text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# New features for extension authors in Visual Studio 2019 version 16.1
Earlier this week, we released [Visual Studio 2019 version 16.1 Preview 1](https://visualstudio.microsoft.com/vs/preview/) (see [release notes](https://docs.microsoft.com/en-us/visualstudio/releases/2019/release-notes-preview)). It’s the first preview of the first update to Visual Studio 2019. If you’re not already set up to get preview releases, then please [do that now](https://visualstudio.microsoft.com/vs/preview/). The preview channel installs side-by-side with the release channel and they don’t interfere with each other. I highly recommend all extension authors install the preview.
Got the 16.1 preview installed now then? That’s great. Here are some features in it you might find interesting.
[This article in blog](https://devblogs.microsoft.com/visualstudio/new-features-for-extension-authors-in-visual-studio-2019-version-16-1/)
Shared Project support
----------------------
There are several reasons why extension authors sometimes must split an extension into multiple projects to support the various versions of Visual Studio. If you’re using an API that did not exist for an earlier version of Visual Studio or if there are breaking changes between the versions you want to support, now there’s a simple easier to split your extension.
With Visual Studio 2019 version 16.1 Preview 1, we’ve added support for referencing Shared Projects from VSIX projects in the same solution.
[](https://devblogs.microsoft.com/visualstudio/wp-content/uploads/sites/4/2019/04/shared-projects.png)
You can place common code in a separate Shared Project that compiles directly into the VSIX projects at build time. The only code that then exists in the VSIX projects themselves, is code that is specific to the Visual Studio version it supports. The result is two separate VSIXs that target their own specific Visual Studio version range and share most of the code from the Shared Project. Checkout the code for the [Extension Manager extension](https://github.com/madskristensen/ExtensionPackTools) that does exactly this.
No more need for .resx file
---------------------------
When adding commands, menus etc. using a VSCT file, you must specify a .resx file marked with the *MergeWithCTO*MSBuild property. The templates in Visual Studio takes care of adding that file and it also adds a .ico file referenced by the .resx file. However, the need for a .resx is an implementation detail and most extensions don’t need to use it.
In an effort to make VSIX project simpler, the requirement for the .resx/.ico files have been removed when using the latest [Microsoft.VSSDK.BuildTools](https://www.nuget.org/packages/Microsoft.VSSDK.BuildTools/) NuGet package version 16.0 or newer.
Behind the scenes, the NuGet package provides an empty .resx to compile with the *MergeWithCTO* property unless you registered your own in the project.
Per-monitor awareness
---------------------
Additional per-monitor awareness support is being enabled in 16.1 with .NET Framework 4.8 installed. Windows Forms UI now better handle DPI scaling across monitors. However, this may cause UI issues in your extension after installing .NET Framework 4.8.
When using Windows Forms in an extension, you can match the Visual Studio 2017 scaling behaviors by wrapping your form or control creation in a *DpiAwareness.EnterDpiScope* call.
```
using (DpiAwareness.EnterDpiScope(DpiAwarenessContext.SystemAware))
using (var form = new MyForm())
{
form.ShowDialog();
}
```
All you need is to add a reference to the [Microsoft.VisualStudio.DpiAwareness](https://www.nuget.org/packages/Microsoft.visualstudio.dpiawareness) NuGet package. Use this package in extensions targeting earlier versions of Visual Studio too but be aware that it will only take effect when running in 16.1 and newer. So, it is safe to use in extensions spanning multiple versions of Visual Studio.
To make it easier to simulate multiple monitors running with different DPI scaling, an engineer from the Visual Studio IDE team built a [handy little tool and put it on GitHub](https://github.com/prasethu/RemoteDesktopEmulator). The team used this tool while they were adding support for per-monitor awareness, so you may find it helpful too.
Read more about how to deal with [per-monitor awareness for extenders](https://docs.microsoft.com/en-us/visualstudio/extensibility/ux-guidelines/per-monitor-awareness-extenders?view=vs-2019).
Synchronous auto-load disabled
------------------------------
18 months ago, we sent an email to extension partners announcing the deprecation of synchronous auto-loading of extension packages. A year ago, we followed up with a [blog post](https://devblogs.microsoft.com/visualstudio/improving-the-responsiveness-of-critical-scenarios-by-updating-auto-load-behavior-for-extensions/) with more details that outlined that synchronously auto-loaded package would be unsupported in a future version of Visual Studio. That version is 16.1.
There are great [samples](https://github.com/Microsoft/VSSDK-Extensibility-Samples/tree/master/AsyncPackageMigration) on how to migrate to *AsyncPackage*with background load enabled, and most extensions today have already made the transition. If you haven’t already, now is a good time to do that before 16.1 goes out of preview.
New SDK meta package
--------------------
The meta package [Microsoft.VisualStudio.SDK](https://www.nuget.org/packages/Microsoft.visualstudio.sdk) is a single NuGet package that references all the various Visual Studio packages that make up the SDK. The cool thing about the meta package is that you have access to all the interfaces and services. In addition, you also avoid issues with mismatched package versions.
When we released Visual Studio 2019 (16.0), the VSIX Project template referenced the 15.9 version of the SDK meta package. That was because the 16.0 version was still under development. All the individual packages had to be published to NuGet before we could take dependency on them from the meta package.
The good news is that now we finally have the 16.0 version ready. You should use it if the lowest version of Visual Studio if your extension supports 16.0. and you can read more about [extension versioning here](https://devblogs.microsoft.com/visualstudio/visual-studio-extensions-and-version-ranges-demystified/).
##### [Mads Kristensen](https://devblogs.microsoft.com/visualstudio/author/madsk/)
Senior Program Manager, Visual Studio Extensibility | https://habr.com/ru/post/448784/ | null | en | null |
# Memcached plugin: NoSQL в MySQL
Здравствуйте! Меня зовут Максим Матюхин, я PHP-программист [Badoo](https://tech.badoo.com/ru/). В своей работе мы активно используем MySQL. Но иногда нам не хватает её производительности, поэтому мы постоянно ищем возможности ускорить её работу.
В 2010 году Yoshinori Matsunobu представил NoSQL-плагин для MySQL под названием HandlerSocket. Заявлялось, что этот плагин позволяет выполнять более 750 000 запросов в секунду. Нам стало любопытно, и мы почти сразу же стали использовать это решение. Результат нам настолько понравился, что мы начали выступать с [докладами](https://www.youtube.com/watch?v=ecIB5X1M1Z8) и писать [статьи](https://habr.com/ru/company/badoo/blog/141945/), рекламируя HandlerSocket.
По-видимому, мы были одними из немногих пользователей этого плагина — начиная с версии MySQL 5.7 он перестал работать. Зато в этой версии появился другой плагин от Oracle — InnoDB memcached plugin, который обещал похожий функционал.
Несмотря на то, что memcached-плагин появился ещё в MySQL 5.6 в 2013 году, статей о нём не так много и в большинстве своём они повторяют документацию: создаётся простая табличка, и к ней делаются запросы через memcached-клиент.
Мы имеем большой опыт работы с Memcached и привыкли к простоте взаимодействия с ним. От InnoDB memcached plugin мы ожидали такой же простоты. Но на деле оказалось, что если паттерны использования плагина хотя бы немного отличаются от описанных в документации и статьях, то всплывает масса нюансов и ограничений, которые определённо стоит учитывать, если вы собираетесь пользоваться плагином.
MySQL HandlerSocket
===================
В этой статье мы так или иначе будем сравнивать новый memcached-плагин со старым HandlerSocket. Поэтому напомню, что представлял собой последний.
После установки плагина HandlerSocket, MySQL начинала слушать два дополнительных порта:
1. Первый порт принимал клиентские запросы для чтения данных.
2. Второй порт принимал клиентские запросы для записи данных.
Клиент должен был установить обычное TCP-соединение на один из этих портов (никакой аутентификации не поддерживалось), и после этого нужно было отправить команду «open index» (специальная команда, с помощью которой клиент сообщал, из какой таблицы какого индекса какие поля мы собираемся читать (или писать)).
Если команда «open index» срабатывала успешно, то потом можно было отправлять GET-ы или INSERT/UPDATE/DELETE-команды в зависимости от порта, на который было установлено соединение.
HandlerSocket позволял выполнять не только GET-ы по первичному ключу, но и простые выборки из неуникального индекса, выборки по диапазону, поддерживал multiget-ы и LIMIT. При этом с таблицей можно было работать как из обычного SQL, так и через плагин. Это, например, позволяло делать какие-то изменения в транзакциях через SQL, а потом читать эти данные через HandlerSocket.
Важно, что HandlerSocket обрабатывал все коннекты ограниченным пулом потоков через epoll, поэтому легко можно было поддерживать десятки тысяч соединений, в то время как в самой MySQL на каждое соединение создаётся поток (thread) и их количество сильно ограничено.
В то же время это всё ещё обычный MySQL сервер — знакомая нам технология. Мы знаем, как его реплицировать и мониторить. Мониторить HandlerSocket сложно, так как он не предоставляет каких-либо специфических метрик; тем не менее некоторые стандартные метрики MySQL и InnoDB оказываются полезными.
Были, конечно, и неудобства, в частности данный плагин не поддерживал работу с типом timestamp. Ну и HandlerSocket протокол сложнее читать и потому сложнее отлаживать.
Подробнее о HandlerSocket можно [почитать здесь](https://yoshinorimatsunobu.blogspot.com/2010/10/using-mysql-as-nosql-story-for.html). Также вы можете посмотреть [одну из наших презентаций](https://www.youtube.com/watch?v=ecIB5X1M1Z8).
InnoDB memcached plugin
=======================
Что же нам предлагает новый memcached plugin?
Как следует из названия, его идея в том, чтобы использовать memcached-клиент для работы с MySQL и через memcached-команды получать и сохранять данные.
Об основных преимуществах плагина можно [прочитать здесь](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-benefits.html).
Нас больше всего заинтересовали следующие:
1. Низкое потребление CPU.
2. Данные хранятся в InnoDB, что даёт определённые гарантии.
3. С данными можно работать как через Memcached, так и через SQL; их можно реплицировать встроенными в MySQL средствами.
К этому списку можно добавить ещё такие плюсы, как:
1. Быстрый и дешёвый коннект. Обычное MySQL-соединение обрабатывается одним thread-ом, и количество thread-ов ограничено, а в memcached-плагине один thread обрабатывает все соединения в event loop-е.
2. Возможность одним GET-запросом запросить сразу несколько ключей.
3. Если сравнивать с MySQL HandlerSocket, то в memcached-плагине не надо использовать команду «Open Table» и все операции чтения и записи происходят на одном порте.
Больше деталей о работе плагина можно найти в официальной [документации](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached.html). Для нас самыми полезными показались страницы:
1. [InnoDB memcached Architecture](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-intro.html).
2. [InnoDB memcached Plugin Internals](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-internals.html).
После установки плагина MySQL начинает принимать соединения на порте 11211 (стандартный memcached-порт). Также появляется специальная база данных (схема) innodb\_memcache, в которой вы будете конфигурировать доступ к своим таблицам.
Простой пример
==============
Допустим, у вас уже есть таблица, с которой вы хотите работать через memcached-протокол:
```
CREATE TABLE `auth` (
`email` varchar(96) NOT NULL,
`password` varchar(64) NOT NULL,
`type` varchar(32) NOT NULL DEFAULT '',
PRIMARY KEY (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
```
и вы хотите получать и изменять данные по первичному ключу.
Вам нужно сначала описать соответствие между memcached-ключом и SQL-таблицей в таблице innodb\_memcache.containers. Эта таблица выглядит примерно так (я убрал описание кодировок, чтобы было проще читать):
```
CREATE TABLE `containers` (
`name` varchar(50) NOT NULL,
`db_schema` varchar(250) NOT NULL,
`db_table` varchar(250) NOT NULL,
`key_columns` varchar(250) NOT NULL,
`value_columns` varchar(250) DEFAULT NULL,
`flags` varchar(250) NOT NULL DEFAULT '0',
`cas_column` varchar(250) DEFAULT NULL,
`expire_time_column` varchar(250) DEFAULT NULL,
`unique_idx_name_on_key` varchar(250) NOT NULL,
PRIMARY KEY (`name`)
) ENGINE=InnoDB DEFAULT
```
Самые важные поля:
* name — префикс вашего Memcached-ключа;
* db\_schema — название базы (схемы);
* db\_table — ваша таблица;
* key\_columns — название поля в таблице, по которому будем искать (обычно это ваш primary key);
* value\_columns — список полей из таблицы, которые будут доступны memcached-плагину;
* unique\_idx\_name\_on\_key — индекс, по которому нужно искать (несмотря на то, что вы уже указали key\_columns, они могут входить в разные индексы и нужно явно указать индекс).
Остальные поля для начала не очень важны.
Добавим описание нашей таблицы в innodb\_memcache.containers:
```
INSERT INTO innodb_memcache.containers SET
name='auth',
db_schema='test',
db_table='auth',
key_columns='email',
value_columns='password|type',
flags='0',
cas_column='0',
expire_time_column='0',
unique_idx_name_on_key='PRIMARY';
```
В этом примере name=’auth’ — это префикс нашего memcached-ключа. В документации он зачастую называется table\_id, и далее в статье я буду использовать этот термин.
Теперь TELNET-ом подключимся к memcached-плагину и попробуем сохранить и получить данные:
```
[21:26:22] maxm@localhost: ~> telnet memchached-mysql.dev 11211
Trying 127.0.0.1...
Connected to memchached-mysql.dev.
Escape character is '^]'.
get @@auth.max@example.com
END
set @@auth.max@example.com 0 0 10
1234567|89
STORED
get @@auth.max@example.com
VALUE @@auth.max@example.com 0 10
1234567|89
END
```
Сначала мы отправили GET-запрос, он нам ничего не вернул. Потом мы сохранили данные SET-запросом, после чего получили их обратно GET-ом.
GET вернул такую строку: 1234567|89. Это значения полей «password» и «type», разделённые символом "|". Поля возвращаются в том порядке, в каком они были описаны в innodb\_memcache.containers.value\_columns.
Возможно, вы сейчас задались вопросом: «А что будет, если в «password» встретится символ "|"?» Об этом я расскажу ниже.
Через SQL эти данные тоже доступны:
```
MySQL [(none)]> select * from auth where email='max@example.com';
+-----------------+----------+------+
| email
| password | type |
+-----------------+----------+------+
| max@example.com | 1234567 | 89 |
+-----------------+----------+------+
1 row in set (0.00 sec)
```
Дефолтный table\_id
-------------------
Есть ещё такой режим работы:
```
get @@auth
VALUE @@auth 0 21
test/auth
END
get max@example.com
VALUE max@example.com 0 10
1234567|99
END
set ivan@example.com 0 0 10
qwerty|xxx
STORED
get ivan@example.com
VALUE ivan@example.com 0 10
qwerty|xxx
END
```
В этом примере запросом get @@auth мы делаем table\_id auth префиксом по умолчанию для данного соединения. После этого все последующие запросы можно делать без указания table\_id.
Пока всё просто и логично. Но если начать разбираться, то обнаруживается много нюансов. Расскажу о том, что нашли мы.
Нюансы
======
Кеширование таблицы innodb\_memcache.containers
-----------------------------------------------
Memcached-плагин читает таблицу innodb\_memcache.containers один раз при старте. Далее, если по Memcached-протоколу приходит неизвестный table\_id, плагин ищет его в таблице. Поэтому вы легко можете добавлять новые ключи (table\_id), но если захотите изменить настройки существующего table\_id, придётся перезапускать memcached-плагин:
```
mysql> UNINSTALL PLUGIN daemon_memcached;
mysql> INSTALL PLUGIN daemon_memcached soname "libmemcached.so";
```
В промежутке между этими двумя запросами Memcached-интерфейс работать не будет. Из-за этого зачастую проще создать новый table\_id, чем менять существующий и перезапускать плагин.
Для нас было неожиданностью, что такой важный нюанс работы плагина описан на странице [Adapting a memcached Application for the InnoDB memcached Plugin](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-porting-memcached.html), — не очень логичное место для такой информации.
Flags, cas\_column, expire\_time\_column
----------------------------------------
Данные поля нужны для имитации некоторых особенностей Memcached. Документация по ним противоречива. Большинство примеров в ней иллюстрируют работу с таблицами, в которых эти поля есть. Может возникнуть опасение, что вам понадобится добавлять их в ваши таблицы (а это как минимум три INT-поля). Но нет. Если у вас в таблицах нет таких полей и вы не собираетесь использовать такой функционал Memcached, как CAS, expiration или флаги, то вам не надо добавлять эти поля в таблицы.
При конфигурации таблицы в innodb\_memcache.containers нужно в эти поля вписать ‘0’, сделать именно строку с нулём:
```
INSERT INTO innodb_memcache.containers SET
name='auth',
db_schema='test',
db_table='auth',
key_columns='email',
value_columns='password|type',
flags='0',
cas_column='0',
expire_time_column='0',
unique_idx_name_on_key='PRIMARY';
```
Досадно, что у cas\_column и expire\_time\_column значение по умолчанию — NULL, и, если вы выполните INSERT INTO innodb\_memcache.containers, не указав значение ‘0’ для этих полей, в них сохранится NULL и этот memcache-префикс попросту не будет работать.
Типы данных
-----------
Из документации не очень понятно, какие типы данных можно использовать при работе с плагином. В нескольких местах сказано, что плагин может работать только с текстовыми полями (CHAR, VARCHAR, BLOB). Вот здесь: [Adapting an Existing MySQL Schema for the InnoDB memcached Plugin](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-porting-mysql.html) предлагают числа хранить в строковых полях, и если вам потом из SQL надо работать с этими числовыми полями, то создавать VIEW, в котором VARCHAR-поля с числами будут конвертироваться в INTEGER-поля:
```
CREATE VIEW numbers AS SELECT c1 KEY, CAST(c2 AS UNSIGNED INTEGER) val
FROM demo_test WHERE c2 BETWEEN '0' and '9999999999';
```
Однако кое-где в документации всё же написано, что можно работать с числами. У нас пока имеется только реальный продакшен-опыт с текстовыми полями, но результаты экспериментов показывают, что с числами плагин тоже работает:
```
CREATE TABLE `numbers` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`counter` int(10) unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB
INSERT INTO innodb_memcache.containers SET name='numbers', db_schema='test', db_table='numbers', key_columns='id', value_columns='counter', flags='0', cas_column='0',expire_time_column='0',unique_idx_name_on_key='PRIMARY';
```
После этого через Memcached-протокол:
```
get @@numbers.1
END
set @@numbers.1 0 0 2
12
STORED
get @@numbers.1
VALUE @@numbers.1 0 2
12
END
```
Мы видим, что memcached-плагин может вернуть любые типы данных. Но он их возвращает в том виде, в котором они лежат в InnoDB, поэтому, например, в случае с timestamp/datetime/float/decimal/JSON возвращается бинарная строка. Но целые числа возвращаются такими, какими мы видим их через SQL.
Multiget
--------
Memcached-протокол позволяет запрашивать несколько ключей одним запросом:
```
get @@numbers.2 @@numbers.1
VALUE @@numbers.2 0 2
12
VALUE @@numbers.1 0 2
13
END
```
То, что multiget работает, — уже хорошо. Но он работает в рамках одного table\_id:
```
get @@auth.ivan@example.com @@numbers.2
VALUE @@auth.ivan@example.com 0 10
qwerty|xxx
END
```
В документации этот момент описан здесь: <https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-multiple-get-range-query.html>. Оказывается, в multiget-е можно указать table\_id только для первого ключа, если все остальные ключи берутся из дефолтного table\_id (пример из документации):
```
get @@aaa.AA BB
VALUE @@aaa.AA 8 12
HELLO, HELLO
VALUE BB 10 16
GOODBYE, GOODBYE
END
```
В этом примере второй ключ берётся из дефолтного table\_id. Мы могли бы указать намного больше ключей из дефолтного table\_id, а для первого ключа мы указали отдельный table\_id, и такая возможность есть только в случае с первым ключом.
Можно сказать, что multiget работает в рамках одной таблицы, потому что полагаться на такую логику в продакшен-коде совсем не хочется: она неочевидна, об этом легко забыть, ошибиться.
Если сравнивать с HandlerSocket, то там тоже multiget работал в рамках одной таблицы. Но это ограничение выглядело естественным: клиент открывает индекс в таблице и запрашивает из него одно или несколько значений. А вот при работе c memcached-плагином multiget по нескольким ключам с разными префиксами — нормальная практика. И от MySQL memcached-плагина ожидаешь того же. Но нет :(
INCR, DEL
---------
Я уже приводил примеры GET-/SET-запросов. У INCR- и DEL-запросов есть особенность. Она заключается в том, что они работают только при использовании дефолтного table\_id:
```
DELETE @@numbers.1
ERROR
get @@numbers
VALUE @@numbers 0 24
test/numbers
END
delete 1
DELETED
```
Ограничения memcached-протокола
-------------------------------
Memcached имеет текстовый протокол, что накладывает некоторые ограничения. Например, memcached-ключи не должны содержать пробельные символы (пробел, перевод строки). Если посмотреть ещё раз на описание таблицы из нашего примера:
```
CREATE TABLE `auth` (
`email` varchar(96) NOT NULL,
`password` varchar(64) NOT NULL,
`type` varchar(32) NOT NULL DEFAULT '',
PRIMARY KEY (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
```
то это значит, что в поле «email» не должно быть таких символов.
Также длина memcached-ключей должна быть менее 250 байт (байт, а не символов). Если отправить больше, получите ошибку:
```
"CLIENT_ERROR bad command line format"
```
Помимо этого, надо учитывать тот факт, что memcached-плагин добавляет в memcached-протокол свой синтаксис. Например, он использует символ "|" в качестве разделителя полей в ответе. Вам нужно следить за тем, чтобы в вашей таблице не использовался этот символ. Разделитель можно настроить, но параметры настройки будут распространяться на все таблицы на всём MySQL-сервере.
Разделитель полей value\_columns
--------------------------------
Если через memcached-протокол необходимо вернуть несколько колонок, как в нашем первом примере:
```
get @@auth.max@example.com
VALUE @@auth.max@example.com 0 10
1234567|89
END
```
то значения колонок разделяются стандартным разделителем "|". Возникает вопрос: «А что будет, если, например, в первом поле в строке будет символ "|"»? Memcached-плагин в этом случае вернёт строку как есть, примерно так: 1234|567|89. В общем случае нельзя понять, где здесь какое поле.
Поэтому важно сразу выбирать правильный разделитель. А поскольку он будет использоваться для всех ключей всех таблиц, это должен быть универсальный символ, который не будет встречаться ни в одном поле, с которым которым вы будете работать через memcached-протокол.
Резюме
======
Нельзя сказать, что memcached-плагин плох. Но складывается впечатление, что он был написан для определённой схемы работы: MySQL-сервер с одной таблицей, к которой есть доступ по memcached-протоколу, и этот table\_id сделан дефолтным. Клиенты устанавливают длительное (persistent) соединение с Memcached-плагином и делают запросы к дефолтному table\_id. Наверное, в такой схеме всё будет работать без нареканий. Если же отойти от неё, натыкаешься на различные неудобства.
Возможно, вы ожидали увидеть какие-нибудь отчёты о производительности плагина. Но мы пока не решились использовать его в высоконагруженных местах. Мы использовали его только в нескольких не очень нагруженных системах и там он работает примерно с такой же скоростью, как HandlerSocket, но честных бенчмарков мы не делали. Но всё же плагин предоставляет такой интерфейс, с которым программист может легко допустить ошибку, — нужно много нюансов держать в голове. Поэтому массово использовать этот плагин мы пока не готовы.
Мы завели несколько feature requests в баг-трекере MySQL:
<https://bugs.mysql.com/bug.php?id=95091>
<https://bugs.mysql.com/bug.php?id=95092>
<https://bugs.mysql.com/bug.php?id=95093>
<https://bugs.mysql.com/bug.php?id=95094>
Будем надеяться, команда разработчиков memcached-плагина будет совершенствовать свой продукт. | https://habr.com/ru/post/453742/ | null | ru | null |
# Обновление Android Jetpack: Activity Result API и рефакторинг Fragment
Привет! С вами Android Broadcast. Прошли 2 недели и очередной релиз библиотек Jetpack от Google уже с нами. Вышло долгожданное исправление множества багов в Fragment из-за рефакторинга внутри FragmentManager, Activity Result API и много другого. Все самое интересное вы найдете ниже, а все подробности [на сайте](https://developer.android.com/jetpack/androidx/versions/all-channel#february_10_2021_2)
> *Если вы хотите узнавать про последние новости Android разработки сразу, тогда подпишитесь на* [*Telegram канал Android Broadcast*](https://t.me/android_broadcast) *или следите за ними в формате видео на* [*YouTube канале*](https://youtube.com/androidBroadcast)*, а также* [*подкасте*](https://soundcloud.com/android_broadcast)
>
>
Activity 1.2.0
--------------
Все изменения [здесь](https://developer.android.com/jetpack/androidx/releases/activity#1.2.0)
* [Activity Result API](https://developer.android.com/training/basics/intents/result) - новое API для получения результата вызова Activity
```
val getContent = registerForActivityResult(GetContent()) { uri: Uri? ->
// Handle the returned Uri
}
override fun onCreate(savedInstanceState: Bundle?) {
// ...
val selectButton = findViewById(R.id.select\_button)
selectButton.setOnClickListener {
// Pass in the mime type you'd like to allow the user to select
// as the input
getContent.launch("image/\*")
}
}
```
* ComponentActivity теперь реализует [ContextAware](https://developer.android.com/reference/androidx/activity/contextaware/ContextAware), что позволяет асинхронно получить Context до вызова `Activity.onCreate()`. Поддержка Coroutine уже добавлена
* Backport метода [Activity.reportFullyDrawn()](https://developer.android.com/reference/android/app/Activity#reportFullyDrawn()), который теперь работает на всех версиях API, исправлены баги и добавлен трейсинг
* Добавлена поддержка [ViewTreeLifecycleOwner](https://developer.android.com/reference/androidx/lifecycle/ViewTreeLifecycleOwner)
Fragment 1.3.0
--------------
Все изменения [здесь](https://developer.android.com/jetpack/androidx/releases/fragment#1.3.0)
* Большой рефакторинг внутри FragmentManager, который исправил множество багов в работе Fragment. Подробности читайте в [статье от Ian Lake](https://medium.com/androiddevelopers/fragments-rebuilding-the-internals-61913f8bf48e)
* Интеграция [Activity Result API](https://developer.android.com/training/basics/intents/result)
* Новое API для передачи результата между двумя Fragment
```
// Fragment1
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Use the Kotlin extension in the fragment-ktx artifact
setFragmentResultListener("requestKey") { requestKey, bundle ->
// We use a String here, but any type that can be put in a Bundle is supported
val result = bundle.getString("bundleKey")
// Do something with the result
}
}
```
```
// Fragment 2
button.setOnClickListener {
val result = "result"
// Use the Kotlin extension in the fragment-ktx artifact
setFragmentResult("requestKey", bundleOf("bundleKey" to result))
}
```
* [FragmentOnAttachListener](https://developer.android.com/reference/androidx/fragment/app/FragmentOnAttachListener) - замена `onAttachFragment()` из `FragmentActivity` и `Fragment`, которая позволяет делегировать событие различным компонентам.
* Стандартные эффекты анимаций `TRANSITION_*` теперь используют [Animator](https://developer.android.com/reference/android/animation/Animator) вместо [Animation](https://developer.android.com/reference/kotlin/android/view/animation/Animation)
* Улучшения FragmentScenario
* [Fragment.setRetainInstance()](https://developer.android.com/reference/androidx/fragment/app/Fragment#setRetainInstance(boolean)) теперь deprecated. Используйте ViewModel.
* Добавлена поддержка [ViewTreeLifecycleOwner](https://developer.android.com/reference/androidx/lifecycle/ViewTreeLifecycleOwner)
* Адаптеры, использующие Fragment, для ViewPager 1 теперь deprecated. [Мигрируйте на ViewPager 2](https://developer.android.com/training/animation/vp2-migration).
Lifecycle 2.3.0
---------------
Все изменения [здесь](https://developer.android.com/jetpack/androidx/releases/lifecycle#2.3.0)
* `SavedStateHandle` теперь поддерживает не parcelable классы
* `LifecycleRegistry` теперь использует `DESTROYED` как последнее состояние
* `LifecycleRegistry` теперь проверяет что методы вызываются на главном потоке, в противном случае - креш
* Добавлены методы `downFrom(State)`, `downTo(State)`, `upFrom(State)`, `upTo(State)` для генерации события, чтобы перевести Lifecycle в нужное состояние необходимой последовательностью событий.
* Новое API [ViewTreeLifecycleOwner](https://developer.android.com/reference/androidx/lifecycle/ViewTreeLifecycleOwner), которое позволяет получить `LifecycleOwner` and `ViewModelStoreOwner`, основываясь куда добавлена View. Например, это уже реализовано в Activity 1.2.0 и Fragment 1.3.0.
* Kotlin расширение [LiveData.observe()](https://developer.android.google.cn/reference/kotlin/androidx/lifecycle/package-summary?hl=ru#(androidx.lifecycle.LiveData).observe(androidx.lifecycle.LifecycleOwner,%20kotlin.Function1)) теперь deprecated. Оно больше не нужно из-за появления SAM для Kotlin интерфейсов.
SavedState 1.1.0
----------------
Все изменения [здесь](https://developer.android.com/jetpack/androidx/releases/savedstate#1.1.0)
* Добавлено API `ViewTreeSavedStateRegistryOwner`, которое позволяет получить `SavedStateRegistry` на основе View.
* `savedstate-ktx`
Core Role 1.0.0
---------------
Все изменения [здесь](https://developer.android.com/jetpack/androidx/releases/core#core-role-1.0.0)
* Добавлено API [RoleManagerCompat](https://developer.android.com/reference/androidx/core/role/RoleManagerCompat) | https://habr.com/ru/post/541942/ | null | ru | null |
# Как избавиться от старого продукта, не удаляя продукт?
Привет! Согласитесь, во многих крупных компаниях рано или поздно возникает проблема — какой-то прибыльный продукт превращается в legacy. Причем обычно менеджмент это осознает, когда хочет "просто" поменять одну цифру на другую к вечеру, а разработчики оценивают это в два спринта. Или когда разработчики один за другим теряют мотивацию и покидают продукт, а новые кандидаты выбирают другие офферы.
Часто эту проблему пытаются решить переписыванием продукта с нуля. Но переписывание с нуля кроет в себе отложенную проблему, так как можно потерять мелкие нюансы и в итоге переписанный продукт будет поначалу болеть "детскими болячками", которые много лет назад были вылечены в legacy. Мы, в АльфаСтраховании считаем, что все члены команды разработки должны понимать, что их материальный успех зависит от того, сколько компания зарабатывает, используя написанный ими продукт. А сколько денег принесет продукт, который постоянно спотыкается и плюется ошибками? И клиентов не удовлетворить ответами из серии: "Ну зато у нас тут микросервисы и неблокирующие стримы". Им важно, чтобы продукт работал быстро и стабильно. А написан ли он в виде скрипта на bash или в виде микросервисов на Scala, потребителям наплевать. Конечно, разработчикам не нужно забывать и о своём развитии — регулярно изучать новые технологии, получать опыт использования их в продуктиве, но не в ущерб бизнесу.
Что с этим делать? Мы нашли для себя ответ, успешно применили на одном продукте и надеемся что этот подход или его части помогут и другим.
Примерно в 2014 г., когда у нас в компании вся разработка, по сути, была только в СУБД Oracle (с помощью PL/SQL), у кого-то возникла идея написать продукт на Java. Поставили разработчикам Java и сказали писать на ней. Экспертизы по Java ни у кого не было, архитектуру никто не проектировал, процедурный стиль программирования просто перенесли на Java, а для отрисовки UI разработчики выбрали [Vaadin Framework](https://vaadin.com/). На продукте разработчики менялись с регулярностью, кто-то пытался переписать отдельные части, кто-то создавал новые классы, соответствующие ООП, но архитектуры по прежнему не было и официально бизнес не давал времени на рефакторинг. Скорость разработки фич была невысокой, в продукте часто появлялись ошибки, они долго находились и исправлялись, а мотивация разработчиков медленно и верно двигалась к 0. Бизнес это стало не устраивать, разработчиков тоже, и в какой-то момент встал вопрос, что делать с продуктом. И, как водится, ответ был такой: "Выкинуть и написать с нуля". Бизнес обеспокоился таким ответом и решил собрать "экспертную группу", чтобы они посмотрели на продукт и решили, что с ним можно сделать с минимальными потерями.
Вначале мы, как экспертная группа, решили конкретизировать все проблемы продукта, затем попробовать их сгруппировать и найти решения для каждой группы. Для этого мы опросили команду разработки, владельца продукта и даже узнали у некоторых кандидатов почему они отказались от офферов. Основные проблемы оказались такие:
Посмотрев на эти проблемы стало ясно, что их можно решить с помощью трех вещей: Архитектурного подхода, Шаблонов проектирования и Spring Framework.
В качестве архитектурного подхода (архитектурного паттерна) мы выбрали [MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) плюс слой сервисов. Да, мы оставили монолит. Думаю не стоит в этой статье еще раз доказывать, что микросервисы это не серебряная пуля, приведу лишь пару доводов, почему все-таки монолит. UI в продукте уже был (Vaadin), он позволял Java разработчикам довольно быстро разрабатывать нормально выглядящий UI, весь функционал хорошо вписывался в одну доменную область, и монолит справлялся с нагрузкой с запасом. Поэтому плюсы монолита (простое и быстрое локальное развертывание и отсутствие внутренних интеграций) перевешивали минусы (горизонтальное масштабирование и масштабирование отдельных сервисов). Конечно эти плюсы монолита были превращены в архитектурные минусы — разработчики с радостью связывали UI компоненты с БД, добавляли какие-то утилитарные методы в классы, отвечающие только за отрисовку UI, вызывали методы одного UI класса из другого, что также привело к сильному запутыванию кода. Но наш архитектурный принцип жестко регламентировал, что так делать нельзя. Взаимодействие должно быть только таким:
Сервисы отвечали за бизнес-логику, чтобы обеспечить доступ к бизнес-функционалу и через API, и через пользовательский интерфейс. Т.е. оперировали бизнес-сущностями, а Controller отвечал только за поведение View. Controller включал в себя нужные сервисы и либо получал из них данные для отображения на UI, либо передавал данные по действиям юзера. Также эти же сервисы использовались через API. В дальнейшем можно расширять RestController (он уже был), менять технологию UI и все это без изменения бизнес-логики.
Из шаблонов проектирования основными стали *Абстрактная фабрика* и *Стратегия*. Основная суть приложения была дать партнерам возможность продавать наши страховки. Все было одинаково, менялись только объекты страхования и настройки для партнеров. Поэтому *Абстрактная фабрика* здесь очень подходила. А *Стратегию* использовали для реализации различных способов оплаты — страховку можно было оплатить разными способами и это влияло как на передаваемые данные, так и на способ обработки ответа от платежных систем. Позже все увидели, что паттерны очень сильно сократили объем дублированного кода и исключили "размазывание" бизнес-логики по нескольким классам.
С внедрением Spring были свои нюансы. В продукте было много самописных singleton, статических полей и методов — делать их всех бинами, а потом еще заменять их внедрение во всех классах за один раз выглядело нелегкой задачей. Мы нашли [такое интересное решение](https://foojay.io/today/statically-spilling-your-spring-beans), которое нам помогло переводить самописные singleton на Spring бины постепенно. Вот пример, когда у нас уже есть композиция, и мы сделали наш самописный singleton `MyBusinessProcess` Spring бином:
```
class SuperService {
public void doSuperSmth() {
Service.getInstance().doSmth();
}
}
class Service {
…
public static void getInstance() {...}
public void doSmth() {
//MyBusinessProcess.getInstance().startProcess();
Context.getBean(MyBusinessProcess.class).startProcess();
}
}
```
Как видите, нам нужно было только поменять вызов одного статического метода `MyBusinessProcess.getInstance()` на другой `Context.getBean(MyBusinessProcess.class)`. Переведя приложение на SpringBoot и проверив этот подход с бинами выяснили, что это рабочий метод и благодаря ему можно проводить архитектурный и стилистический рефакторинг постепенно в спринтах. Мы договорились с бизнесом, что команда сможет тратить 40% спринта на рефакторинг. А чтобы не тыкаться просто по всему проекту, то рефакторить классы, которые затрагиваются в рамках бизнес-задачи. Если какие-то места не получается просто "зацепить" заодно, в рамках бизнес-задачи, договорились их заводить как задачи на рефакторинг в бэклог.
Ну вот, когда все теоретические и экспериментальные этапы были завершены, надо было приступать к непосредственно рефакторингу. В этом продукте не было тестов. Совсем. Поэтому любые изменения были опасны, а покрыть юнит-тестами всю систему, переполненную статическими полями и методами, было задачей не из легких. Хорошо, что в этом продукте был не сильно сложный UI и были REST методы, затрагивающие основные процессы. Перед началом изменений мы написали функциональные тесты на API — после этого можно было уже заниматься рефакторингом, не боясь кардинально что-то сломать.
Процесс пошел, на код ревью проверялось также соответствие принципам, анализатор кода проверял уровень покрытия тестами и баги. Через несколько спринтов сквозь трущобы начал прорисовываться стройный облик четко выстроенной системы.
Из нашей истории можно сделать минимум три вывода:
1. Если решили использовать технологию, позаботьтесь о том, чтобы в команде был хотя бы один профессионал, который имеет в ней опыт
2. Прежде чем делать систему необходимо спроектировать архитектуру, и если через какое-то время бизнес-логика кардинально меняется, необходимо перепроектировать продукт, давать время на рефакторинг и не копить технический долг
3. Необходимо давать разработчикам возможность использовать в продукте современные mainstream технологии
На все это аргумент один — это экономически выгодно в среднесрочной и долгосрочной перспективе.
Чтобы не превращать пост в трехтомник, мы опустили многие детали. В комментариях с удовольствием ответим на вопросы и можем что-то раскрыть подробнее. Если у вас есть свои успешные подходы, будем рады услышать. | https://habr.com/ru/post/682894/ | null | ru | null |
# Swift и время компиляции
*Пост основан на статье [medium.com/@RobertGummesson/regarding-swift-build-time-optimizations-fc92cdd91e31](https://medium.com/@RobertGummesson/regarding-swift-build-time-optimizations-fc92cdd91e31) + небольшие изменения/дополнения, то есть текст идет от моего лица, не третьего.*
Всем знакома ситуация после изменения файла(ов) или просто переоткрытия проекта:
Нужно сказать, что какой-то особой проблемы с компиляцией я не замечал когда писал на Objective-C, но всё изменилось с приходом в массы swift. Я частично отвечал за CI сервер по сборке iOS проектов. Так вот, проекты на swift собирались невыносимо медленно. Еще разработчики любят тащить поды (cocoapods зависимости) на каждый чих в свои swift проекты, иногда, в безумном количестве. Так вот, компиляция всей этой смеси могла продолжаться несколько минут, хотя сам проект состоял буквально из пары десятков классов. Ну ладно, как бы ясно, язык новый, на этапе компиляции происходит намного больше проверок, чем в том же ObjC, глупо ожидать, что она будет работать быстрее (да, swift это строго типизированный язык и всё должно быть максимально явно объявлено (как в Java, например), в отличии от ObjC, где не всё так строго). Разработчики swift с каждым релизом обещают в x раз ускорения скорости компиляции. Ну вроде, действительно, сборка 2.0 и уже потом 2.2 стала работать быстрее, вот вот на носу уже 3.0 версия (конец года).
Компилятор компилятором, но оказывается, что время сборки проекта можно катастрофически увеличить буквально несколькими строчками кода. Часть примеров взято из вышеупомянутой статьи, часть самописные (не поверил автору и хотелось самому проверить). Время замерял через
```
time swiftc -Onone file.swift
```
Список того, что может замедлить ваш компилятор
-----------------------------------------------
### Неосторожное использование Nil Coalescing Operator
```
func defIfNil(string: String?) -> String {
return string ?? "default value"
}
```
Оператор **??** разворачивает *Optional*, если там что-то есть, то возвращает значение иначе выполняется выражение после **??**. Если связать подряд несколько этих операторов, то можем получить увеличение времени компиляции на порядок (не ошибся, на порядок :) ).
```
// Без оператора компиляция занимает 0,09 секунд
func fn() -> Int {
let a: Int? = nil
let b: Int? = nil
let c: Int? = nil
var res: Int = 999
if let a = a {
res += a
}
if let b = b {
res += b
}
if let c = c {
res += c
}
return res
}
```
```
// С операторами 3,65 секунд
func fn() -> Int {
let a: Int? = nil
let b: Int? = nil
let c: Int? = nil
return 999 + (a ?? 0) + (b ?? 0) + (c ?? 0)
}
```
Да, в 40 раз :). Но мои наблюдения показали, что проблема возникает, только если использовать больше двух таких операторов в одном выражении, то есть:
```
return 999 + (a ?? 0) + (b ?? 0)
```
уже будет ок.
### Объединение массивов
Я иногда пишу скрипты на руби, руби потрясающий язык, где большое количество операций можно уложить в пару строк кода, без потери читабельности. Особенно нравится работать с массивами. То есть, это вполне обычный код на руби для меня:
```
res = ar1.filter { ... } + ar2.map { ... } + ar3.flatMap { ... }
```
Если же в этом стиле напишем на swift, то это может очень сильно подпортить время компиляции, хотя конструкции языка позволяют так писать. Ну и как бы все сейчас только и говорят об иммутабельности, поэтому создавать мутабельный массив не комильфо и вообще дурной тон, пфф. Но что же мы получим, если будем так писать?
```
// Время 0,15 секунд
func fn() -> [Int] {
let ar1 = (1...50).map { $0 }.filter { $0 % 2 == 0 }
let ar2 = [4, 8, 15, 16, 23, 42].map { $0 * 2 }
var ar3 = (1..<20).map { $0 }
ar3.appendContentsOf(ar1)
ar3.appendContentsOf(ar2)
return ar3
}
```
```
// Время 2,86 секунд
func fn() -> [Int] {
let ar1 = (1...50).map { $0 }
let ar2 = [4, 8, 15, 16, 23, 42]
return (1..<20).map { $0 } + ar1.filter { $0 % 2 == 0 } + ar2.map { $0 * 2 }
}
```
Разница почти в 20 раз. А ведь с массивами мы работаем в каждом втором методе. Но стоит отметить, такое поведение компилятора я получил, если суммирую больше чем два массива в одном выражении, то есть:
```
return ar1.filter { $0 % 2 == 0 } + ar2.map { $0 * 2 }
```
уже ок.
### Ternary operator
Автор оригинального поста приводит пример, из которого следует, что не стоит использовать сложные выражения вместе с тернарным оператором:
```
// Build time: 0,24 секунды
let labelNames = type == 0 ? (1...5).map{type0ToString($0)} : (0...2).map{type1ToString($0)}
// Build time: 0,017 секунд
var labelNames: [String]
if type == 0 {
labelNames = (1...5).map{type0ToString($0)}
} else {
labelNames = (0...2).map{type1ToString($0)}
}
```
### Избыточные касты
Тут автор просто убрал лишние касты в *CGFloat* и получил существенную скорость в компиляции файла:
```
// Build time: 3,43 секунды
return CGFloat(M_PI) * (CGFloat((hour + hourDelta + CGFloat(minute + minuteDelta) / 60) * 5) - 15) * unit / 180
// Build time: 0,003 секунды
return CGFloat(M_PI) * ((hour + hourDelta + (minute + minuteDelta) / 60) * 5 - 15) * unit / 180
```
### Сложные выражения
Тут автор имеет ввиду, смесь локальных переменных, переменных класса и инстансов класса вместе с функциями:
```
// Build time: 1,43 секунды
let expansion = a - b - c + round(d * 0.66) + e
// Build time: 0,035 секунд
let expansion = a - b - c + d * 0.66 + e
```
Правда тут автор оригинального поста так и не понял почему так.
---
В общем можно подвести итог, что использовать сложные фичи/конструкции языка это классно, но стоит помнить, что весь этот синтакчический сахар может существенно повлиять как на время компиляции, так и на сам рантайм. Говорят, если писать на скале под андроид, то за счет всего этого синтаксического сахара, очень быстро можно упереться в лимит количества методов и нужно будет прибегать к лишним телодвижениям.
пс.
Один из разработчиков swift языка дал небольшой ответ на этот пост оригинальному автору, что в swift 3 сделано много улучшений в эту сторону:
> [@matt\_sven](https://twitter.com/matt_sven) [@NatashaTheRobot](https://twitter.com/NatashaTheRobot) [@RobertGummesson](https://twitter.com/RobertGummesson) [@iOSGoodies](https://twitter.com/iOSGoodies) A lot of improvements made it into the Swift 3 branch after 2.x branched.
>
> — Joe Groff (@jckarter) [6 мая 2016 г.](https://twitter.com/jckarter/status/728584734754754560) | https://habr.com/ru/post/283106/ | null | ru | null |
# Стилизуя нестандартно
Вот есть у нас приложение. Серьезное, большое, взрослое. Обходимся практически без стилей, но без беспорядка; используем себе виджеты из AppCompat, но уже затянули тему из Material Design Components (MDC) и подумываем о полноценной миграции.
И вдруг появляется задача на полный redesign. А у нового дизайна со старым общая разве что бизнес логика. Компоненты новые, шрифты нестандартные, цвета (за исключением фирменных) другие. В общем приходит осознание того, что пришло время переезжать на MDC.
Но не все так просто:
* Redesign предполагается по частям. То есть в приложении будут как экраны со старым, так и с новым внешним видом
* Цвета и типографика в новом дизайне отличны от того, что рекомендует MDC. Хотя принципы именования схожи
* Presentation слой разбит на отдельные ui модули. Причем некоторые из них используются другим приложением. Учитывая, что обходимся без стилей, для стилизации в таких модулях некоторые свойства спрятаны за атрибуты: цвета, текстовые стили, строки и многое другое
* Существует налаженная схема на предмет того, как работать с вышеупомянутыми ui модулями. В частности с атрибутами. А значит и с цветами, текстовыми стилями, строками и прочим. А при MDC хотелось бы использовать стили
Далее делюсь опытом того, как справиться с этими трудностями: как при переезде на MDC частично стилизовать Android приложение с независимыми ui модулями, абстрагироваться от дизайн системы и при этом ничего не сломать. Бонусом - советы и разбор сложностей, с которыми я столкнулся.
лего равно стили### Про ui модули
Есть ui модули. Они не зависят от проекта. Лежат отдельно от него.
Внутри каждого из проектов есть корневой модуль. Назовем его **core-presentation**. Он зависит от тех ui модулей, которые используются в данном приложении. Подключаются модули как обычная gradle зависимость.
Возникает вопрос. А как стилизовать-то? Если коротко, то с помощью атрибутов. Внутри каждого такого ui модуля определены используемые атрибуты, которые должны быть реализованы темой приложения:
```
```
Используются они примерно так:
### Ближе к "теме" (стилю)
У меня появился план. Простой, но от того не менее гениальный. План базировался на нескольких принципах, а я, в свою очередь, его придерживался.
Собственно, принципы:
* Так как MDC тема уже затянута, ничто не мешает использовать виджеты из MDC. Никакого **AppCompat**'a. И хоть под капотом framework компоненты переопределяются в аналоги из **MDC**, явное использование последних компонент все же нагляднее:
```
```
* Все компоненты (классы, ресурсы, атрибуты) нового ui в названии содержат какой-нибудь одинаковый префикс или постфикс (например, **v2**)
* Стиль - это единственный способ изменить **внешний** вид View. Иными словами, каждая View обладает стилем (либо через `style` в xml, либо через дефолтный атрибут стиля посредством `defStyleAttr`), и **только** этот стиль определяет её внешний вид. Примеры:
```
```
* Название стиля не должно раскрывать его **внешний** вид. При этом оно должно базироваться на названии компонента дизайн системы. Примеры:
```
@style/V2.Widget.MyFancyApp.TextInputLayout.Filled
@style/V2.Widget.MyFancyApp.TextInputLayout.Search
@style/V2.Widget.MyFancyApp.Button.BlackOutlined
@style/V2.Widget.MyFancyApp.Button.Primary
@style/V2.Widget.MyFancyApp.Button.Secondary
@style/V2.Widget.MyFancyApp.Button.Text
```
* Все ресурсы, включая имплементации стилей, лежат внутри **core-presentation**
Как итог:
* Получаем абстрактные стили. Проекты независимы в области палитр, текстовых стилей и любых других составляющих внешнего вида
* UI модули не содержат никаких ресурсов
* Пересечение именований компонентов старого и нового ui исключено вследствие префикса-постфикса
---
Вроде не сложно: используй только стили; определяй нужные цвета в этих стилях. Но так ли это все просто на практике?
Да. Но ровно до тех пор, пока не нарвешься на `TextView`. А как быть здесь? Ровно также. Использовать стили. Проблема лишь в том, что таких стилей будет до бесконечности много. Почти под каждый `TextView` нужно заводить отдельный стиль. В защиту такого решения отмечу, что из [статьи](https://medium.com/androiddevelopers/material-theming-with-mdc-type-8c2013430247) про MDCможно косвенно сделать вывод, что тривиальный текст - тоже отдельный стиль:
> While TextAppearance does support android:textColor, MDC tends to separate concerns by specifying this separately in the main widget styles
>
>
Примеры:
```
@style/V2.Widget.MyFancyApp.TextView.GiftItemPrice
@style/V2.Widget.MyFancyApp.TextView.GiftItemName
...
<item name = "android:textAppearance">?v2TextAppearanceCaption1</item>
<item name = "android:textColor">?v2ColorOnPrimary</item>
<item name = "android:textAppearance">?v2TextAppearanceCaption1</item>
<item name = "android:textColor">?v2ColorOnPrimary</item>
<item name = "textAllCaps">true</item>
<item name = "android:background">?v2ColorPrimary</item>
...
```
Если приглядеться, то можно заметить, что для всех названий атрибутов стилей в примере используется постфикс **v2** (например, `primaryButtonStyleV2`), а для текстовых стилей - префикс (`v2TextStyleGiftItemName`). Сделано это для того, чтобы упростить навигацию при автоподстановке IDE.
---
По итогу, после таких переделок файл с атрибутами в новом ui модуле выглядит примерно так:
```
...
...
...
...
```
Почти все зашито в стили. Исключение составляют строки и иконки. Они имеют отношение к контенту, а не к внешнему виду.
Вообще, строки можно было бы зашить в соответствующие стили для `TextView`, но бывают случаи, когда строка нужна в коде (и пробросить через стиль ее попросту не получится).
Что касается иконок, то, в целом, под них тоже можно завести отдельные стили. Все на стилях.
А как быть с `android:background`, когда просто нужна какая-нибудь подложка? Цвет или форма там какая-нибудь. Об этом чуть позже. Спойлер - через стили.
---
Рассмотрим несколько стилей:
```
<item name = "android:textAppearance">?v2TextAppearanceCaption1</item>
<item name = "android:textColor">?v2ColorOnPrimary</item>
...
...
<item name = "icon">?ic16CreditV2</item>
```
Можно заметить, что текстовые стили (`android:textAppearance`) и цвета используются через атрибуты. Также и иконки. И это все в **core-presentation**, где, собственно, все это доступно и напрямую (через `@color/`, `@style/`, `@drawable/`). Так зачем же?
Ответ: для гибкости. Такой подход дает преимущества в случае появления новых тем. Примеры:
* Темная (или любая другая, отличная от оригинальной по палитре) тема. В новой теме просто меняем значения атрибутов цветов на нужные
* "Тематические" темы (Halloween, Christmas, Easter и так далее). Переопределяем иконки и шрифты под саму тематику. Разобраться с тем, как и когда использовать такие темы, - дело третье
### Подводные камни, сложности, советы
#### MaterialThemeOverlay
Если вдруг вам потребуется определить `android:theme` в дефолтном стиле кастомной View, то ничего у вас не выйдет. Просто не сработает. Хотя для любого другого, не дефолтного стиля все отлично работает. Подробнее проблема разобрана в [этой статье](https://medium.com/@ataulm/refactoring-themes-with-style-53af646f9eef).
Но отчаиваться не стоит, ведь и для данного проблемного случая есть решение. Меняем `android:theme` на `materialThemeOverlay`, оборачиваем контекст через `MaterialThemeOverlay.wrap(...)` и все работает.
Где-то в xml:
```
@style/V2.Widget.MyFancyApp.AchievementLevelBar
<item name = "materialThemeOverlay">@style/V2.ThemeOverlay.MyFancyApp.AchievementLevelBar</item>
```
Сама кастомная View:
```
class AchievementLevelBar @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = R.attr.achievementLevelBarStyleV2
) : LinearLayoutCompat(MaterialThemeOverlay.wrap(context, attrs, defStyleAttr, 0), attrs, defStyleAttr) {
init {
View.inflate(context, R.layout.achievement_level_bar, this)
...
}
...
}
```
И это не работает. А не работает это из-за того, что манипуляции в `init {}` блоке осуществляются с исходным `context`, а не с обернутым. Отсюда вырисовывается очень простое правило: **никогда** не использовать исходный `context` при инициализации. Для того, чтобы в данном примере `materialThemeOverlay` заработал, необходимо `context` заменить на `getContext()`. Просто оставлю кусок `MaterialButton` здесь:
```
public MaterialButton(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(wrap(context, attrs, defStyleAttr, DEF_STYLE_RES), attrs, defStyleAttr);
// Ensure we are using the correctly themed context rather than the context that was passed in.
context = getContext();
```
(А если так сделать в Kotlin, то Lint будет ругаться на name shadowing. Грусть)
#### Light status bar
У нас на проекте для подложки под status bar используется кастомная `StatusBarView`. В идеале, такой штуки быть не должно (потому что [edge-to-edge](https://habr.com/ru/company/surfstudio/blog/464373/)), но пока что она присутствует. Довольствуемся тем, что есть.
Так вот, в старом дизайне status bar повсеместно translucent. Что это значит: есть какой-то полупрозрачный темный overlay (причем везде разный), а цвет контента - белый или около того. В новом же дизайне status bar может быть светлым (light): со светлым background и темным контентом.
Слева - translucent; справа - lightСобственно задача заключается в том, чтобы уметь поддерживать light status bar наравне с translucent через кастомную `StatusBarView`. Нюансы:
* Для поддержки light status bar необходима 23я версия SDK (или выше). Для всех версий, что ниже, можно отображать дефолтный translucent status bar (идея взята [отсюда](https://medium.com/@SindkarP/support-for-lollipop-devices-while-using-windowlightstatusbar-362777886393))
* Translucent status bar достигается с помощью выставления флага `FLAG_TRANSLUCENT_STATUS`;overlay без полупрозрачности (для light) - с помощью `FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS`
* Чтобы менять цвет контента, понадобятся следующие [методы](https://github.com/nickbutcher/plaid/blob/main/core/src/main/java/io/plaidapp/core/util/ViewUtils.java#L113):
```
fun setLightStatusBar() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
var flags = window.decorView.systemUiVisibility
flags = flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
window.decorView.systemUiVisibility = flags
}
}
fun clearLightStatusBar() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
var flags = window.decorView.systemUiVisibility
flags = flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
window.decorView.systemUiVisibility = flags
}
}
```
* Без `FLAG_TRANSLUCENT_STATUS` кастомная `StatusBarView` не залазит под status bar. Исправляется это примерно так:
```
class StatusBarView @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {
init {
...
systemUiVisibility = SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
}
}
```
* Чтобы окончательно использовать кастомную `StatusBarView` для light status bar, нужно задать прозрачный `statusBarColor`
* Возвращаясь к стилям, всю эту логику с light / translucent status bar можно зашить в кастомный атрибут `StatusBarView`
#### Color State List (CSL)
В MDC [статье](https://medium.com/androiddevelopers/material-theming-with-mdc-color-860dbba8ce2f) про цвета для полупрозрачных оттенков какого-либо цвета советуется использовать CSL. Дело в том, что с 23й версии SDK для CSL доступны атрибуты. И свойство `android:alpha`. А если соединить, то получится любой цвет с любой прозрачностью.
Выглядит это примерно так:
**color/v2\_on\_background\_20.xml**
```
```
Используются такие цвета не через атрибут, а напрямую, через `@color/` . Мощь данного подхода в том, что такой CSL зависит от какого-то цвета. Что внутри `v2ColorOnBackground` не имеет никакого значения. Без CSL пришлось бы лезть в палитру и добавлять для каждого `v2ColorOnBackground` аналог с 20% прозрачностью:
```
#000000
#33000000
```
Хоть это все и здорово, но есть свои заморочки:
* Как уже писал ранее, для поддержки необходима 23я версия SDK и выше. Но вообще, для MDC виджетов все работает нормально и с 21й версии. Если же так получилось, что нужно дернуть такой CSL через атрибут (например, в кастомной View для кастомного атрибута), то на помощь приходит метод MaterialResources.getColorStateList(). Вот только это является частью Restricted API~~, но кого это останавливало~~
* CSL не работает в качестве `android:background` и схожих. Но ничто не мешает сделать так:
```
<item name = "android:background">@drawable/v2\_rect</item>
<item name = "android:backgroundTint">@color/v2\_on\_background\_15</item>
...
```
#### Подложка и android:background
Сразу к делу. Никаких через xml. Вот **v2\_rect.xml** из примера выше - это единственный допустимый случай. MDC отказался от этого. И всем следует.
А если нужна подложка, то почему бы не посмотреть в сторону `ShapeableImageView` (ну или на крайний случай `MaterialCardView`)? Здесь и способов кастомизации больше. Как пример:
```
@style/V2.Widget.MyFancyApp.Shimmer
<item name = "srcCompat">@drawable/v2\_rect</item>
<item name = "tint">@color/v2\_on\_background\_15</item>
<item name = "shapeAppearance">@style/V2.ShapeAppearance.MyFancyApp.SmallComponent.Shimmer</item>
```
#### Стили компонент ViewGroup
Рассмотрим пример:
```
```
Представим, что такая конструкция встречается почти на каждом новом экране. Учтем, что здесь определено три атрибута стиля.
Вдруг появляется нестандартный экран. На нем все три стиля отличаются. Вопрос: сколько новых атрибутов потребуется? Правильный ответ - один, для `AppBarLayout`(назовем новый атрибут `secondaryAppBarStyleV2` ). Для всего остального есть **ThemeOverlay**:
```
@style/V2.Widget.MyFancyApp.AppBarLayout.Secondary
<item name = "materialThemeOverlay">@style/V2.ThemeOverlay.MyFancyApp.AppBarLayout.Secondary</item>
...
<item name = "statusBarStyleV2">@style/V2.Widget.MyFancyApp.StatusBar.Secondary</item>
<item name = "toolbarStyleV2">@style/V2.Widget.MyFancyApp.Toolbar.Secondary</item>
```
Пример конкретный, но применять такое можно к любой ViewGroup. В частности, к кастомной View. Если есть уверенность в том, что какая-то View (и ее стиль) будет использоваться исключительно в контексте определенной ViewGroup, то можно не имплементировать атрибут ее стиля на уровне темы приложения, а сделать это на уровне **ThemeOverlay** ViewGroup.
#### MaterialToolbar и Toolbar из AppCompat
Под капотом многие framework виджеты при inflate преобразуются в соответствующие из MDC. Чтобы ничего случайно не сломать виджетами из MDC, при затягивании темы (то есть до начала сего рассказа) все framework виджеты были заменены аналогами из AppCompat. Примерно так:
```
```
И это нормально-таки себе работало. Таким образом получили следующее: в новых скринах используется `MaterialToolbar` , в старых - `Toolbar`из AppCompat.
Здесь возник один интересный баг. Для стиля `MaterialToolbar` был определен атрибут `navigationIconTint`. Этот атрибут не поддерживается `Toolbar`из AppCompat. Тем не менее, при переходе с нового скрина на старый, navigationIcon в `Toolbar`каким-то образом красился с помощью `navigationIconTint`. Помог лишь полный переезд на `MaterialToolbar`.
#### Стили и размеры
Вот есть такая штука в Material Design Guidelines, как Dense text fields. По сути это `TextInputLayout`с высотой в 40dp. Есть даже стили под него (`Widget.MaterialComponents.TextInputLayout.*.Dense`). Ограничений (в Guidelines) на предмет наличия иконок (в начале или в конце) нет; более того, даже есть пример с иконкой.
Берем `TextInputLayout`, выставляем ему Dense стиль, добавляем start icon и... это ничем не отличается от обычного, не Dense стиля. Копаем в сторону того, а как же тогда получить высоту в 40dp. Надеемся на лучшее, в нужных стилях выкручиваем в 0 вертикальные `padding`. Не помогает.
Причина оказалась в `design_text_input_start_icon.xml`, где для start icon установлены минимальные размеры в 48dp. Тем не менее, если выставить для `TextInputLayout` 40dp в `android:layout_height`, все выглядит как нужно.
Не будем забывать про стили. Dense - это про стиль. Следовательно, `android:layout_height` должен в этом случае лежать внутри стиля. А это плохо тем, что в каждом месте использования `TextInputLayout`с таким стилем придется выпилить `android:layout_height` из разметки ([ответ](https://medium.com/androiddevelopers/android-styling-themes-overlay-1ffd57745207) на вопрос, почему так):
```
@style/V2.Widget.MyFancyApp.TextInputLayout.Search
<item name = "android:layout\_height">40dp</item>
...
```
Возможно это просто баг и в дальнейшем такого workaround получится избежать.
---
Как по мне, получилось неплохое решение. Оно имеет свои недостатки, но преимущества в виде абстракции от дизайн системы в ui модулях и возможности частичной стилизации куда весомей.
Используйте средства стилизации по максимуму. Это не сложно. Спасибо за прочтение. | https://habr.com/ru/post/552486/ | null | ru | null |
# PHP: Реализация формальных грамматик
Недавно мне нужно было написать парсер для строки поиска, который приводит строки вида
(aa&bb)^(!cc^!(dd^ee)) в строку вида куска SQL: (?f LIKE "%aa%" AND ?f LIKE "%bb%") OR (?f NOT LIKE "%cc%" OR !((?f LIKE "%dd%" OR ?f LIKE "%ee%")) ). Я написал like и SQL для упращения, на самом деле там был SPHINX, да и не оптребовалось оно в конце концов, но разговор о том как я этого добился написав [формальные грамматики](http://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) и реализовав их на PHP.
Коль уж зашли в пост, то откроюсь пред вами: несмотря на высшее математическое образование я делал это в первый раз, а до этого слыхивал, но не видывал как это делается. Поэтому прошу всех высоколобых математиков и гуру закидывать меня правильными решениями и всячески поправлять, а пока что я расскажу о своих результатах и о том как я к ним пришел.
Было несколько вариантов достичь цели:
первое — это написать рекурсивную (вспомним "?R") регуляру, но я отбросил такой вариант как «не спортивный», о да покарают меня за это лемминги =)
второе — это написать построение дерева вручную, но как-то уж больно много писать пришлось бы да и как-то больно топорно.
третье — это вспомнить про слова «формальная грамматика». Да уж страшными они кажутся на первый взгляд, однако на практике все намного лучше и полезнее — его я и избрал. Повторюсь, что это первая моя реализация подобной концепции так что указывайте мне смело на мои ошибки!
итак приступим:
Составим алфавит
Алфавит = {(,),!,&,^,(,),a-Z, пробел тут,-,\_, а-Я}
составим метаалфавит под нашу задачу с учетом приоритетов операций (! приоритетнее & и ^, а последние одинакового приоритета)
F -> T|T&F|T^F
T\* -> I|!I|!S
I -> (F)|S
S -> C|SC
C -> [a-Z\_ а-Я-]
Это правила по которым формируются элементы метаалфавита снизу вверх
F — формула, T — терм, I — итем, S- строка, C — символ. Назвал как понравилось.
\* в T внесен !S чтобы "! бала бала бла" трактовать как ?f NOT LIKE "%бала бала бла%", а не как !(?f LIKE "%бала бала бла%"), короче можно и без нее.
Как видно грамматика, содержащая разбор отрицания (!) стоит ниже грамматики содержащей разбор других операций (& и ^), а грамматика содержащая разбор скобок еще ниже — таким образом формируется приоритет операций.
у меня для такой задачи получилась [контекстно не зависимая](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BD%D0%BE-%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) грамматика G2 по иерархии Хомского — простая короче, но не такая простая как конечный автомат (поэтому чистыми «регулярами», без рекурсий и не решаются такие задачи).
Теперь осталось все это реализовать. Не думаю что интересно как я кодил, поэтому не томя читателя выложу конечный код, замечу лишь что в нем не реализован поиск синтаксических ошибок (Хотя душа заболела и разбор пары самых вопиющих ошибок я все же добавил в код).
> `Copy Source | Copy HTML1.
> 2. class GrammarParcer2SQLToken{
> 3. private $string = '';
> 4. private $index = 0;
> 5. private $sql\_token = '';
> 6. private $error = null;
> 7. public function \_\_construct($s=null){
> 8. if (!empty($s))
> 9. $this->string = $s;
> 10. $this->index = 0;
> 11. $this->error = null;
> 12. }
> 13.
> 14. public function parce($s=null, $e=null){
> 15. if (!empty($s))
> 16. $this->string = $s;
> 17. $this->index = 0;
> 18. $this->error = null;
> 19. $this->F();
> 20. $e = $this->error;
> 21. return $this->sql\_token;
> 22. }
> 23.
> 24. public function getError(){
> 25. return $this->error;
> 26. }
> 27.
> 28. protected function setError($mes){
> 29. $this->error = $mes;
> 30. }
> 31.
> 32. protected function isEnd(){
> 33. if (!empty($this->error) or $this->index >= strlen($this->string))
> 34. return true;
> 35. return false;
> 36. }
> 37.
> 38. protected function F(){
> 39. $this->T();
> 40. if ($this->isEnd())
> 41. return;
> 42. if ($this->string{$this->index} == '&'){
> 43. $this->sql\_token.= ' AND ';
> 44. }elseif ($this->string{$this->index} == '^' or $this->string{$this->index} == '|'){
> 45. $this->sql\_token.= ' OR ';
> 46. }else{
> 47. return;
> 48. }
> 49. $this->index++;
> 50. $this->F();
> 51. }
> 52.
> 53. protected function T(){
> 54. $this->I();
> 55. if ($this->isEnd())
> 56. return;
> 57. if ($this->string{$this->index} == '!'){
> 58. $this->index++;
> 59. if (!$this->S('invert')){
> 60. $this->sql\_token.= '!(';
> 61. $this->I();
> 62. $this->sql\_token.= ')';
> 63. }
> 64. }
> 65. }
> 66.
> 67. protected function I(){
> 68. if ($this->string{$this->index} == '('){
> 69. $this->sql\_token.= '(';
> 70. $this->index++;
> 71. $this->F();
> 72. if ($this->string{$this->index} !== ')'){
> 73. $this->setError('parse error, expected ")" on offset: '.$this->index);
> 74. //нет закрывающей скобки.
> 75. }
> 76. $this->sql\_token.= ')';
> 77. $this->index++;
> 78. }else{
> 79. $this->S();
> 80. }
> 81. }
> 82.
> 83. protected function S($invert=false){
> 84. if ($this->isEnd())
> 85. return false;
> 86. $string='';
> 87. while(!$this->isEnd()){
> 88. if (preg\_match('~[0-9a-zа-я\_ -]~i', $this->string{$this->index})){
> 89. $string.=$this->string{$this->index};
> 90. $this->index++;
> 91. continue;
> 92. }elseif (!preg\_match('~[&)(!|^]~i', $this->string{$this->index})){
> 93. $this->setError('parse error, unexpected "'.$this->string{$this->index}.'" on offset: '.$this->index);
> 94. //ненормальный символ =)
> 95. }
> 96. break;
> 97. }
> 98. if (empty($string))
> 99. return false;
> 100. $this->sql\_token.= '?f '.($invert?'NOT ':'').'LIKE "%'.mysql\_escape\_string($string).'%"';
> 101. return true;
> 102. }
> 103. }`
посмотреть пример:
> `Copy Source | Copy HTML1. $input = '(aa&bb)^(!cc^!(dd^ee))';
> 2. $parcer = new GrammarParcer2SQLToken();
> 3. echo $parcer->parce($input);
> 4. echo "\n".$parcer->getError();`
UPD сделал раскраску кода — спасибо s-c.me | https://habr.com/ru/post/73665/ | null | ru | null |
# API смс сервера GoIP
Здесь будет краткое руководство как пользоваться их API. В свое время нужно было привязать отправку и получение смс к своему программному обеспечению. Каждый раз лазить в вебморду смс сервера от GoIP и проверять вх./исх. сообщения было неудобно.
#### API сервера
Для отправки смс используется API:
```
http://192.168.1.70/goip/en/dosend.php?USERNAME=root&PASSWORD=root&smsprovider=1&smsnum=89650001199&method=2&Memo=hello
```
Бывает, что сообщение не уходит, тогда нужно его отправить повторно:
```
http://192.168.1.70/goip/en/resend.php?messageid=уникальный_номер_смс_сообщения_в_бд&USERNAME=root&PASSWORD=root'
```
Вот пример методов класса для отправки смс сообщения
```
public function send()
{
// Номер телефона на который нужно отправить сообщение.
// Формат номера 10 значный номер (XXX-XXX-XX-XX) без 8, +7
// $smsnum = '9650001199';
// Получаем номер телефона с клиента
$smsnum = substr($_POST['phone'],2,10);
// Код сотового оператора
$code = substr($smsnum,0,3);
$regexp = '/9[0,1,2,3,5,6,7,9][0,1,2,3,4,5,6,7,8,9]/';
// Проверяем Коды сотовых операторов
if( !preg_match($regexp, $code)) {
return 'Ошибка. Номер телефона неверный.';
}
// Само сообщение
// $msg = 'тест';
// $msg = mb_substr(trim($_POST['smsText']),0,335,'UTF-8');
$msg = trim($_POST['smsText']);
// Массив или объект содержащий свойства
$arr = array('Memo' => $msg);
// Генерирует URL-кодированную строку запроса
$msg = http_build_query($arr);
// MTC 910, 915, 916, 917, 919, 985, 986
$regexp = '/910|915|916|917|919|985|986|/';
// Сообщения на номера МТС отправляем со второй группы линии,
// остальные с первой группы
if(preg_match($regexp, $code)) {
$smsprovider = 2;
} else {
$smsprovider = 1;
}
// С помощью такого Url мы отправляем сообщение на смс сервер GoIp
$url = 'http://192.168.1.35/goip/en/'
.'dosend.php?USERNAME=root&PASSWORD=root&smsprovider='.$smsprovider
.'&smsnum='.$smsnum.'&method=2&'.$msg;
// Читает содержимое файла в строку, в нашем случае мы должны получить messageid
$get = file_get_contents($url);
//echo htmlspecialchars($get);
// Убираем пробелы, иначе функция preg_match не может найти подстроку
$str = str_replace(" ","",$get);
// Шаблон для поиска
$reg = '/resend.php\?messageid=(.*?).*USERNAME=root.*PASSWORD=root/';
// Результат пишет в массив
preg_match($reg, $str, $matches);
$url = 'http://192.168.1.70/goip/en/'.$matches[0];
//Делаем Get запрос чтобы смс сообщение было отправлено
file($url);
return $res = 1;
}
public function resend()
{
// Номер сообщения которое нужно переотправить
$msgid = (int) $_POST['msgid'];
$url = 'http://192.168.1.70/goip/en/resend.php?messageid='.$msgid
.'&USERNAME=root&PASSWORD=root';
// Делаем Get запрос чтобы смс сообщение было отправлено
file($url);
return $res = 1;
}
```
Данные по исх./вх. сообщениям хранятся в таблицах receive и sends:
```
// Запрос на получение всей истории переписки по заданному номеру
$query = "(SELECT 'in' AS route,time,goipname,msg,0 AS msgid,"
."CHAR_LENGTH(msg) AS msg_length,'0' AS over"
." FROM `receive` WHERE `srcnum`='".$srcnum."')"
." UNION "
."(SELECT 'out' AS route,T2.time,T3.name AS goipname,T2.msg,";
."T1.messageid AS msgid,"
."CHAR_LENGTH(T2.msg) AS msg_length,T1.over"
." FROM `sends` AS T1"
." INNER JOIN message AS T2 ON T1.messageid=T2.id"
." INNER JOIN goip AS T3 ON (T2.goipid=T3.id OR T1.goipid=T3.id)"
." WHERE telnum='".$srcnum."')"
." ORDER BY time";
```
#### Формируем файл для массовой смс рассылки
Родной смс сервер поддерживает массовую смс рассылку, на входе он требует XML-файл.
Пример создания файла:
```
// Начало файла
$str = "\n";
// Здесь в цикле заполняем тело файла необходимыми данными
$str .= "\t\n"
."\t\t".$num."\n"
."\t\t".$msg."\n"
."\t\tbeeline\n"
."\t\n";
// конец цикла
$str .= "";
$file = 'sms.xml';
$open = fopen($file,"a");//открываем файл для чтения и записи
fwrite($open,$str);
fclose($open);
```
Готовый файл загружаем и начинается смс рассылка.
Готовых примеров применения вышеописанных кодов уже не осталось. Года 2 тому назад был изучен обмен данными между родным смс сервером и самим шлюзом GoIP. На основании полученных данных написал собственный смс-сервер. Плюсом стало, что можно отслеживать статус доставки смс сообщения. Но там есть нюанс, что статус доставки смс сообщения отразится, если телефон включен в момент отправки. Если номер включат позже на несколько часов или дней, то статус доставки не увидим, хотя само сообщение будет доставлено. А в остальном только плюсы.
Если есть опыт работы с wireshark, то можно проследить следующий алгоритм общения между GoIP и родным смс сервером. Далее несложно написать свой собственный смс сервер.
#### API общения между смс сервером и шлюзом GoIP
```
Sms server <--> GoIP
-> MSG 11 5 hello\n
<- PASSWORD 11\n
-> PASSWORD 11 password1\n
<- SEND 11\n
-> SEND 11 1 +8613800138000\n
<- OK 11 1 160\n
-> SEND 11 2 +8613800138001\n
<- WAIT 11 2\n
-> SEND 11 2 +8613800138001\n
<- OK 11 2 161\n
...
-> DONE 11 \n
<- DONE 11 \n
```
Сам код проекта с примерами выложить в краткой форме не получится. Слишком много данных, и все это привязано к другому проекту. В ближайшее время планирую запустить тестовую версию смс сервера на PHP.
Ссылки выложить не получится. Хабр запрещает ссылки на коммерческие сайты. | https://habr.com/ru/post/507460/ | null | ru | null |
# Автоматическое освещение для балкона на Arduino
Примерно пару месяцев назад решил увлечь себя электроникой. В частности захотелось поиграться с Arduino. Но для баловства довольно дорого заказывать оригинальный, поэтому полез на всем известный китайский сайт. Там со скидкой нашел клон Arduino Uno в стартовом наборе. Его и заказал.
Примерно через 3 недели получил свою «игрушку» и, наверное, как и все, начал баловаться морганием светодиодиками. Это, конечно же, быстро надоело, хотелось чего-то посерьезнее. Возникла мысль сделать автоматическое включение/отключение света на одном из балконов (частенько хожу курить). Так как uno — это слишком «жирно» для такой задачи, на том же сайте заказал по скидке nano, датчики движения, текстолитовые макетки, блок питания с 220В на 5В и реле.
Прошел еще месяц…
**Посылки получил**
Надо пробовать. Сначала, как и следует, собрал схему на бредборде. Все работает, добавил потенциометр для регулировки светочувствительности, прекрасно.
Решил все дело собирать уже на плате. Как оказалось, реле было выполнено на большой плате и не влезало на мою макетку, подпилил его с боков (контактов/дорожек там к счастью не было). А так же, что бы впаять блок реле непосредственно в плату пришлось контакты перепаять на другую сторону. Получилось как-то так:
**Реле после доработки напильником**
Справа получилось немного неровно, так как там проходила дорожка.
Самое сложное, на мой взгляд, было сделать дорожки на плате. Тоненькая медная проволока, флюс и олово мне в этом помогли. Получилось довольно «топорно», но, повторюсь, это мой первый опыт, да и хотелось поскорее закончить и опробовать.
**Дорожки**
К счастью все уместилось на плате 5х7 см, это хорошо еще тем, что плата имеет отверстия для крепления, которыми я воспользуюсь после изготовления корпуса из оргстекла.
**Итог работы**
Датчик движения умышленно не сделал фиксированным, так как есть задумка его сделать на «рожках», что бы можно было менять его направление. Потому как пока еще не решил где готовый прибор будет крепиться.
Программу собирал по чуть-чуть из всяких туториалов по датчикам. В инструкции к датчику движения было сказано что ему нужно давать настроиться при первом запуске, от 10 до 30 секунд. Этот момент я пропустил, так как вообще не увидел его смысла. Устройство работает абсолютно одинаково как с ним, так и без него. Единственна разница — тратиться время на калибровку до первоначальной готовности.
**Скетч**
```
int const Pot = A5;
int const Light = A7;
int const Relay = 3;
int const Move = 4;
int const pause = 180000; // 3 минуты мне как правило достаточно для перекура :)
long unsigned int lowIn;
boolean lockLow = true;
boolean takeLowTime;
void setup() {
pinMode(Move, INPUT);
pinMode(Relay, OUTPUT);
digitalWrite(Relay, HIGH);
}
void loop() {
int moveVal = digitalRead(Move);
int lightVal = analogRead(Light);
int potVal = analogRead(Pot);
int lightLimit = map(potVal, 0, 1023, 500, 1000);
if (moveVal == HIGH && lightVal < lightLimit) {
if (lockLow) {
lockLow = false;
digitalWrite(Relay, LOW);
}
takeLowTime = true;
} else {
if (takeLowTime) {
lowIn = millis();
takeLowTime = false;
}
if (!lockLow && millis() - lowIn > pause) {
lockLow = true;
digitalWrite(Relay, HIGH);
}
}
}
```
Принцип работы таков: при обнаружении движения датчиком, сравнивается показание фоторезистора с пороговым (необходимым для срабатывания реле), которое регулируется потенциометром. Если все удовлетворяет, то включается реле на 3 минуты, по истечению которых, если движение не фиксируется, реле отключается.
Пороговые значения фоторезистора снимал закрывая его пальцем и направляя на него фонарик в 2000 люмен.
Учитывая новогодние праздники, ежедневные приходы гостей, а так же «непосильный вклад» в работу моего коллеги, на все изготовление ушло часов 12-15.
**Коллега**
Прошу строго не судить. Это моя первая статья и первый более-менее серьезный опыт работы с ардуино и паяльником. А конструктивная критика очень приветствуется. Даже, я бы сказал, необходима.
Спасибо за потраченное время. Надеюсь в скором будущем дополню статью уже финальным вариантом своего устройства, в корпусе и с демонстрацией работы.
P.S.
Хотелось бы отметить мой восторг от заказанного БП, при мощности в 4 Вт он имеет размеры всего 22х30х18 мм, а цена всего около 200 руб.
P.P.S.
Вся проделанная работа стоит конечно же гораздо дороже, чем готовый вариант от наших азиатских друзей. Но все же своими руками — гораздо интереснее. | https://habr.com/ru/post/248079/ | null | ru | null |
# Принцип единственной ответственности: глубокое погружение
Про **принцип единственной ответственности** (The Single Responsibility Principle, SRP) уже было написано множество статей. В большинстве из них даётся лишь поверхностное его описание мало чем отличающееся от информации в [википедии](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B5%D0%B4%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8). А те немногие статьи что затрагивают ключевые особенности SRP делают это вскользь, не акцентируя на них внимания и не развивая тему дальше.
Эта статья — попытка дать более глубокое объяснение принципу единственной ответственности, а также показать как его всё таки можно применять на практике. Кому интересно — добро пожаловать под кат.
Уровень 0
---------
Первоначально, автор принципа — Дядя Боб, дал ему такую формулировку:
> *A class should have one, and only one, reason to change.*
> *Класс должен иметь лишь одну причину для изменений.*
Это наиболее часто цитируемое определение принципа и оно крайне туманно. Проблема в том, что никто точно не понимает, что есть причина для изменений. Отсюда возникают различные субъективные трактовки «причины», а также стойкое ощущение того, что применение принципа единственной ответственности в разработке ПО это удел матёрых архитекторов и вообще что-то из области искусства. А ведь применение принципов проектирования на практике это именно то, что хочется в первую очередь освоить в процессе их изучения.
Рассмотрим следующий пример класса и попробуем оценить (субъективно конечно же) соответствует ли он SRP согласно определению выше:
**Примечание:** *весь код в статье не высосан из пальца, а взят из реальных проектов автора.*
```
class SelectQuery
{
public function __construct(QueryExecutor $executor) {...}
public function select($column, $alias = null): self {...}
public function from($table, $alias = null): self {...}
public function join(string $type, $table, $conditions = null): self {...}
public function where($column, $operator = null, $value = null): self {...}
public function orderBy($column, $order = null): self {...}
public function groupBy($column, $order = null): self {...}
public function limit(?int $limit): self {...}
public function offset(?int $offset): self {...}
public function build(): string {...}
public function rows(): array {...}
public function row(): array {...}
public function column(): array {...}
public function scalar() {...}
public function count() {...}
}
```
Как нетрудно догадаться этот класс умеет строить SELECT запрос и выполнять его. Сразу же бросается в глаза что у класса есть две группы методов: методы для генерации SQL кода и методы для выполнения этого кода. А значит у нас могут появиться две разных причины для изменения этого класса. Например, мы можем добавить новый метод having() для генерации HAVING условий. Это изменение никак не затронет методы выполняющие запрос. С другой стороны, мы можем добавить метод groupByKey() позволяющий группировать извлечённые данные по ключу и это в свою очередь никак не скажется на первой группе методов.
Налицо нарушение SRP. Решить проблему можно было бы, например, разделением класса на два:
```
class SelectQuery
{
public function select($column, $alias = null): self {...}
public function from($table, $alias = null): self {...}
public function join(string $type, $table, $conditions = null): self {...}
public function where($column, $operator = null, $value = null): self {...}
public function orderBy($column, $order = null): self {...}
public function groupBy($column, $order = null): self {...}
public function limit(?int $limit): self {...}
public function offset(?int $offset): self {...}
public function build(): string {...}
}
class ExecutableSelectQuery extends SelectQuery
{
public function __construct(QueryExecutor $executor) {...}
public function rows(): array {...}
public function row(): array {...}
public function column(): array {...}
public function scalar() {...}
public function count() {...}
}
```
Теперь вроде всё в порядке. Каждый класс делает ровно одну вещь и имеет ровно одну причину для изменений.
А вот другой пример:
```
@Transactional
class SearchService {
public List searchAthlete(SearchCriteria criteria)
public List searchUser(SearchCriteria criteria)
public List searchAssociation(SearchCriteria criteria)
public List searchOrganization(SearchCriteria criteria)
public List searchClub(SearchCriteria criteria)
public List searchTeam(SearchCriteria criteria)
public List searchGame(SearchCriteria criteria)
}
```
Как следует из названия класс используется для поиска различных сущностей и больше ничего не делает, а значит соответствует SRP. Ведь так?
А как вам такой пример:
```
class ActiveRecord
{
private $properties = [];
public function __get($property) {...}
public function __set($property, $value) {...}
public function create() {...}
public function update() {...}
public function delete() {...}
public function read() {...}
}
```
Ну ActiveRecord известный антипатерн. Он точно нарушает SRP. Или нет?
На самом деле во всех этих примерах нарушение или не нарушение SRP зависит от того, что мы будем считать причиной для изменений. При этом, варьируя широту этого понятия мы сможем обосновать как создание классов содержащих ровно по одному методу (из одной строки кода), так и создание «божественных объектов». А значит озвученное выше определение принципа единственной ответственности бесполезно.
Уровень -1
----------
По видимому, Дядя Боб в какой-то момент пришёл к тому же выводу и поэтому в своей недавней книге [Clean Architecture](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164) даёт новое определение этого принципа:
> *A module should be responsible to one, and only one, actor.*
> *Модуль должен отвечать перед одним и только одним актором.*
Под актором здесь понимается группа, состоящая из одного или нескольких лиц, желающих изменения **поведения** программного модуля.
Это определение гораздо лучше предыдущего, т.к., во-первых, оно акцентирует внимание не на классе, а на модуле, что явно указывает на то, что SRP применим к любой части системы и не зависит от используемой парадигмы программирования. Во-вторых, из него следует важное практическое следствие:
> Для определения соответствия программного модуля принципу единственной ответственности не всегда достаточно изучения лишь кода этого модуля. Требуется изучить также как этот модуль используется во внешнем по отношению к нему коде.
Иными словами, каждый актор определяет контекст использования модуля или, что тоже самое, набор сценариев использования модуля. Это может показаться неочевидным сразу, но каждый сценарий использования модуля отражает чьё-либо желание зафиксированное в коде.
**Докажем это**Каждый актор, или что тоже самое, группа лиц желающих изменения поведения модуля выступает в роли заказчика этого изменения. Чтобы изменение не было бесполезным оно должно как-то и где-то проявляться. Единственный способ это сделать это задействовать это изменение в одном или нескольких сценариях использования модуля. Если же изменение поведения программного модуля никак не проявляет себя в сценариях использования, то это означает одно из двух: либо это изменение не касается поведения модуля (например, рефакторинг приватных методов класса), а значит не относится к SRP вообще, либо оно сделано «на перспективу», что напрямую нарушает принцип YAGNI и следовательно такое изменение бесполезно.
Оценим с этой точки зрения наш первый пример — класс SelectQuery. Объективно он может использоваться в двух контекстах (т.е. у него есть два актора): генерация SQL кода и выполнение этого кода. Если у нас есть оба этих актора, т.е. если класс в каких-то сценариях используется только для генерации SQL, а в каких-то для выполнения запросов, то первая реализация класса не соответствует SRP. Если же у нас лишь один актор (как в проекте автора) — контекст выполнения запросов, то тогда исходная реализация не противоречит SRP. Действительно, в этом случае с точки зрения применения SelectQuery не будет никакой разницы содержится ли весь нужный функционал для построения и выполнения запросов в одном классе или в двух связанных классах. Сценарий использования будет всегда одним и тем же — строим запрос и потом выполняем:
```
$rows = (new SelectQuery(new QueryExecutorImpl()))
->select(...)
->from(...)
->where(...)
->rows();
```
Заметим, что классы из второй реализации SelectQuery не противоречат принципу единственной ответственности как для одного так и для двух акторов. А значит в случае одного актора отвечающего за выполнение запросов обе реализации эквивалентны с точки зрения следования SRP.
Что на счёт следующего класса SearchService. Одного кода класса недостаточно. Во-первых, неизвестно, что представляют собой сущности Athlete, Association и т.д. А во-вторых, неясен контекст использования класса. Например, может быть такой вариант что сущности это простые DTO, а контекст использования поиск различимых, но почти однородных данных. Тогда этот класс имеет одного актора и следовательно удовлетворяет SRP. Но если возвращаемые сущности это бизнес сущности, а методы класса используются в разных контекстах соответствующих каждой бизнес сущности (как в проекте автора), то тогда класс имеет кучу акторов, по одному на каждый метод, и следовательно жёстко нарушает принцип единственной ответственности.
В каких контекстах может использоваться наш ActiveRecord? На самом деле только в одном — сохранение записи в источнике данных. Никак иначе использовать этот класс нельзя. Таким образом, ActiveRecord прекрасно согласуется с SRP.
**Для тех кто не верит**Приведённая выше реализация ActiveRecord действительно не нарушает SRP (кто думает иначе, приведите пример использования отличный от сохранение данных в источнике данных). Однако в [оригинальном определении](https://www.martinfowler.com/eaaCatalog/activeRecord.html) этого патерна заложено нарушение SRP: как минимум два контекста — бизнес логика и взаимодействие с источником данных.
Постойте! Что мы вообще делаем? На каком основании мы выделяем контексты (акторов) использования модуля. Каков критерий разграничения акторов? Чем это принципиально отличается от «причины для изменений»? Собственно ничем. Да, мы теперь знаем, что нужно изучать то как мы используем программные модули, но в остальном трактовка принципа единственной ответственности в его актуальной формулировке всё также субъективна и находится в прямой зависимости от опыта и интуиции разработчика. Хотелось бы какого-то более формального подхода к проблеме, что-нибудь померить и посчитать в конце концов. Что ж, такой подход есть.
Уровень -2
----------
Принцип единственной ответственности возник как попытка объединения двух важных понятий структурного анализа и проектирования: [coupling](https://en.wikipedia.org/wiki/Coupling_(computer_programming)) (сопряжение, зацепление, связанность) и [cohesion](https://en.wikipedia.org/wiki/Cohesion_(computer_science)) (сплочённость, связность, прочность модуля).
**Как это было*** В 1972 году [Дэвид Парнас](https://en.wikipedia.org/wiki/David_Parnas) публикует статью в которой он высказывает идею декомпозиции системы на модули основываясь на том как они могут изменяться в будущем.
* В 1974 [Эдсгер Дейкстра](https://en.wikipedia.org/wiki/Edsger_W._Dijkstra)
вводит новый термин: [The Separation of Concerns](https://en.wikipedia.org/wiki/Separation_of_concerns) (Разделение ответственности).
* В конце 70х [Том Демарко](https://en.wikipedia.org/wiki/Tom_DeMarco) популяризирует понятия coupling и cohesion предложенные ранее (в 1974) [Ларри Константином](https://en.wikipedia.org/wiki/Larry_Constantine).
* В конце 90х — начале 2000х Дядя Боб объединяет все эти идеи в [принцип единственной ответственности](https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html).
Оба понятия неформально определяются следующим образом:
> Coupling — степень взаимозависимости между программными модулями.
> Cohesion — степень взаимозависимости между структурными составляющими программного модуля (подмодулями).
Введём также определение связи и зависимости между программными модулями:
> Модуль A связан с модулем B, или что тоже самое, модуль B связан с модулем А, только тогда когда существует передача информации между ними.
> Модуль A зависит от модуля B, а модуль B не зависит от A, если изменения в спецификации А *никогда не приведут* к изменениям кода в B, а изменения в спецификации B *могут приводить* к изменениям кода в A.
Где под спецификацией модуля понимается некоторая его часть доступная для прямого обращения извне (программный интерфейс модуля). Существует также альтернативная формулировка:
> Модуль A зависит от модуля B, а модуль B не зависит от A, если удаление модуля B приводит к нарушениям в работе A.
Таким образом программные модули могут быть связанными, но при этом независимыми. При этом несвязанные модули всегда независимы. Чего не скажешь про зависимые модули, они всегда связанны. Заметим, что информация (например, вызов метода, класса, обращение к переменной, отправка сообщения и т.д.) может передаваться как от зависимого модуля к независимому так и наоборот. Обратите также внимание на то, что связность это по сути то же самое что и сопряжение, но применительно к подмодулям рассматриваемых модулей. При этом в хорошо спроектированной системе низкое сопряжение между модулями подразумевает высокую связность внутри этих модулей (смотри, например, [GRASP](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design))).
**Нет ли тут подвоха?**Если связность это тоже самое что и сопряжение, то получается, что для некоторого набора модулей входящих в состав более крупного модуля их взаимозависимость должна быть одновременно высокой (модули являются подмодулями более крупного модуля, а значит должны обладать высокой связностью) и низкой (сопряжение между модулями). Как такое возможно? Возможно, если взаимозависимость подмодулей каждого модуля будет не меньше взаимозависимости между модулями более высокого уровня. При этом самые низкоуровневые модули будут обладать наибольшей взаимозависимостью, а самые высокоуровневые (из которых состоит вся программа) — наименьшей. Следующий рисунок демонстрирует хорошую и плохую декомпозицию программы на модули (разноцветные модули изменяются в одно и то же время):
В стандарте [ISO/IEC/IEEE 24765-2010](https://www.smaele.nl/documents/iso/ISO-24765-2010.pdf) определены (неформально) следующие виды связности и сопряжения (от худшего к лучшему):
* **Связность**
1. Случайная (coincidental)
Подмодули модуля в этом случае никак не взаимодействуют друг с другом и выполняют функционально не связанные задачи. Примером такой связности может быть весь тот код, который часто приводят для демонстрации нарушения принципа единственной ответственности:
```
class UserManager
{
public function writeToFile(...) {...}
public function calculatePaymentAmount(...) {...}
public function authenticateUser(...) {...}
}
```
2. Логическая (logical)
Также как и в случае случайной связности подмодули модуля никак не взаимодействуют друг с другом (либо взаимодействуют слабо), однако наблюдается их логическое сходство по какому-либо признаку (например, по сходству решаемых подмодулями задач). Примером логической связности может служить класс SearchService, при условии, что все его методы возвращают различные экземпляры бизнес сущностей. Тогда все методы класса имеют одно общее свойство — все они выполняют поиск некоторой сущности хотя каждый метод функционально принадлежит разным модулям.
3. Временная (temporal)
Тип связности при котором подмодули объединены в модуль по причине их совместного использования в некоторый момент времени выполнения программы, а порядок обращения к ним не важен. При этом подмодули никак функционально не связаны между собой.
```
class ExceptionProcessor
{
public function logException(Exception $e) {...}
public function notifyAdminAboutException(Exception $e) {...}
public function showFormattedException(Exception $e) {...}
}
// Далее, где-то в коде
$exceptionProcessor = new ExceptionProcessor();
...
try {
...
} catch (Exception $e) {
$exceptionProcessor->logException($e);
$exceptionProcessor->notifyAdminAboutException($e);
$exceptionProcessor->showException($e);
}
```
4. Процедурная (procedural)
Тип связности при котором подмодули объединены в модуль по причине их совместного использования в некоторый момент времени выполнения программы. Обращение к модулям происходит в определённом порядке. Подмодули могут быть функционально связаны между собой.
```
class Concole
{
public static function hasColorSupport(): bool {...}
public static function highlight(string $text): string {...}
}
// Далее, где-то в коде
$consoleText = '...';
if (Console::hasColorSupport()) {
$consoleText = Console::highlight($consoleText);
}
$this->write($consoleText);
```
5. Коммуникационная/информационная (communicational/informational)
Подмодули модуля функционально связаны между собой и обрабатывают одни и те же данные. Порядок обращения к подмодулям не имеет значения. Примером этого типа связности может служить класс SelectQuery (до разделения), ActiveRecord (только CRUD), большинство классов бизнес сущностей и сервисов, при условии их правильной реализации, воплощающих сценарии использования бизнес логики.
6. Последовательностная (sequential)
Подмодули модуля функционально связаны между собой. При этом выходные данные одного подмодуля становятся входными данными другого подмодуля, т.е. важен порядок обращения к подмодулям. Как правило такой модуль имеет одну точку входа.
```
class ExpressionExecutor
{
public function execute(string $expression) {
$ast = $this->parse(
$this->lexer(
$this->characterIterator($expression)
)
);
return $ast->evaluate();
}
protected function parse(Lexer $lexer) {...}
protected function lexer(Iterator $iterator): Lexer {...}
protected function characterIterator($expression): Iterator {...}
}
```
7. Функциональная (functional)
Все подмодули модуля функционально связаны между собой и выполняют одну хорошо определённую задачу. Этот тип связности прямая противоположность случайной связности.
```
class Lexer
{
public function __construct(CharacterIterator $charIterator) {...}
public function getTokens(): Generator {...}
}
```
* **Сопряжение**
1. Патологическое (pathological)
Программный модуль оказывает влияние или зависит от внутренней реализации другого модуля. Как правило, этот тип зацепления связан с нарушением принципа сокрытия информации (information hiding).
```
class Hash:
...
def hashOfText(self, text):
self.__hashFromCache(text, self.__textHashCache)
def __hashFromCache(text, cache):
...
class OrderId:
...
def hash(self):
return Hash()._Hash__hashFromCache(self.__id, dict())
```
2. По содержимому (content)
Часть или все содержимое одного программного модуля включены в содержимое другого модуля. Примером такого зацепления могут служить вложенные или анонимные классы.
```
public class BitSet implements Cloneable, java.io.Serializable {
...
public IntStream stream() {
class BitSetSpliterator implements Spliterator.OfInt {
...
}
return StreamSupport.intStream(
new BitSetSpliterator(0, -1, 0, true),
false
);
}
}
```
```
class EventPublisher
{
private $subscribers = [];
public function __construct()
{
$this->subscribers[] = new EventSubscriberContract {
public function handle(Event $event)
{
...
}
}
}
}
```
3. По общей области данных (common, common-environment)
Два или более модулей совместно используют общую область данных (глобальную по отношению к модулям).
```
$board = [];
class Bot implements Player
{
...
public function move()
{
global $board;
...
if ($board[$x][$y] === $this->shape['o']) {
...
}
...
$board[$x][$y] = $this->shape['x'];
...
}
}
class Game
{
private $player1;
private $player2;
public function __construct(Player $player1, Player $player2)
{
$this->player1 = $player1;
$this->player2 = $player2;
}
public funciton next(): bool
{
$this->player1->move();
if ($this->isGameOver()) {
return true;
}
$this->player2->move();
if ($this->isGameOver()) {
return true;
}
return false;
}
public function isGameOver(): bool
{
global $board;
if ($board[$x][$y] === 'x' || ... ) {
return true;
}
return false;
}
}
```
4. Смешанное (hybrid)
Различные подмножества значений некоторого элемента данных используются в нескольких программных модулях для разных и несвязанных целей. Тут можно придумать такой искусственный пример: есть некоторый DTO содержащий данные потребляемыми двумя совершенно разными модулями.
5. По управлению (control coupling)
Один модуль взаимодействует с другим модулем с целью повлиять на его поведение путём передачи ему управляющей информации.
```
class SortedCollection
{
private $items;
private $comparator;
public function __construct(array $items, callable $comparator) {
$this->items = $items;
$this->comparator = $comparator;
}
public function items(): array
{
$this->sort();
return $this->items;
}
private function sort(): void
{
usort($this->items, $this->comparator);
}
}
...
$collection = new SortedCollection([3, 5, 2, 1], function (int $a, int $b) {
return $a <=> $b;
});
$sortedItems = $collection->items();
```
6. По данным (data)
Данные одного программного модуля поступают на вход другого модуля.
```
class UserController
{
public function userDetails(string $userId, UserQueryService $service)
{
return $service->getUserDetails($userId);
}
}
```
Где-то с середины 70х годов прошлого века существуют и продолжают разрабатываться метрики для измерения как вышеперечисленных видов связности и сопряжения, так и их новых разновидностей. **Ссылки для примера*** [Class Cohesion Metrics for Software Engineering](http://www.math.md/files/csjm/v25-n1/v25-n1-(pp44-74).pdf)
* [A Survey on Software Coupling Relations and Tools](https://dibt.unimol.it/staff/fpalomba/documents/J16.pdf)
* [Measuring coupling and cohesion in object-oriented system](https://www.researchgate.net/publication/238729882_Measuring_coupling_and_cohesion_in_object-oriented_systems)s
Несмотря на обилие метрик, не существует какого-то единственного способа для вычисления сопряжения и связности модулей. Отчасти это связано с отсутствием строгой формализации этих понятий. С другой стороны разновидностей связей между программными модулями великое множество. Какие-то связи считаются «полезными», а какие-то «вредными» (зависимости). И какую связь какой считать во многом зависит от того на каком языке программирования написана программа, какая парадигма программирования использовалась или в каком архитектурном стиле велась разработка.
Уровень — 3
-----------
Тем не менее не всё так плохо. Существуют интегральные метрики позволяющие объединить всё, что мы считаем «полезным» в отношении связей и рассчитать связность и сопряжение для всей системы. Один из таких подходов описан в [Measuring Software Coupling](http://www.wseas.us/e-library/conferences/2007corfu/papers/540-383.pdf). Хотя этот метод предлагается использовать для вычисления сопряжения, он также подходит и для вычисления связности модулей.
Суть метода заключается в следующем: необходимо составить список того, что мы считаем зависимостями, далее по формулам рассчитываем связность или сопряжение. Расчёт будет настолько точным насколько адекватным и полным будет наш список видов зависимостей. Из-за диалектической природы сопряжения и связности списки зависимостей для них могут быть противоположными.
**Описание алгоритма расчёта**
1. Составляем матрицу описания связей для m модулей связанных посредством n видов связей: 
где  число характеризующее степень влияния вида связи j на модуль i. Чем больше это число тем сильнее модуль i связан с какими-то другими модулями через связь j. Если  равен нулю, то это означает что вид связи j не относится к модулю i.
Следует заметить, что матрица описаний применима только к модулям граф зависимостей которых связный, т.е. есть существует путь передачи информации из любого модуля в любой другой модуль. Или другими словами в матрице описаний не должно быть строк или колонок состоящих из одних нулей.
2. Вычисляем матрицу зависимостей: 
по следующим формулам: 
где  — сумма всех элементов i-й строки матрицы описаний, а  — величина обратная сумме элементов k-го столбца матрицы связей.
3. Анализируем получившуюся матрицу зависимостей. При этом имеем:
* , для всех i и j.
*  — степень зависимости между модулями i и j, если .
*  — степень независимости модуля i от остальных модулей, если .
*  — зависимость модуля от других модулей.
*  — общая степень взаимозависимости модулей.
*  — средняя степень взаимозависимости модулей.
Пользуясь вышеописанным алгоритмом попробуем рассчитать сопряжение и связность. Для примера возьмём код на PHP:
```
php
class User {...}
class Chat {...}
class ChatSession {...}
interface UserRepository
{
public function getMostLowLoadedOperator(): ?User;
}
interface ChatRepository
{
public function chatFrom($chatId): Chat;
}
interface ChatSessionRepository
{
public function sessionFrom($sessionId): ChatSession;
public function save(ChatSession $session): void;
}
interface BotService {...}
class ChatSessionApplicationService extends AbstractApplicationService
{
public function __construct(
ChatSessionRepository $sessionRepository,
ChatRepository $chatRepository,
UserRepository $userRepository,
BotService $botService,
UserAccessService $accessService
) {
...
}
public function startSession(StartSessionCommand $command): string
{
// Используются Chat, ChatRepository, ChatSession, ChatSessionRepository,
// BotService и функционал из AbstractApplicationService
...
}
public function switchChatSessionToFreeOperator($sessionId): void
{
// Используются ChatSession, ChatSessionRepository, User и UserRepository
// и функционал из AbstractApplicationService
...
}
public function changeName($sessionId, string $name): void
{
// Используются ChatSession, ChatSessionRepository и UserAccessService
...
}
}
</code
```
Прежде чем рассчитывать сопряжение составим список возможных связей между классами в PHP. Каждому типу связи присвоим вес в диапазоне от 0 до 1 (0 — соответствует отсутствию связи, 1 — соответствует максимально «жёсткой» связи).
| Вид связи | Вес связи |
| --- | --- |
| Класс наследует не абстрактный класс или использует каким либо образом не абстрактный класс. | 1.0 |
| Класс использует трейт. | 0.8 |
| Класс наследует абстрактный класс или использует каким либо образом абстрактный класс. | 0.6 |
| Класс реализует интерфейс или использует каким либо образом интерфейс. | 0.4 |
| Класс взаимодействует с другим классом через посредника — функцию или другой класс или используется каким-либо образом другим классом будучи при этом независимым от него. | 0.2 |
| Класс взаимодействует с другим классом через несколько посредников или не взаимодействует вовсе. | 0.0 |
Приведённый список зависимостей не является исчерпывающим, а скорее показывает качественную картину: какая из зависимостей является более «жёсткой» по отношению к другой. Можно также спорить по поводу весов. Однако наша задача получить не точное значение сопряжения, а качественно оценить на сколько код плох или хорош в этом отношении.
Итак, описание зависимостей есть, можно приступать к расчёту сопряжения. Всего у нас есть 11 модулей:
1.  — User
2.  — Chat
3.  — ChatSession
4.  — UserRepository
5.  — ChatRepository
6.  — ChatSessionRepository
7.  — ChatSessionApplicationService
8.  — AbstractApplicationService
9.  — BotService
10.  — UserAccessService
11.  — StartSessionCommand
Составим матрицу описания связей, где  будет определять степень зависимости между  и . Таким образом столбцы в матрице связей это веса рёбер графа зависимостей рассчитанные в прямом и обратном направлении:
Матрица описания связей:
| | $ \small m_7m_{11} $ | $ \small m_7m_3 $ | $ \small m_7m_6 $ | $ \small m_6m_3 $ | $ \small m_7m_5 $ | $ \small m_5m_2 $ | $ \small m_7m_2 $ | $ \small m_7m_1 $ | $ \small m_7m_4 $ | $ \small m_4m_1 $ | $ \small m_7m_{10} $ | $ \small m_{10}m_1 $ | $ \small m_7m_9 $ | $ \small m_7m_8 $ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| $ \small m_1 $ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 |
| $ \small m_2 $ | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| $ \small m_3 $ | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| $ \small m_4 $ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0.4 | 0.2 | 0 | 0 | 0 | 0 |
| $ \small m_5 $ | 0 | 0 | 0 | 0 | 0.4 | 0.2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| $ \small m_6 $ | 0 | 0 | 0.4 | 0.2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| $ \small m_7 $ | 0.2 | 0.2 | 0.2 | 0 | 0.2 | 0 | 0.2 | 0.2 | 0.2 | 0 | 0.2 | 0 | 0.2 | 0.2 |
| $ \small m_8 $ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0.6 |
| $ \small m_9 $ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| $ \small m_{10} $ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0.2 | 0 | 0 |
| $ \small m_{11} $ | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Выполняем расчёты и получаем матрицу зависимостей:
Общая зависимость классов , а средняя степень зависимости 
Как и следовало ожидать, самым зависимым модулем оказался ChatSessionApplicationService, за ним следуют репозитории, UserAccessService, AbstractApplicationService и наконец все остальные классы. Средняя степень зависимости между классами небольшая, что говорит нам о том, что в основном классы слабо связанны между собой.
Попробуем теперь вычислить связность ChatSessionApplicationService и понять на сколько он удовлетворяет SRP. Здесь также можно было бы составить иерархию видов связей внутри модуля (класса) с точки зрения связности его подмодулей (методов). Но поскольку в нашем случае методы внутри ChatSessionApplicationService связаны исключительно через зависимости класса условимся в целях упрощения расчётов считать использование конкретной зависимости методом за 1. Таким образом, строки матрицы описаний связей будут соответствовать методам класса, а столбцы — использованию конкретной зависимости:
1. Метод использует UserRepository
2. Метод использует ChatRepository
3. Метод использует ChatSessionRepository
4. Метод использует UserAccessService
5. Метод использует BotService
6. Метод использует AbstractApplicationService
Матрица связей:
Матрица зависимостей:
Общая связность класса , а средняя степень связности методов 
Сразу бросается в глаза низкая степень связности методов друг с другом. Об этом также свидетельствует средняя связность. При этом первый метод почти не связан с третьим, а второй в два раза сильнее связан с первым методом чем с третьим. Третий метод слабо связан с первыми двумя. Всё это означает, что ChatSessionApplicationService плохо соответствует SRP и, следовательно, должен быть разбит на три класса. К тому же такое разбиение только улучшит показатели сопряжения между классами (кто не верит — посчитайте сами) в силу слабой независимости сервиса с остальными классами.
Дно?
----
Едва ли. Исследования в области контроля качества и сложности программного кода ведутся до сих пор и останавливаться не собираются. А значит применение принципов управления сложностью программного кода, к которым в частности относится SRP, будет становиться всё более приближенным к стандартным инженерным практикам. | https://habr.com/ru/post/465507/ | null | ru | null |
# Газовый шейдер в Cocos2d
Добрый день.
Хотела поделиться своим небольшим опытом оптимизации шейдеров на IOS, и по возможности услышать дельные советы на этот счет. Вроде бы есть прекрасный инструмент OpenGl ES 2.0, и можно сделать неплохие эффекты, но при этом получить более-менее вменяемый fps не всегда получается.
Начала с простого. Сделана небольшая программка построения бесконечного газопровода, обходя препятствия и подключая объекты. Задача – отрисовать газ, заполняющий трубу. Программирую я на Cocos2d, материалов по шейдерам там не очень-то много, но по большому счету, можно легко пристраивать любые примеры доступные для ios и андроида. Небольшое отличие, которое вносит непосредственно Cocos2d, — это передача координат вершинных шейдеров в экранных размерах, а не в диапазоне [-1.0, 1.0]. Это весьма удобно.
Для конвертации диапазонов кокос сам формирует матрицу CC\_MVPMatrix, и добавляет ее в вертексный шейдер.
За основу газа взят шейдер, который комбинирует цвета на основе входящей текстуры шума Перлина.
```
precision mediump float;
varying vec4 Position;
varying vec2 v_texCoord;
uniform float Offset;
uniform sampler2D uTextNoise;
void main (void)
{
vec4 noisevec;
vec3 color;
float intensity;
vec3 FireColor1 = vec3(0.5, 0.7, 0.8);
vec3 FireColor2 = vec3(0.1, 0.3, 0.8);
noisevec = texture2D(uTextNoise, Position.xy);
noisevec = texture2D(uTextNoise, vec2 (Position.x+noisevec[1]+Offset, Position.y-noisevec[2]+Offset));
intensity = 1.5 * (noisevec[0] + noisevec[1] + noisevec[2] + noisevec[3]);
intensity = 1.95 * abs(intensity - 0.35);
intensity = clamp(intensity, 0.0, 1.0);
color = mix(FireColor1, FireColor2, intensity) * 1.8;
gl_FragColor = vec4(color,1.0);
}
```
Первоначально, я планировала сгенерить газ на весь экран, а далее вырезать нужную облать для рендеринга. Проблема в том, что такой простенький шейдер снижал fps до 22 кадров на iphone4. На других устройствах производительность была лучше, но не брилиантли, что называется.
Наиболее подходящим выходом в данной ситуации является генерация небольшой промежуточной текстуры в фреймбуфере. Эту текстуру в дальнейшем можно растянуть или размножить, установив соответствующие параметры текстуры. Этот способ можно использовать для генерации воды, тумана, газа.
Создание фреймбуфера в кокосе:
```
-(void) createFBO
{
GLint _oldFBO;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_oldFBO);
ccGLBindTexture2DN(0, texOut.name);
glGenFramebuffers(1, &_noiseFBO);
glBindFramebuffer(GL_FRAMEBUFFER, _noiseFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texOut.name, 0);
glBindFramebuffer(GL_FRAMEBUFFER, _oldFBO);
glActiveTexture(GL_TEXTURE0);
}
```
Отрисовка будет выглядеть примерно так:
```
-(void)draw
{
ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GLint _oldFBO;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_oldFBO);
glBindFramebuffer(GL_FRAMEBUFFER, _noiseFBO);
[shaderProgramNoise use];
[shaderProgramNoise setUniformsForBuiltins];
glUniform1f(quOffset0, offset);
ccGLBindTexture2DN(0, texNoise.name);
ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_TexCoords);
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertexArr);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, vertexTex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindFramebuffer(GL_FRAMEBUFFER, _oldFBO);
[shaderProgramAlpha use];
[shaderProgramAlpha setUniformsForBuiltins];
ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_TexCoords);
ccGLBindTexture2DN(0, texOut.name);
ccGLBindTexture2DN(1, texTemplate.name);
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertexArrOut);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, vertexTexOut);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glActiveTexture(GL_TEXTURE0);
}
```
В отрисовке мы сначала подключаем фрейм буффер, в котором shaderProgramNoise формирует текстуру texNoise маленького размера.
Далее в рендер буффере shaderProgramAlpha отрисовывает обработку двух текстур: газа и трафарета. Текстуру трафарета первоначально я отрисовывала в другой фрейм буфер, используя картинки полных и частичных труб.
Fps значительно улучшился. Тем не менее, полученный вариант был вовсе не оптимальным. Как выяснилось, увеличение количества frambuffer’ов (! хотя их всего было 2!) нагружает систему, и fps сразу падает на десяток. Понятное дело, что такая драматическая ситуация наблюдалась только на iphone4, тем не менее это надо учитывать при разработке и не плодить дополнительные frambuffer’ы без необходимости.
Хорошим решением было бы разместить трафаретную текстуру в stencil буффер frameBuffera c газом. Там где значение стенсила 0, не происходит вызов пиксельного шейдера. Однако, неприятным моментом в использовании stencil- буфферов является невозможность запихать туда текстуру. Т.е. рисовать туда придется треугольниками – а это полное ФУ (для данной задачи). Но раз уж я упоминула о stencil-буффере, скажу, что все-таки запихать туда текстуру мне удалось. Поскольку вызов glDrawArrays для stencil’а тоже использует шейдерную программу, то используя в этой программе discard для прозрачных областей, мы все-таки можем получить там трафарет текстуры. Если кому-то интересно смотрите такой способ:
```
-(void)draw
{
glDisable(GL_DEPTH_TEST);
ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0/255.0, 200.0/255.0, 245.0/255.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glClearStencil(0);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_NEVER, 1, 0);
glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);
ccGLBindTexture2DN(0, stencilTexture.name);
[shaderProgramStencil use];
[shaderProgramStencil setUniformsForBuiltins];
ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_Color|kCCVertexAttribFlag_TexCoords);
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertexArr);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, vertexTex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// теперь устанавливаем stencil buffer как маску
glStencilFunc(GL_EQUAL, 1, 255);
[self.shaderProgram use];
[self.shaderProgram setUniformsForBuiltins];
ccGLBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
ccGLBindTexture2DN(0, tex0.name);
ccGLEnableVertexAttribs(kCCVertexAttribFlag_Position|kCCVertexAttribFlag_Color|kCCVertexAttribFlag_TexCoords);
glVertexAttribPointer(kCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertexArr);
glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, vertexTex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glActiveTexture(GL_TEXTURE0);
}
```
Шейдер для отрисовки трафарета текстуры, будет выглядеть так:
```
precision lowp float;
varying vec2 v_texCoord;
uniform sampler2D CC_Texture0; // по умолчанию в кокосе
void main()
{
vec4 color = texture2D(CC_Texture0, v_texCoord);
if (color.a == 0.0)
{
discard;
}
gl_FragColor = color;
}
```
Разумеется использование функции discard (а также функции if и непоследовательного доступа к текстурам) в пиксельном шейдере – это зло и низкий fps. Поэтому никакого смысла в таком надругательстве над stencil буффером нет, вот собственно поэтому его мало используют в 2d.
В итоге, я решила избавится от отдельного “запекания” текстуры трафарета в фреймбуфер, а также от загрузки ее в stencil буффер. И пришла к такому решению: делаю один фреймбуфер c маленькой текстурой газа, строю VBO трафарета, в который складирую координаты текстур трубопровода, координаты текстур газа, и координаты экрана и рендерю на экран. Вижу отличный fps.
Видео результата можно посмотреть [здесь](https://everyplay.com/videos/6526466).
Мне эти “упражнения” очень помогли разобраться в пучине “open gl”. Возможно, кому-то тоже будут интересны и полезны эти знания. | https://habr.com/ru/post/227491/ | null | ru | null |
# Легко и непринуждённо: почта и Jabber для пользователей вашего сайта
Допустим, вы развиваете какой-нибудь сайт в интернете. У вас есть постоянные пользователи, кто-то заходит к вам от случая к случаю. И вы конечно же ищете способы удержания аудитории на вашем сайте, придумывая всякие оригинальные функции и оттачивая до блеска интерфейс. Почему бы тогда не использовать имя вашего сайта в качестве экспортной монеты? Можно ведь предоставить вашим пользователям в качестве дополнительного бонуса *почтовый адрес* и соответствующий *адрес Jabber* в вашем домене.
Конечно, я не предлагаю становится очередным провайдером почты. Это глупо, когда есть такие игроки, как [gmail.com](https://gmail.com) и [yandex.ru](http://www.yandex.ru/). Кроме того, вы естественно можете использоваться услуги вышеупомянутых Google и Yandex для подключения своего домена к их сервисам. Но тогда вы не получите никакой интеграции с вашей базой пользователей и никакого контроля над доступной функциональностью.
Но есть простой и элегантный способ прозрачно совместить почту и Jabber в вашем домене с профилями пользователей на сайте. У пользователя при этом везде будет единый логин и единый пароль и не будет необходимости в совершении никаких дополнительных действий для подключения почты и Jabber аккаунта. Просто дополнительный бонус, идущий в комплекте с регистрацией на вашем портале.
[](http://creativecommons.org/licenses/by-sa/3.0/deed.ru)
Начнём с описания того, как это будет работать. Если у вас есть сайт, на котором можно регистрироваться, значит у вас конечно же есть БД пользователей с логином, email адресом и паролем для каждого (если вы хоть чуточку цените своих пользователей, то вместо паролей у вас будут необратимые хеши, но для данной статьи это не важно). Кроме того, логины у всех пользователей конечно же различны. Тогда можно настроить *почтовый сервер*, который почту для **user@yourdomain.com** будет перенаправлять на основной ящик пользователя из профиля, а так же *Jabber сервер*, который будет авторизовывать по JID **user@yourdomain.com** через вашу БД. Таким образом пользователи вашего сайта получат почтовый и Jabber адрес в вашем домене, совмещённые с их профилем. При этом вы не будете предоставлять почтовый ящик, только адрес. Это очень удобно для конечного пользователя, поскольку ящик у него всегда где-то уже есть и обычно нету смысла заводить ещё один. А вот красивый адрес, которым можно похвастаться, никогда не помешает. Единственное, нужно обязательно предусмотреть возможность отключения данной функциональности через профиль пользователя. Иначе такую систему можно будет очень эффективно использовать для рассылки спама.
#### Практическая сторона вопроса
Перейдём от теории к практике. Для поднятия почтового и Jabber сервисов вам потребуется любой Linux-сервер, однако в данной статье описывается **Ubuntu Server 10.04**. Кроме того, все инструкции будут аналогичны и для более старых версий **Ubuntu**, а так же для **Debain**.
В качестве почтового сервера имеет смысл использовать **Postfix**, как один из самых надёжных и при этом нетребовательных к ресурсам. В качестве XMPP (он же в просторечии Jabber) сервера — **ejabberd**. Эти два сервера практически никак не будут связаны между собой, так что начнём с настройки почты.
#### Настройка почтовой системы
Для установки **Postfix** в **Ubuntu** достаточно выполнить
```
sudo apt-get install postfix
```
Когда у вас спросят, какой тип настройки использовать — выберите интернет-сайт и введите какие-нибудь данные в ответ на дальнейшие вопросы от балды, чуть ниже будет готовый конфиг со всеми необходимыми настройками.
После установки необходимо настроить Postfix так, чтобы при запросе доставки письма на адрес **someuser@yourdomain.com**, Postfix смотрел бы в вашу БД, узнавал бы, есть ли там искомый пользователь и активирован ли для него почтовый адрес, и, если всё в порядке, — на какой адрес перенаправить письмо. После чего Postifx должен принять письмо и перенаправить его на основной почтовый адрес указанного пользователя.
Эту задачу можно решить встроенными средствами Postfix, однако заставлять почтовый сервер для каждого нового письма отправлять запрос в основную базу данных — это далеко не лучшая идея, поскольку это создаст лишнюю нагрузку на вашу БД пользователей, благо спама сейчас в интернете гуляет очень и очень много. Гораздо лучше пару раз в сутки выгружать нужную информацию из вашей основной БД в Postfix, благо вся эта информация — это таблица из двух полей: имя пользователя и его основной адрес почты.
Для перенаправления почты в Postfix служат различные **alias\_maps**. Поскольку описываемая система никак не привязана к системным пользователям сервера, то будем использовать механизм виртуальных доменов и параметр [virtual\_alias\_maps](http://www.postfix.org/postconf.5.html#virtual_alias_maps) для перенаправления почты на основные адреса пользователей. В этом параметре как раз надо указать таблицу соответствия адреса пользователя адресу, на который нужно перенаправить корреспонденцию. Эта таблица будет создаваться на основании содержимого вашей основной БД пользователей специальным скриптом, о котором чуть ниже.
Пока же давайте окончательно разберёмся с необходимым опциями Postfix. Вся настройка Postfix осуществляется путём редактирования конфигурационного файла */etc/postfix/main.cf*. Итак, для решения поставленной задачи, как я уже говорил, будет использоваться механизм виртуальных доменов, поскольку реальным пользователям почты на сервере не от куда взяться. Поэтому необходимо полностью отключить локальную доставку. Кроме того, пользователи не должны иметь никакого доступа к вашему SMTP серверу, поэтому стоит отключить авторизацию и SSL шифрование.
Вот содержание конфигурационного файла, который используется на одном из моих серверов:
```
# See /usr/share/postfix/main.cf.dist for a commented, more complete version
########################################################
## Основные параметры
smtpd_banner = $myhostname ESMTP server
biff = no
# Максимальный размер письма. По умолчанию всего 10Mb
message_size_limit = 204800000
# Основные параметры хоста
myhostname = mail.yourdomain.com
myorigin = $mydomain
mynetworks =
127.0.0.0/8
mailbox_size_limit = 0
virtual_mailbox_limit = 0
recipient_delimiter = +
inet_interfaces = all
inet_protocols = ipv4
append_dot_mydomain = no
readme_directory = no
##########################################################
## Настройки адресов и доставки
# Используем только виртуальных пользователей, поэтому всё локальное отключаем
mydestination =
local_recipient_maps =
relay_domains =
relay_recipient_maps =
transport_maps =
# Настройки виртуальных ящиков
virtual_mailbox_domains =
$mydomain
# Локальных пользователей нет (если нужны - нужно ставить Dovecot)
# Однако карта обязательно должна существовать (пусть и пустая)
virtual_mailbox_maps =
hash:/etc/postfix/mailboxes/local-mailboxes
# Собственно карты перенаправлений
virtual_alias_maps =
hash:/etc/postfix/mailboxes/db-aliases
hash:/etc/postfix/mailboxes/local-aliases
# Параметры локальной доставки. Если она нужна, то надо ставить Dovecot
virtual_mailbox_base = /var/mail
virtual_uid_maps = static:900
virtual_gid_maps = static:900
###########################################################
## Авторизация и шифрование - отключены
# SASL авторизация отключена
smtpd_sasl_auth_enable = no
# TLS отключён
smtpd_use_tls = no
###########################################################
## Ограничения и запреты
# Запретить ETRN команду
smtpd_etrn_restrictions = reject
# Запретить VRFY команду
disable_vrfy_command = yes
# Требовать наличие EHLO (HELO) команды
smtpd_helo_required = yes
# Всегда отклонять письма для всех неизвестных ящиков
smtpd_reject_unlisted_recipient = yes
# Ограничения на клиента - принимаем только если есть PTR (не жёсткий запрет)
smtpd_client_restrictions =
permit_mynetworks
reject_unknown_reverse_client_hostname
permit
# Ограничения на HELO. Отклоняем письма от всех хостов, которые даже представиться не могут
smtpd_helo_restrictions =
permit_mynetworks
reject_invalid_helo_hostname
reject_non_fqdn_helo_hostname
reject_unknown_helo_hostname
permit
# Ограничения на MAIL FROM. Отклоняем все письма, отправитель которых предоставил невалидный адрес
smtpd_sender_restrictions =
reject_non_fqdn_sender
reject_unknown_sender_domain
permit
# Ограничения на RCPT TO. Принимаем только для известных нам адресов
smtpd_recipient_restrictions =
reject_non_fqdn_recipient
reject_unlisted_recipient
permit_mynetworks
reject_unauth_destination
permit
# Ограничения на данные. Не принимаем в случае некорректной передачи
smtpd_data_restrictions =
reject_unauth_pipelining
```
Подробней про настройку и различные опции Postfix можно почитать в интернете, для нашей же задачи важны три момента:
1. Не стоит ставить слишком жёсткие ограничения с целью фильтрации спама. Оставьте эту прерогативу почтовым серверам, которые используют ваши пользователи. Ваша задача — просто переслать почту и отсеять только то, что спамом является 100%. Подробнее про правильную настройку Postfix с целью минимизации потока спама можно почитать в одной из моих [прошлых статей](http://help.ubuntu.ru/wiki/фильтрация_спама_на_уровне_smtp_протокола). Обратите внимание, для нормальной пересылки вам надо не забыть корректно настроить DNS записи для вашего сервера, об этом также можно почитать в статье по ссылке.
2. Обязательно укажите пустую карту локальных пользователей в параметре **virtual\_mailbox\_maps**, иначе Postfix будет принимать почту для всех адресов в вашем домене и выдавать кучу ошибок о невозможности доставки. В моём случае файл карты называется */etc/postfix/mailboxes/local-mailboxes*. Это обычный пустой текстовый файл. После его создания необходимо выполнить команду
```
sudo postmap /etc/postfix/mailboxes/local-mailboxes
```
иначе Postfix не сможет работать с вашим файлом.
3. Ну и наконец все правила перенаправления будут задаваться в двух файлах, указанных в параметре **virtual\_alias\_maps**. Один будет создаваться автоматически скриптом на основании содержимого вашей базы пользователей, а второй нужен для ручного создания дополнительных вспомогательных адресов. После редактирования файла дополнительных адресов не забудьте выполнить для него команду **postmap**. Подробней про использование псевдонимов для перенаправления почты в Postfix можно почитать в [официальной документации](http://www.postfix.org/ADDRESS_REWRITING_README.html).
Теперь, собственно, сам скрипт, который создаёт карту псевдонимов на основе содержимого базы пользователей. Приведённый ниже скрипт предназначен для работы с БД движка [SMF](http://www.simplemachines.org/), вам потребуется модифицировать его под вашу БД:
```
#!/usr/bin/perl
# Скрипт выбирает из SMF пользователей из определённой группы,
# и создаёт на основе выборки карты для postfix. Должен запускаться по
# cron. Предположительно отсюда /etc/cron.d/postfix-smf-sync
use 5.010;
use DBI;
#############################################################
# Настройки базы данных (MySQL)
$MYSQL_host = 'bd.yourdomain.com';
$MYSQL_port = '3306';
$MYSQL_user = 'postfix';
$MYSQL_pass = 'PASSW0RD';
$MYSQL_db = 'my_smf';
# Параметры SMF - группа пользователей с доступом к почте и префикс таблиц
$SMF_GID = '15';
$SMF_prefix = 'smf_';
# Обслуживаемый домен
$domain = "yourdomain.com";
# Файл псевдонимов
$postfix_file = "/etc/postfix/mailboxes/db-aliases";
#############################################################
$dbh = DBI->connect("DBI:mysql:$MYSQL_db:$MYSQL_host:$MYSQL_port",$MYSQL_user,$MYSQL_pass) or die "Hey guys! We've got a big error here...\n";
# Выполняем запрос
my $sth = $dbh->prepare("SELECT memberName, realName, emailAddress
FROM ${SMF_prefix}members
WHERE (ID_GROUP = $SMF_GID OR FIND_IN_SET($SMF_GID, additionalGroups))") or die "Hey guys! We've got big error here!\n";
$sth->execute() or die "Hey guys! We've got a big error here...\n";
# Открываем файл псевдонимов для Postfix
open ALIASES, ">$postfix_file" or die "Can't open $postfix_file\n";
say ALIASES <fetchrow\_hashref()) {
# Делаем lower case, но нужно это только для красоты
my $user = lc $row->{realName};
# Если имя пользователя содержит неразрешённые символы - пропускаем его
# Разрешены любые буквы, цифры и символы ".", "-" и "\_"
next unless $user =~ /^($w+$s)\*$w+$/;
# Убеждаемся, что пользователь подумал головой
my $email = lc $row->{emailAddress};
next if "$user\@$domain" eq $email;
# Пишем псевдоним в файл
say ALIASES "$user\@$domain\t$row->{emailAddress}";
}
# Закрываем файл псевдонимов и создаём хеш для postfix'а
close ALIASES;
`/usr/sbin/postmap hash:$postfix\_file`;
```
В результате работы скрипта будет создан файл псевдонимов */etc/postfix/mailboxes/db-aliases*, в котором будут строчки вида
```
someuser@yourdomain.com usermail@anotherdomain.com
```
По одной строчке для каждого пользователя, состоящего в группе пользователей почты. Скрипт содержит проверку на дурака: во-первых, никакие пользователи с спецсимволами в имени не будут пропущены в файл псевдонимов Postfix. Ну и во-вторых пользователь не сможет указать в качестве основного адреса в своём профиле адрес на вашем же сайте, дабы не получился цикл почтовый системы.
Всё, что осталось сделать, это добавить запуск скрипта в планировщик, например, создать задание **cron**. Для этого создайте файл */etc/cron.d/postfix-sync* с примерно следующим содержанием:
```
# Synchronize Postfix with BD
18 04 * * * root /etc/postfix/scripts/postfix-sync.pl
```
Как видно, у меня скрипт запускает каждый день в 04:18.
На этом настройка почтовой системы заканчивается.
#### Настройка XMPP сервера
В качестве XMPP сервера будем использовать **ejabberd**. Для начала его нужно поставить:
```
sudo apt-get install ejabberd
```
В интернете полно материалов по настройке *ejabberd*, нам же для интеграции с существующей БД пользователей всего лишь нужно сказать *ejabberd* использовать внешний механизм авторизации и написать модуль, реализующий авторизацию через нашу базу. Для использования внешней авторизации в конфигурационный файл *ejabberd* */etc/ejabberd/ejabberd.conf* нужно записать всего лишь две строчки:
```
{auth_method, external}.
{extauth_program, "/etc/ejabberd/auth.pl"}.
```
Ну и собственно сам модуль авторизации для всё той же БД SMF, который вам потребуется изменить под вашу базу:
```
#!/usr/bin/perl
use 5.010;
use Digest::SHA1 qw(sha1_hex);
use DBI;
#############################################################
# Настройки базы данных (MySQL)
$MYSQL_host = 'bd.yourdomain.com';
$MYSQL_port = '3306';
$MYSQL_user = 'postfix';
$MYSQL_pass = 'PASSW0RD';
$MYSQL_db = 'my_smf';
# Параметры SMF - группа пользователей с доступом к почте и префикс таблиц
$SMF_GID = '15';
$SMF_prefix = 'smf_';
# Обслуживаемый домен
$valid_domain = "yourdomain.com";
#############################################################
# Просто соединяемся с БД
sub db_connect {
my $dbh = DBI->connect("DBI:mysql:$MYSQL_db:$MYSQL_host:$MYSQL_port",$MYSQL_user,$MYSQL_pass);
return $dbh;
}
$dbh = db_connect;
# Это именно то, что вы видите. Бесконечный цикл, ага.
while(1) {
# Получаем запрос от ejabberd
my $nread = sysread STDIN, my $buf, 2;
unless ($nread == 2) { exit }
my $len = unpack "n", $buf;
$nread = sysread STDIN, $buf, $len;
my ($op,$user,$domain,$passwd) = split /:/, $buf;
# Сложно сказать зачем, но фильтруем символы
$passwd =~ s/[\n\r]//g;
# Домен проверяет ejabberd, но на всякий случай
die "о_О" if $valid_domain ne $domain;
my $result = 0;
## Для идентичности поведения с почтовой системой:
# если имя пользователя содержит неразрешённые символы - пропускаем его
# Разрешены любые буквы, цифры и символы ".", "-" и "_"
if ($user =~ /^\w+[\w.\-_]*\w+$/) {
# Пытаемся восстановить соединение, если оно сброшено
unless ($dbh) { $dbh = db_connect }
# Подготавливаем запрос если соединение установлено. При неудаче - сбрасываем соединение
my $sth = $dbh->prepare("SELECT memberName, realName, passwd
FROM ${SMF_prefix}members
WHERE (ID_GROUP = $SMF_GID OR FIND_IN_SET($SMF_GID, additionalGroups)) AND realName = '$user'")
or $dbh = undef if $dbh;
# Выполняем запрос если соединение установлено. При неудаче - сбрасываем соединение
$sth->execute() or $dbh = undef if $dbh;
# Если соединение не сброшено
if ($dbh) {
# Получаем количество найденных строк
my $num = $sth->rows();
# Получаем ответ если он состоит ровно из одной строки
my $row = $sth->fetchrow_hashref() if $num == 1;
# Проверяем пароль или пользователя
if ($op =~ /auth/i and $num == 1) {
my $epass = sha1_hex(lc($row->{memberName}) . $passwd);
$result = $epass eq $row->{passwd} ? 1 : 0;
} elsif ($op =~ /isuser/i and $num == 1) {
$result = exists $row->{memberName} ? 1 : 0;
}
}
} else {
$result = 0;
}
# Отправляем ответ для ejabberd
my $out = pack "nn", 2, $result;
syswrite STDOUT, $out;
}
```
Кроме этого стоит убрать из секции **modules** конфигурационного файла *ejabberd* модуль **mod\_register**, поскольку зарегистрироваться на вашем Jabber сервере невозможно.
Вся остальная настройка Jabber сервера никак не привязана к авторизации. Соответственно, вы можете свободно настраивать конференции, логгирование и прочие возможности, в изобилие доступные в *ejabberd*, чтобы в итоге получить максимально соответствующий вашим задачам XMPP сервер.
#### В качестве резюме
Предложенное техническое решение позволяет легко предоставить вашим пользователям почтовый и XMPP адреса в вашем домене, при этом от пользователя не требуется никакая дополнительная регистрация и запоминание никаких дополнительных паролей и логинов. Адрес включается и выключается в профиле пользователя одной галочкой (или ещё как-то, в зависимости от реализации).
При этом пользователь получает полнофункциональный XMPP аккаунт со всеми дополнительными сервисами, которые вы только захотите ему предоставить. И почтовый адрес, который не привязан к какому-то конкретному физическому ящику. Кстати, обращаю внимание: отправлять почту с выданного адреса пользователь сможет без проблем, хоть и не через ваш SMTP сервер. Например, отправка от имени стороннего ящика реализована в Gmail, либо же можно использовать SMTP сервер провайдера.
С технической стороны выгрузка адресов для Postfix из вашей основной базы сводит на нет опасность сбоя основного сайта из-за проблем с почтой. Проблем с XMPP также не должно возникнуть, поскольку по сути XMPP сервер практически не связан с другими службами. Модуль авторизации просто проверяет присланный по зашифрованному соединению (особенность XMPP) пароль через базу, ничего не изменяя и не добавляя. Так что через него что-то плохое сделать тоже не получится.
Единственной проблемой предложенной схемы является теоретическая возможность компрометации основного ящика пользователя путём посылки специального письма, которое примет ваш сервер, но отклонит почтовый сервер пользователя. В этом случае отправителю придёт отбойка, в которой будет написан основной адрес пользователя. И хотя обычно узнать почтовый адрес не составляет никакого труда с помощью более простых способов, всё же включать почту для вашего домена нужно только по запросу пользователя, дабы не нервировать параноиков.
*Вот так, легко и непринуждённо, можно попытаться догнать и перегнать Вконтакте и Фейсбук. Описанная схема реально работает на нескольких сайтах достаточно продолжительное время. Любые комментарии, вопросы и предложения всячески приветствуются!*
#### Актуальная версия статьи
***Самая последняя и наиболее актуальная версия этой статьи, разбитая на две части — для [почты](http://help.ubuntu.ru/wiki/почтовые_адреса_для_пользователей_сайта) и [Jabber](http://help.ubuntu.ru/wiki/jid_для_пользователей_сайта), находится на официальном русскоязычном Wiki-ресурсе документации по Ubuntu. Там вы можете свободно улучшать и дополнять выложенные справочные и обучающие материалы, а также добавлять свои собственные. Если вам есть, что рассказать другим пользователям Ubuntu, то огромная просьба — напишите или отредактируйте соответствующую статью на [help.ubuntu.ru](http://help.ubuntu.ru/wiki). Даже небольшими улучшениями и дополнениями вы поможете тысячам людей, а кто-то из них, в свою очередь, опишет что-нибудь полезное и интересное для вас.*** | https://habr.com/ru/post/104741/ | null | ru | null |
# JPoint 2017 — конференция, которая смогла. Обзор лучших докладов в открытом доступе
Недавно коллега задал привычные уже вопросы про «зачем ходить на конференции» и «зачем смотреть записи на YouTube». Так как это друг, а не просто какой-то произвольный человек, захотелось ответить более обстоятельно, детально и по чесноку. К сожалению, в режиме онлайн, при живом общении, сделать это сложно: просто не упомнишь всех подробностей. С другой стороны, это отличная тема для хабрапоста: можно один раз написать развёрнутый обзор и потом, как истинный социофоб, отвечать на все вопросы ссылками на Хабр.
Идея проста: надо взять наиболее популярные доклады с JPoint 2017, кратенько пересказать, о чём там речь, почему это круто и зачем нужно лично мне. Каждый из этих докладов заслуживает отдельного разбора, но вначале — краткий обзор первой десятки. Поехали!
Интересно, что именно на этой конференции в топ попали два кейноута. Кейноуты по определению задают дух и тон конференции, они расчитаны на "вдохновение" и "расширение кругозора". Чтобы на узкой технологической конференции кейноут попал в топ — это надо постараться. Тем не менее, они все здесь. Программный комитет добился этого нехитрым приёмом: первый кейноут — традиционно популярный научпоп, второй делает Шипилёв (спикер-рецидивист, серийный делатель самых лучших докладов).
Чтобы сравнить свои ощущения от просмотра доклада, рядом с каждым из них будет средняя оценка участников конференции.
10. [Задача о коллективной (без)ответственности](http://2017.jpoint.ru/talks/collective-responsibility/)
========================================================================================================
Спикер: Алексей Савватеев; оценка: 4.38 ± 0.04.
Яркий доклад от популяризатора науки, в особенности — математики и теории игр. Доклад основывается на собственных исследованиях и на работе Оливера Харта и Бенгта Хольмстрёма (лауреатов Нобелевской премии по экономике 2016 года, которую дали за теорию контрактов).
Сначала даётся некая вводная для тех, кто забыл (или никогда не знал) базовые вещи про теорию игр и контракты. Этим отличается кейноутный доклад от «хардкора»: автор не сказал «все, кто завалил в вузе матчасть — встали и вышли из зала». Вместо этого он коротко и доходчиво объясняет тему на примерах, так что становится понятно кому угодно. Например, теорию контрактов можно использовать следующим образом: если у нас есть какая-то обычная кодерская контора, то строится модель всех вовлечённых лиц (работников, работодателя и т.п.) и в дальнейшем работодатель может управлять этой системой не с помощью прямых приказов, а с помощью тонко выбранных стимулов.
Алексей приводит большое количество примеров таких контрактов, в том числе и плохо работающих. Например, рассказывает о том, как с помощью неверно выбранных правил можно случайно заблокировать автомобильное движение. Короче, общая задача в том, как организовать процесс правильно.
По цепочке примеров мы приходим к объяснению [равновесия Нэша](http://mipt.ipu.ru/sites/default/files/page_file/%D0%A2%D0%98%C2%A3%D0%B0-03_0.pdf) на примере задачи о турникетах. Нэш — это тот товарищ, который был главным героем фильма «Игры разума», получил Нобелевку по экономике в 1994 году и Абелевскую премию по математике в 2015. Нэш доказал очень общую теорему существования равновесия в играх. Приводятся такие актуальные примеры, как деньги и вера в их стоимость и сравнительная уверенность в качестве преподавания в вузах.
Очень круто, что Алексей прямо в ходе доклада организовал brainstorm вместе с аудиторией — и в аудитории реально были люди, способные поддержать беседу. Обычно такие попытки выглядят жалко, но в данном случае они как бы были частью доклада. К сожалению, почувствовать этого на записи нельзя, но это был один из немногих докладов, где я присутствовал вживую. В таком формате обсуждали, например, вторую часть задачи о турникетах.
И наконец, на основе этого мы переходим к центральной теме доклада: о том, как к докладчику обратились с просьбой решить задачу неуплаты налогов при высоком уровне коррупции. Строится модель, формализуется задача и вопрос решается в рамках теории игр, в ходе чего мы натыкаемся на ряд очень интересных следствий и наблюдений.
Вообще говоря, это предполагалось стать критической статьей, но понятно, что моих знаний в теории игр никогда не хватит, чтобы критиковать настоящего учёного на его поле боя. Правильно ли он выбрал модель? Корректны ли расчёты? Да чёрт его знает. В первую очередь меня зацепил образ мышления автора, который можно проследить как в видеозаписи доклада, так и при общении вживую. Этот способ мышления — он как почерк.
Все программисты так или иначе решают проблему моделирования на своих языках программирования, но в случае Алексея разговор идёт о крайне сложных реальных проблемах, которые натягиваются на очень высокоуровневые математические абстракции, что вместе позволяет построить весьма контринтуитивные выводы и проверить их на практике. Для меня кейноутная ценность этого доклада именно в этом — в мгновении внезапного просветления и прозрения, когда начинаешь видеть «Матрицу» простых вещей другими глазами.
9. [Перформанс: Что В Имени Тебе Моём?](http://2017.jpoint.ru/talks/performance-whats-in-it-for-youh/)
======================================================================================================
Спикер: Алексей Шипилёв (Red Hat); оценка: 4.38 ± 0.03.
Ещё один кейноут, на этот раз про перформанс. Вначале Лёша обсуждает критерии успешной разработки. Конечно же, грамотно примазывается к аудитории, рассказав о том, что главный критерий бизнеса — это бабло, а мы, программисты, зарабатываем тонну бабла!
Пока аудитория не оправилась от лести, начинается бомбардировка более печальными техническими вещами типа общения с безопасниками. Из чего делается вывод, что перформанс в топе влияния на успешность проекта — не самая важная штука. Забавно это слышать от чувака, который перформансом занимается — обычно всякий кулик хвалит своё болото.
Дальше сравнивается корректная программа и быстрая программа, и приводится слайд с [кривой имени Ш](https://youtu.be/p2b4JHESEOc?t=5m45s). Имхо, этот слайд — один из самых просветляющих моментов, позволяющий найти себя в Общей Картине Всего. Если из доклада хочется посмотреть всего один слайд, то вот он.
Лёша аккуратно проходится по всем уровням диаграммы, и лично для меня эти рассуждения имеют весьма чёткое применение. Например, это хорошо формализованный список аргументов в определении перформансной стратегии и для борьбы с вредными утверждениями типа «профилировать нужно или нормально, или вообще никак» (когда находимся в зелёной зоне). Обсуждается и кнут с его «преждевременной оптимизацией» в роли главного аргумента всех споров. И как продать начальству свою работу по улучшению перфоманса. И что делать, когда к тебе приходят продавать какую-то дичь, типа новой супербыстрой базы данных.
Заспойлерю пару слайдов:
Таких слайдов там невообразимое количество, и что характерно — все они строго по делу. Что, в общем, и стоило ожидать от чувака, который этим зарабатывает на жизнь. Не сказать, что это какие-то супертайные знания, но для меня их ценность — в максимально чёткой, вылизанной формулировке и организации информации.
Примеры, конечно, там жесть: какие-то куски кода из javac с падением скорости компиляции от 2 до 8 минут, доказательства через закон Амдала и [Universal Scalability Law](http://www.perfdynamics.com/Manifesto/USLscalability.html) и т.п. Хотя откуда бы у Лёши другие примеры?
Есть подозрение, что какие-то эксперты по перформансу затаили теперь злобу на докладчика, ибо он в одном докладе сдал все их основные секреты и темы консультаций.
8. [Будущее Kotlin: Стратегия и тактика](http://2017.jpoint.ru/talks/the-future-of-kotlin-how-agile-can-language-development-be/)
=================================================================================================================================
Спикер: Андрей Бреслав (JetBrains); оценка: 4.41 ± 0.08.
Кто не слышал ничего про Kotlin? Ну точно не мы. Все новости переполнены Котлином, интернет бурлит, и вот к нам на огонёк приходит руководитель этого проекта — Андрей Бреслав. Андрей рассказывает именно о будущем языка и платформы, поэтому он вполне может ошибиться, но менее ценным это доклад не делает.
Во-первых, интересно, что Андрей действительно может говорить от имени продукта. Он может говорить сразу целиком рынками: будет ли драться Kotlin за Big Data со Scala, будет ли он сражаться за Data Science с Python. Если на первых слайдах он говорит: «Our creed: Pragmatic Language for Industry (Interop, Tooling, Safety) for JVM, JS and Native platforms» — значит, так оно и есть. На этом слайде можно закрыть дискуссии в чатиках на тему, является ли поддержка отличающихся от JVM платформ реальным приоритетом.
Тут же Андрей объясняет, что они не стараются добиться, чтобы любую программу можно было запустить на любой платформе. «Write once, run everywhere» — это для Java, а котлиновцы этим заниматься не будут. Это тоже ценный кусочек мозаики — ценный для того, кто уже прямо сейчас проектирует Kotlin-ориентированные архитектуры. Имхо, для архитекторов этот доклад неоценим тем, что можно с берега начать понимать, с кем ты связался и на что собираешься подписываться.
Там же из зала можно было задать другие неудобные вопросы типа: а когда будет поддержка Objective-C, полезные библиотеки типа сокетов в Kotlin Native и т.п. Вопросы неудобные, но Андрей как-то выкрутился :-) Очень много было вопросов именно про native, в докладе всерьёз обсуждалось применение Kotlin в embedded. Был вопрос про Kotlin на Arduino и zero cost abstractions и обсуждение, что, если писать для Arduino как для сервера — это, вообще-то, полный отстой.
Вообще, доклад получился очень специфический. О планах, амбициях, стратегии.
Очевидно, что он является очень важным для всех, кто уже связывает своё будущее с Kotlin. Для всех остальных… Ну, скажем так, каких-то особо «продающих» кусков доклада — «съешь меня», «выпей меня», «купи меня» — не было, и это очень меня подкупило. Чуваки стали уже такими толстыми, что им даже не нужно продаваться и трясти рекламными буклетами на каждом углу. С другой стороны, если тебе изначально хотелось понять, на кой чёрт тебе Kotlin — с этим тут негусто, и определяться придётся по каким-то косвенным признакам.
Для меня основная польза этого доклада была в не высказанной явно, но прослеживающейся идее: Kotlin будущего — это не тот Kotlin, который есть сейчас. Если сейчас меня по мелочи что-то раздражает, то в будущем это скорее всего будет исправлено. В частности, люди серьёзно задумываются над такими вещами, как метапрограммирование, которое для меня стало блокером для Golang на большом спектре задач. Очень достойная идея о том, что плагин в компилятор автоматически становится плагином в IDE, что при внедрении кодогенераторов Golang опять же может стать болью, и надо её решать. Короче, Kotlin можно брать как стратегическое решение с большим будущим.
7. [Верификация Java байт-кода: когда, как, а может отключить?](http://2017.jpoint.ru/talks/java-byte-code-verification-when-how-or-maybe-to-turn-it-off/)
==========================================================================================================================================================
Спикер: Никита Липский (Excelsior); оценка: 4.42 ± 0.07.
Завязка такова, что Никита делал простой студенческий доклад об анатомии JVM.
На нём выяснилось, что не только студенты, но и взрослые матёрые разрабы зачастую имеют пробелы в базовых знаниях и не понимают, как работает верификатор байткода.
Такие штуки как GC не требуются спецификацией, и в принципе сборку мусора можно отключить (н-р с помощью Epsilon GC). В противоположность этому, байткод жёстко прописан в JVMS и на один и тот же байткод VM должна отдать один и тот же результат (вне зависимости, корректен он или нет). В результате верификатор пишется один раз, и потом про него забывают. (До поры до времени, мы-то знаем, что Value Types потребуют изменений в верификаторе.) И поэтому в мире есть от силы десяток человек, которые когда-либо писали верификаторы, и Никита — один из них.
Вот в этом слайде всё содержание доклада:
И к вопросу, «зачем ходить на конференции» и «зачем смотреть записи» — в текстовом виде в интернете сложновато добыть связное изложение этих вопросов.
Забавная фотка — количество людей, которые смотрели class-файл изнутри. Почти весь зал. Хм, зачем им это? :-) Если честно, до того, как я начал копаться в кишках JVM и просто кодил веб-приложухи, у меня даже мысли не возникало начать изучать такие подробности, скукота же (на самом деле нет).
Вначале Никита даёт развёрнутую вводную о том, какова структура class-файла, что такое байткод и какие там бывают инструкции и т.п.
Присутствует игра «кто хочет стать миллионером», ~~как [Gil Tene](https://www.azul.com/leadership/gil-tene/)~~, и разные интересные примеры.
Дальше мы вместе с Никитой пробегаемся по стадиям загрузки класса в JVM (loading, linking, initializing) из пятой главы JVMS. Верификация — это первая стадия этапа линковки. После чего мы опускаемся в подробности верификации: проверки на статические (static constraints) и структурные ограничения (structural constraints). Статические проверки делаются в два прохода, на выходе получается control flow graph байткода метода, а структурные ограничения проверяют более сложные вещи, например, что глубина стека в каждой инструкции должна быть определенной величины для любого пути исполнения.
Магия верификатора работает на статическом потоковом анализе, который иногда объясняют в институтах на теории программирования или теории схем программ. Сразу было понятно, что Никита уж как-то слишком складно излагает эту часть — и оказывается, он ведет лекции по потоковому анализу. Каким-то образом сквозь Программный комитет конференции в этом месте просочилась матчасть про полурешётки свойств и так далее.
Вся эта матчасть, тем не менее, легко ложится на привычные джависту вещи вроде Stack Map Frame и конкретные байткоды. Про это есть куча хороших иллюстраций. Более того, мы можем даже посчитать реальное время выполнения задачи верификации, и что с этим сделали в Java 5. После чего обсуждается множество разных чисто практических вещей.
Лично для меня этот доклад дал прочное обоснование (как с точки зрения теории, так и практики) о том, почему рекомендации отключать верификатор байткода (`java -jar -Xverify:none MyApp`) — это чистое безумие, и что к [критике верификатора](http://chrononsystems.com/blog/java-7-design-flaw-leads-to-huge-backward-step-for-the-jvm) нужно относиться с большой долей скепсиса. Кроме того, это может здорово помочь при использовании таких библиотек, как [ASM](http://asm.ow2.org/) (рекомендации по использованию ASM даны прямо по ходу доклада).
6. [Проклятие Spring Test](http://2017.jpoint.ru/talks/spring-test-horror/)
===========================================================================
Спикеры: Кирилл Толкачев (Альфа-Лаборатория) и Евгений Борисов (Naya Technologies); оценка: 4.45 ± 0.05.
Это чисто практический доклад, рассказывающий, как тестировать куски своих микросервисов и применять различные принципы, обсуждаемые в докладе.
Он очень отличается от предыдущих докладов про устройство JVM обилием близких сердцу веб-разработчика вещей вроде живой демонстрации чата, написанного на Spring с использованием стандартной архитектуры с REST и очередями. Рассматриваются животрепещущие вопросы на тему, что мы можем по-быстрому замокировать, а что у нас развалится при использовании наивного подхода.
В качестве акта лёгкого троллинга докладчики тестируют не какие-то произвольные веб-сервисы, а мозг Баруха Садогурского ([@jbaruch](https://habrahabr.ru/users/jbaruch/)) и Егора Бугаенко ([@yegor256](https://habrahabr.ru/users/yegor256/)). По условию задачи, ответы Баруха — кэшируются, а Егор может со временем менять мнение и обязательно перед ответом раздумывает (получает данные с помощью очереди).
Писать про этот доклад особо не имеет смысла — его надо именно смотреть. Докладчики живо и интересно показывают основы тестирования с помощью Spring — не только какие-то сухие факты, а именно разработку с нуля до работающего приложения. Интересно, что изначально многие вещи намеренно делаются неправильно и потом эволюционным путём допиливаются до идеала.
Я точно пересмотрю этот доклад в следующий раз, когда нужно будет делать проект на Spring и Spring Boot. Стало понятнее, зачем нужен `@SpringBootTest` (сделать тест на полный контекст, поменять properties, сделать тесты с определенным скопом — пакет/конфигурация/автоскан), чтобы сохранить изоляцию теста — нужен `@TestConfiguration`, а `@SpringBootConfiguration` нужен только для сигнализации `@SpringBootTest`, что ему пора остановиться. В целом, стало понятно, что тестирование с использованием Spring может быть быстрым, но кэш легко поломать, и для тестов следует использовать только `@TestConfiguration`.
Имхо, повторюсь, в этом докладе важнее сам процесс разработки и понимание его эволюции, чем конкретный финальный список выводов. Самостоятельно к тем же выводам прийти можно, конечно — но с бездарной потерей огромного количества времени.
5. [Spring – Глубоко и не очень](http://2017.jpoint.ru/talks/spring-deep-and-not-very/)
=======================================================================================
Спикер: Евгений Борисов (Naya Technologies); оценка: 4.46 ± 0.05.
Ещё один доклад Жени Борисова, который отлично дополняет уже присутствующий в топе «Проклятие Spring Test».
Выводы из доклада, внезапно, даются на первом же слайде, поэтому давайте пробежимся по ним:
* Spring не идеален, но лучше ничего нет. И он всё равно достаточно хороший, поэтому мы его любим;
* На Spring можно и нужно строить свою платформу;
* Не бойтесь его чинить, но не забывайте, что он чинит себя сам;
* Читайте в спеке про обновления.
Женя начинает доклад с известного слайда:
Это к вопросу о том, зачем нужно общаться вживую с разработчиками, ходить на конференции и смотреть свежие записи. Вот это наблюдение Жени я прочувствовал на своей шкуре: значительная часть утверждений про Spring либо враньё, либо безнадежно устарело.
Например, идея самовпрыскивания. При использовании транзакционности бин, который вызывает собственный метод, должен использовать не `this`, а прокси на себя. Для этого нужно заинжектить самого себя (точнее не самого себя, а собственный прокси). Откуда берётся такая ситуация — Женя подробно объясняет. Это не работало до Spring 4.3, хотя можно было воспользоваться аннотацией `@Resource`, и иногда это срабатывало, а в XML это работало всегда. Начиная со Spring 4.3 начали работать `@Autowired` и `@Inject`, но не стандартный Java-конфиг (семантика Java не позволяет сделать такую хитрую штуку). И всё это заняло **четыре с половиной года**, начиная с создания бага в трекере Spring.
Следующий пример — про проклятый `PropertySourcesPlaceholderConfigurer`. Сколько эта штука (точнее, её кастомные реализации) кровушки из меня попила. Женя указывает на то, что в версии 4.2 нужно было его в джаваконфиге указывать как `static` (иначе всё упадёт с ошибкой), а в свежих версиях — можно либо указать только `@PropertySource`, либо не указывать вообще, если это Spring Boot. Между этими вещами — тоже годы.
Примеры, кстати, жгут напалмом. Например, циркулярные зависимости между бинами иллюстрируются примером с мужем, который инжектит внутрь себя жену.
Из этих примеров я вынес мысль, что пихать логику в `@PostConstruct` для блокирующего запуска бизнес-логики — это плохо. Если честно, все эти годы такая мысль даже не приходила в голову (ну это потому что я быдлокодер, бывает) — ведь все эти проблемы решаются тщательно подобранными костылями. Женя рассказывает, как правильно писать такой костыль — самодельную аннотацию `@Main`, которая делает понятно, что.
Грубо говоря, делается eventListener (новый компонент, в нём над методом — аннотация `@EventListener`, а в параметрах — какой event мы хотим отловить). Нам нужен `ContextRefreshedEvent`. Потом необходимо пробежаться по BeanDefinition'ам, найти и дернуть `@Main`. Но при этом для того, чтобы всё это заработало под Spring Boot, нужно провести определённые манипуляции. Здесь я всё это описывать не буду, кому интересно — посмотрит доклад. Тем более, что для людей, не погружённых в Spring, вся эта магия методов с названиями длиннее 80 символов кажется какой-то дичью. Впрочем, в докладе рассказывается, как сделать, чтобы вся эта дичь подключалась автоматически просто с помощью добавления зависимости в Maven, дабы вам не приходилось каждый раз лезть в этот ад.
И дальше рассказывается ещё много интересных, а иногда и совершенно запретных вещей с написанием `BeanFactoryPostProcessor` и разруливанием версий Spring. Уверен, что существуют люди, которые наслушались Женю, применили всё это неправильно и потом их сожгли живьём :-)
В целом, доклад позволяет лучше понять, как работает Spring, Spring Boot, и самое главное — нюансы идеологии, которые простым чтением джавадоков не понять. Тут нужно вмешательство и совет опытного Spring-джедая, коим Женя и является. Этот доклад (и другие доклады Жени) стоит пересмотреть сразу же, как стандартных возможностей начнёт не хватать, и захочется написать побольше `BeanPostProcessor` и `BeanFactoryPostProcessor`.
4. [Повесть о том, как один инженер HTTP/2 Client разгонял](http://2017.jpoint.ru/talks/performance-engineering-story-how-oracle-optimized-http-2-client/)
==========================================================================================================================================================
Спикер: Сергей Куксенко (Oracle); оценка: 4.47 ± 0.06.
Как все, наверное, уже знают, HTTP/2 aka [RFC 7540](https://tools.ietf.org/html/rfc7540) — это протокол, придуманный господами из Google или ещё кем-то, чтобы заменить старый ламповый HTTP/1.1.
Основную роль в дальнейшем повествовании играют несколько отличий /2 от /1.1:
* Бинарный формат (использование Frames)
* Мультиплексирование множества запросов в единственном TCP соединении
+ `=> => ...`
* Сжатие заголовков (HPACK aka [RFC 7541](https://tools.ietf.org/html/rfc7541))
По сути, HTTP/2 — это такая низкая транспортная подложка, решающая конкретные проблемы предыдущего стандарта.
С другой стороны, в OpenJDK есть [JEP 110](http://openjdk.java.net/jeps/110), «HTTP Client», который был выпущен в рамках JDK 9, но пока не стал частью Java SE. Его выпустили ровно настолько, что его можно посмотреть и обсудить. Выглядит оно примерно так, как и можно ожидать: конструктор с урлами, синхронный и асинхронный API и т.п. Клиент универсальный и работает как с HTTP/1.1, так и с /2.
Докладчик и есть тот человек, который занимался перформансной работой над этим клиентом, о чём он в дальнейшем и рассказывает. Цель в том, чтобы получить достаточно быстрый клиент за разумное время работы разработчика.
Вначале он его побенчмаркал, в надежде, что, возможно, в клиенте и менять особо ничего не надо. В качестве конкурента для сравнения использовался клиент Jetty.
Как-то печально вышло. В данном случае была известная проблема с `TCP_NODELAY`, если кто-то помнит, что это такое. Про некоторые особо известные косяки люди иногда просто забывают. Тем не менее, Сергей утверждает, что все эти вещи — это не какие-то тайные знания, и типичные косяки очень легко гуглятся и изучаются любым новичком.
Интересно, как это устроено в голове у настоящего специалиста по перформансу. Не у дилетанта какого-то, а у самого настоящего. Он не читал спеку по протоколу до самого последнего момента. Профилировал, писал перформансные тесты, смотрел интерфейс профайлера — но полез читать спеку только в самый последний момент, когда оказалось, что существуют жирные функции, которые отжирают много ресурсов, но по названию непонятно, что они делают. То есть рефлекс «всегда вначале читай спеку», возможно — не самый правильный.
С другой стороны, раз уж читаешь спеку, читай её аккуратно и используй встроенные в неё хаки. После использования нужных хаков клиент начал обгонять Jetty — вот что сила спеки животворящей делает!
В докладе всё это иллюстрируется на реальных данных из предметной области написания HTTP-клиента. Например, предыдущий пример по спеку иллюстрировался процедурой расширения окна в HTTP/2. Наверное, для какой-то части аудитории этот вопрос сам по себе является актуальным, и все примеры с граблями там — это реально полезно. Для меня, если честно, было не очень: в повседневной практике веб-быдлокодинга ты обычно используешь такие библиотеки, однажды раз и навсегда написанные суперпрофессионалами.
Кроме этого, есть ещё набор забавных лайфхаков. Существует миф, что перформансник круглые сутки сидит в Mission Control и делает на его основе какую-то чёрную магию. В практике Сергея, скорей всего он просто будет валить логи в файл и смотреть их подручными способами вот так:
Сразу после этого наглядно показывается, как в сетевой библиотеке можно рефакторить жирный код под глобальным локом в быструю очередь. Блокировки — зло, и простым рефакторингом можно выжать многое.
Параллельно развенчиваются мифы о том, что переход от GC на пулы автоматически сделает нам хорошо — в реальности же можно прийти к ситуации, когда мы не имеем от пулов ничего хорошего, но имеем все минусы работы без пулов.
Там ещё много интересного, но нельзя же хабрапост превращать в огромный сборник скриншотов (хотя хочется).
В целом, доклад оставляет ощущение хорошо переданного майндсета инженера-перформансника, занимающегося работой с сетью, которым **внезапно** можешь оказаться ты сам. И в качестве бонуса позволяет пройтись по типичным граблям разработки HTTP-клиента.
3. [Fast and Safe Production Monitoring of JVM Applications with BPF Magic](http://2017.jpoint.ru/talks/fast-and-safe-production-monitoring-of-jvm-applications-with-bpf-magic/)
================================================================================================================================================================================
Спикер: Sasha Goldshtein (Sela Group); оценка: 4.49 ± 0.07.
Итак, мы переходим к первой тройке. Этот доклад был особо сложным для понимания. Дело в том, что в целях написания этой статьи я пересматривал все записи на двукратной скорости. Саша сам по себе говорит быстрее обычного человека, плюс весь доклад ведётся на английском языке. Эта комбинация реально выносит мозг, так что если вы слушаете его в первый раз — стоит включить стандартную скорость.
Суть в том, что тот софт, который обычно используется для мониторинга приложения на C++ или Python и на котором Саша собаку съел, можно отлично использовать и для мониторинга JVM-приложений. Всё это будет, конечно, на Linux.
Глобальная задача доклада такова:
В этом плане сразу бросается в глаза слово BPF, о котором многие даже не подозревают. В принципе, в интернете можно найти и [другие доклады](http://www.brendangregg.com/blog/2016-03-05/linux-bpf-superpowers.html) на схожую тематику, но не применительно к Java.
Я не буду спойлерить весь этот чудесный доклад, а начну с небольшой затравочной истории, которая у непосвященного может вызвать священный трепет.
Доклад начинается с обсуждения других средств мониторинга, с учётом статуса их разработки (все инструменты поделены на новые, стабильные и мёртвые). Например, стабильные вещи типа: `ftrace`, `perf`, `SystemTap` (он требует компилировать и динамически загружать модули ядра — в том числе, на продакшне). Есть новые штуки: `SysDig` (очень простая, но фич мало), `BPF` с биндингами на разные языки. Есть ещё много разного — `dtrace for Linux`, `ktap`, `LTTng` и т.п.
Дальше мы выясняем, какие вещи можно узнать про JVM. Оказывается, в JVM есть специальные трейспоинты, которые можно включить и соединяться к ним внешним софтом:
Кроме того, Саша написал тулзу `tplist`, которую можно вызывать как `tplist -p `pidof java`` и которая отображает всё это в виде плоского списка, чтобы не нужно было глазами вычитывать.
Интересно, что у всех этих поинтов есть параметры, так что если мы грепнем по `monitor__waited`, то обнаружим структуру из четырех полей (signed, unsigned, unsigned, signed). К сожалению, кроме типов значений, просто так мы о параметрах ничего не узнаем. Но инфу всё-таки можно отрыть в `.stp`-файлах, хотя и не в самой удобной форме. Как минимум, оттуда можно вытянуть имена аргументов.
Дальше, чтобы перейти к `BPF`, Саша приводит пример приложения, которое нужно отладить на проде: понять, какой кусок кода печатает в консоль ересь, при условии, что отладчиком подключиться нам не дадут. Задача ужасная, обычный админ сбежит от неё в ужасе. Нужно подключить `-XX:PreserveFramePointer` (дающий 3% оверхеда), и дальше используется утилита `trace` из `BCC`:
```
trace `SyS_write (arg1==1)` "%s", arg2' -U -p `pidof java`
```
trace обязательно запускается под рутом. Дальше мы говорим, что надо трейсить (в данном случае — `SyS_write` — сискол на запись), выставляем условие (`(arg1==1)`), сообщение для вывода (`"%s", arg2`), `-U` — userspace call stack, ну, и конечно фильтрануть по PIDу. Получается как-то так:
Дальше с помощью предварительно написанной скриптятины (`create-java-perf-map` из `perf-map-agent`) превращаем адреса методов в их настоящие названия методов в Java.
Дальше нужно немного покопаться в выхлопе наших команд — и ура! Мы только что получили конкретное место, которое выводит нужные строчки.
Можете провернуть такой фокус у себя на проде: непривычный к такому тулингу обыватель может посчитать это магией и поверить во всё, что угодно. В следующий раз можно будет сказать админу, что ты умеешь читать его мысли и поднимать мёртвых.
Этот доклад переполнен такими фантастическими штуками, которые на самом деле объясняются использованием продвинутого тулинга, в том числе утилит из `BCC`.
Java-приложение слишком часто собирает мусор с помощью System.gc() и хочется узнать — почему? Да пожалуйста, только кроме `-XX:PreserveFramePointer` придётся включить ещё и `-XX:+ExtendedDTraceProbes` — очень дорогую опцию, которую не получится держать на постоянку. Если часто просить админа включать и выключать её — он может догадаться, что ты не настоящий некромант (на самом деле, ты хуже — ты джавист, который сейчас вынесет ему мозг). Ну и после этого провести адский ритуал, о котором рассказывает Саша: нужно будет аттачнуться к `method__entry`.
Кроме того, Саша расскажет, чем плох `perf` (спойлер: выталкивает слишком много данных для анализа в юзерспейсе) и о всяких таких вещах.
Очень рекомендую прослушать и сделать выводы из этого доклада совершенно всем, кто занимается перформансом Java-приложения на платформе GNU/Linux. Это абсолютный **must have**.
2. [Сделаем Hibernate снова быстрым](http://2017.jpoint.ru/talks/hibernate-performance-tuning/)
===============================================================================================
Спикер: Николай Алименков (EPAM); оценка: 4.51 ± 0.04.
Что когда-нибудь ещё придётся увидеть Hibernate в топе докладов на втором месте — оказалось сюрпризом, если не шоком. Hibernate — это такая штука, которую выпустили [в 2001 году](https://en.wikipedia.org/wiki/Hibernate_(framework)). Разве за все эти годы про него не сказано всё, что только возможно? Остались ли ещё люди, которые будут это слушать?
Остались. Но только в случае, если это действительно хороший доклад, а Николай Алименков — именно тот человек, который разбирается в сортах Hibernate. В течение лет эдак пяти он делает доклады с холиворными названиями типа «Почему я ненавижу Hibernate» или «Босиком по граблям Hibernate», и так далее — список велик, и часть из них можно [пересмотреть на YouTube](https://www.youtube.com/watch?v=YzOTZTt-PR0&t=3s).
Хочется сказать, что озвученная в заголовке проблема мне действительно близка. Люди используют Hibernate неправильно, отказываются думать мозгом, не читают умных книжек и потом плачут, что «Hibernate тормозит». С одной стороны, это вызывает такое неприятное ощущение, нечто среднее между жалостью и снобским презрением. С другой стороны, если у системы такой API, что с большинство пользователей не может освоить его в течение почти 17 лет — с таким API явно что-то не так.
Николай в первом же слайде делает disclaimer на тему, что это только его персональный опыт. Но в данном случае наш опыт полностью совпадает.
Доклад начинается с небольшой обязательной вводной о том, что же такое Hibernate, какую задачу он решает — универсальный ООП-адаптер на все базы данных, показывает, что Hibernate работает не магически, а внутри себя использует всё тот же JDBC, JTA в контейнере и так далее. Взглянув всю цепочку уровней абстракции, мы понимаем, что на перформанс может влиять любая её часть и любой переход, и чтобы их улучшать — надо уметь их измерять.
Для измерения предлагается использовать логи самого Hibernate (`hibernate.generate_statistics=true`, логгер `org.hibernate.stat` на уровне `DEBUG` и т.п.) либо писать микробенчмарки на [JMH](http://openjdk.java.net/projects/code-tools/jmh/).
Для того, чтобы посмотреть, какие запросы уходят в базу, предлагается использовать всевозможные datasource proxy (p6spy, datasource-proxy и т.п.) и смотреть сырые данные. Можно поставить [какой-нибудь](https://github.com/vladmihalcea/db-util) counting interceptor — чтобы посчитать, сколько физических запросов отправилось в базу. Ну и конечно, можно в самом Hibernate включить логирование запросов.
Дальше Николай показывает, как много интересного можно вычитать в логе Hibernate даже относительно сравнительно небольшого запроса. Лог кричит и визжит, что у тебя всё неправильно, и нужно срочно переделывать. (Правда, обычно его никто не читает, пока гром не грянет.) В том числе лог рассказывает, как читать статистику в логах, куда и на что тратилось время.
В докладе рассказывается об основных вещах, которые можно и нужно тюнить. Например, настройки JDBC, такие как правильная реализация connection pool — в зависимости от выбранного пула, перформанс может отличаться в разы. Стоит взглянуть на размер батча, рассмотреть возможность перехода на нативные запросы или даже использовать голый JDBC в Session.doWork(), если всё действительно плохо.
Николай не гнушается пробежаться по проблемам, которые все якобы должны знать, но на самом деле все забивают. Например, знаменитая N+1. Если вам кто-то говорил, что «мнение, что N+1 — это проблема, устарело», то… нет, так не пойдёт. Это просто от лени и нежелания думать. Не беда — за тебя подумал докладчик: далее следует огромная секция про то, как уменьшать количество запросов, включая такие сравнительно редко используемые фичи, как NamedEntityGraph (это фича не Hibnerate, а JPA, но одно другому не мешает).
Дальше по ходу рассматриваются батчи, second level cache и так далее. Ясно, что все, кто действительно работал с Hibernate, знают про second level cache, но не все понимают, как это работает, и самое главное — что транзакционный режим есть только у каких-то отдельных решений (потому что этот режим слишком тяжеловесный). Рассматривается способ работы Query Cache и так далее и тому подобное.
В целом, этот доклад не рассказывает каких-то действительно новых вещей, которые никто раньше не знал или которые нельзя найти в документации. Но он даёт очень чёткий и проверенный в бою чек-лист вещей, которые можно и нужно тюнить при работе с Hibernate. Как же этот доклад пролез в топ? Мне кажется, секрет в том, что этот курс на самом деле — идеальный курс молодого бойца, пройти который в особенности стоит перебежчикам из других технологий типа Ruby. Представьте, что вы нанимаете людей, которые раньше пользовались другими решениями (не Hibernate) — вы можете либо потратить несколько дней на адскую работу по составлению своего «курса молодого бойца», а можете просто отдать им видеозапись этого доклада. И уже поверх него наворачивать «мясо» по раскрытию разных специальных тем и инструментов.
1. [Shenandoah: сборщик мусора, который смог](http://2017.jpoint.ru/talks/shenandoah-the-garbage-collector-that-could/)
=======================================================================================================================
Спикер: Алексей Шипилёв (Red Hat); оценка: 4.64 ± 0.04.
И наконец, наш победитель. Как всегда, это доклад Лёши.
А это ведь странно. Как получается, что он раз за разом делает самые популярные доклады? Давайте оглянемся назад на наш рейтинг: Hibernate использует значительная часть аудитории (допустим, треть), Spring — тоже немало. Почти каждому приходилось мониторить и разбираться с перформансом на проде и так далее. Но писать свой Garbage Collector?
Кажется, тут играет свою роль загадочная русская душа, тяготеющая к небывалому хардкору. Если посмотреть на людей, выползающих после доклада Шипилёва из зала, то большинство из них как будто оплавились от вспышки сверхновой. (Некоторые, конечно, ничего не слушали и смотрели на картинки — им норм.)
Кстати, как вы, наверное, помните, я пишу эту статью, пересматривая все доклады на двукратной скорости. На этой скорости Лёша говорит так быстро и такие страшные вещи, что у меня из ушей потекла кровь.
Собственно, возвращаясь к теме. Доклад — о новом Garbage Collector под названием Shenandoah, который делает команда Лёши. Его отличие в том, что он работает с очень низкими паузами. Слово «Shenandoah» читается как «Шенандоа» (как [национальный парк](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D0%BD%D0%B0%D0%BD%D0%B4%D0%BE%D0%B0_(%D0%BD%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BF%D0%B0%D1%80%D0%BA)) в США и река в нём) или в обиходе просто «Шинандá» (с ударением на последний слог).
Во-первых, доклад начинается с предложения до его прослушивания прочитать [GC Handbook](http://gchandbook.org/). Дело в том, что большинство алгоритмов GC берётся из этого учебника, а все новшества — это некие небольшие дополнения к ним. Но раз мы уже на докладе — уже поздно читать GC Handbook. Придётся ближайший час выживать без него.
Первые слайды — это крупная картина вещей, происходящих вокруг GC. Ландшафт существующих решений и место Shenandoah в этом мире.
Крупно рассматривается, как устроена в Shenandoah куча, как работает цикл сборки и так далее.
Там есть две паузы, но они субмиллисекундные, и для большинства задач этого более чем достаточно. Главное достижение в том, что жирная часть, которая в другом коллекторе ушла бы в паузу, в случае Shenandoah делается параллельно с коллектором.
Дальше рассматриваются все стадии этого процесса. Вначале — Concurrent Mark, который в принципе решён человечеством в различных GC, но не без проблем, влияющих на производительность. **ЧТОБЫ НАЙТИ МУСОР — НУЖНО ДУМАТЬ КАК МУСОР!**
Рассказываются о преимуществах и недостатках этих подходов (включая первый, реализованный в [Epsilon GC](https://habrahabr.ru/post/321856/), который написал Лёша же).
Рассматриваем чёрно-серо-белый алгоритм Дейкстры. Видим, как при выполнении STW-сборки граф волнообразным движением перекрашивается из белого в серое, а потом в чёрное.
Узнав, как устроен STW, смотрим на concurrent-реализацию, её проблемы и решения (incremental update и snapshot-at-the-beginning — SATB).
Конечно, всё это приправлено кучей ассемблера и совершенно адских рассуждений, которые нужно переслушивать по нескольку раз :-)
В конце концов мы приходим к выводу, что в init mark и final mark самое жирное — это rootset, и корень зла — размер этого рутсета.
Но это только начало, потому что concurrent copy — куда сложней, чем concurrent mark. Мы снова возвращаемся к тому, как работает stop the world.
Думаю, дальше описывать происходящее нет смысла, потому что — смотрите цитату с картинки. Это однозначно лучший доклад про Garbage Collection, сделанный на русском языке. А может быть, лучший доклад про Garbage Collection вообще.
Кроме того, у него есть продолжение, сделанное осенью на Joker 2017, но пока что ещё не выложенное в публичный доступ.
Рекомендую посмотреть этот доклад трём основным категориям слушателей:
* Специалистам, плотно работающим с JVM и её перформансом, которым в точности нужно представлять работу Shenandoah и работу GC вообще;
* Всем, кому хочется узнать больше о магии, благодаря которой работает наша Java-платформа;
* Всем, кому так или иначе нужно прочитать о GC. Потому что в интернете информации о внутреннем устройстве GC сильно меньше, чем хотелось бы. Детали реализации, очевидно, не являются частью стандарта, чтобы сесть и почитать. Информацию о них можно взять только из таких вот уникальных докладов.
Заключение
==========
В этой статье мы кратко рассмотрели все самые популярные доклады на [JPoint 2017](http://2017.jpoint.ru/). Вполне возможно, по большинству из них будут выпущены отдельные статьи на Хабре с подробными расшифровками.
Крайне рекомендую самостоятельно пробежаться по всем этим докладам и сделать собственные выводы. Каждый из них занимает всего около часа.
История JPoint на этом, конечно, не заканчивается. В этом году, 6-7 апреля, на площадке Конгресс-центра ЦМТ в Москве пройдёт следующий [JPoint 2018](https://jpoint.ru/), на котором будет много новых, интересных и полезных докладов. [Приобрести билеты](https://jpoint.ru/tickets/) можно уже сейчас. | https://habr.com/ru/post/346364/ | null | ru | null |
# Нужно ли современному программисту уметь создавать алгоритмы?
После негативной реакции хабровчан на мою [прошлую заметку](https://habr.com/ru/post/470407/) про собеседование программистов, пришлось хорошенько порефлексировать, чтобы переосмыслить и скорректировать некоторые свои представления о программировании, программистах и себе. Да и, кроме откуда-то взявшейся заносчивости, неработающих примеров (не протестил — не деплой, ага), я совершенно не выразил того, что изначально хотел: главное — это умение писать код, решающий задачу.
За прошедшее время обязанность участвовать в технических собеседованиях разработчиков от меня никуда не делась. Формат собеседования остался прежним: это работа с кодом в онлайн-блокноте, но задач осталось всего две и они стали намного проще.
Вот пример одной из них:
```
/* Простое число — целое положительное число, имеющее только два делителя: 1 и само себя */
function isPrimeNumber(number) {
/* необходимо реализовать функцию, возвращающую true в случае, если number является простым числом и false в противном случае */
}
```
Вынесенный в заголовок этой статьи вопрос отнюдь не риторический и обязан своим появлением страстям, которые крутятся вокруг этой задачи на собеседованиях.
Немного вводных данных: мы ищем фуллстеков, пишущих на JavaScript/TypeScript. Спектр задач, в зависимости от пожеланий самого разработчика, может быть очень широким: от разработки биллинговой системы, до десктоп-приложения для рисования на скриншотах и загрузки в облако. Соответственно, базовые знания математики (плюс-минус, разделить-умножить, найти среднее арифметическое, максимум-минимум в ряде) нужны, равно как и умение решать прикладные задачи, решения которых может и не быть на stackoverflow. По резюме мы отбираем кандидатов уровня не ниже middle, с соответствующим опытом работы. Разработка — совсем не профильный вид деятельности компании, поэтому нам трудно привлечь мощных разрабов и таких кандидатов очень мало.
Задача, подобная этой, должна была стать примитивным фильтром, показывающим, что собеседник умеет создавать алгоритмы. Знание каких-либо конкретных алгоритмов не требуется. Вычислительная сложность решения не особо важна, главное — задачу нужно решить.
Помню как я первый раз удивился, когда парень с трёхлетним опытом работы в крупных проектах, сказал что для решения этой задачи нужен какой-то «алгоритмист». И он объяснил почему: у него опыт разработки сервисов, где, в основном, работаешь с данными из базы, очередями — получаешь/передаёшь, вот это вот всё. Тогда я и задумался, что современное программирование — это, наверное, больше про опыт работы с RabbitMQ, MongoDB, чем про вычисление/нахождение чего-то.
Часто кандидаты говорят «я не математик», «у меня с математикой не очень». Первое время я терялся и не знал что ответить, потому что я не вижу тут математики, это задача на поиск. Да и трудно ожидать таких слов от программиста, метящего на зарплату в тысячи долларов. Теперь-то я предлагаю кандидатам поразмышлять: «поскольку любое положительное целое число делится без остатка на единицу и само себя, достаточно найти хотя бы ещё одно число, на которое аргумент можно поделить нацело и вернуть false, а если не нашли, то вернуть true». Но и это не всегда помогает.
Понимаю, что в это может быть трудно поверить, но я хочу сказать, что написанное мной правда и представляет в моей работе определённую проблему. Добавлю, что такие случаи актуальны для программистов с небольшим опытом работы (до пяти лет). Я предполагаю, что этому есть несколько причин:
#### 1. Клиповое мышление
Современное клиповое мышление как-то отразилось на программировании и новоиспечённым разработчикам проще (а может и интереснее) искать решения даже простейших задач на stackoverflow, из-за чего способность «придумывать» алгоритм для решения задачи не прокачивается даже с годами.
Не знаю как происходит процесс программирования у других, может, теперь действительно принято обращаться к stackoverflow не тогда, когда ты не можешь что-то решить, а сразу же, без самой попытки решения? Ни в коем случае не говорю, что это плохой подход, вероятно даже хороший: за счёт такой мемоизации решений, в перспективе, можно создать ИИ, который по ответам на stackoverflow будет кодить без участия человека.
#### 2. Простота и массовость языка
Я уверен, что если бы мы искали Си-разработчика, то такой проблемы не было бы. Но случая проверить эту гипотезу пока не представилось.
Тренд «войти в айти», куча онлайн школ с программами аля «Интенсив по Python», «Стань React-разработчиком за месяц» породили массу людей, которых в программировании изначально привлекала оплата (возможно, только она) труда. Но и эти разработчики очень востребованы. Например, фронтендеров появляется сейчас очень много, но их всё равно не хватает: без работы не останется никто, главное уметь в React. Нужны ли тут алгоритмы? Я скажу «да, конечно», и, вероятно, ошибусь.
Раньше программирование изучали из любопытства и за годы до того, как оно начинало приносить программисту деньги. Многие так и не начали этим зарабатывать, программируя для себя, но работая по смежным специальностям. А теперь программированию учат с гарантией трудоустройства и пост-оплатой за курсы с первой зарплаты. И я только за, как человек заинтересованный в полной комплектации команды, в которой я работаю.
Но, как программист, я не понимаю, почему задача из школьного курса информатики способна вызвать затруднения у дипломированных профессионалов.
Возможно, в наших требованиях к кандидату что-то не то. Может, нам действительно не нужно, чтобы разработчик умел придумывать решение задачи, и такое требование — это старпёрство. Мне уже начинает так казаться.
Я работаю в одном помещении с инженерами, занимающимися интеграцией, поддержкой облачной инфраструктуры. Сегодня я пожаловался коллегам на эту проблему и они тоже удивились. Удивились и сказали как бы они решили эту задачу, причём разговор сразу пошёл про оптимизацию вычислений. Это не профессиональные программисты, возможно, последний раз они прогали что-то ещё в институте, но они умеют составлять алгоритмы для решения задачи. | https://habr.com/ru/post/490358/ | null | ru | null |
# Интернет-радио «Моминьмай»: будем знакомы
### Здравствуй, Хабр!
Это моя первая статья здесь и сегодня я хочу рассказать о нашем необычном интернет-радио.
В этой статье будет ретроспектива, нынешнее состояние, планы на будущее. Немного философии по теме. Также коснусь технических деталей и приглашу к обсуждению.
Как мы размещаемся на "сервере" с 32 Мб оперативной памяти? Как мы выросли из пет-проекта одного человека до команды профессионалов, работающих на энтузиазме? Зачем и кому это вообще нужно?
### Знакомство и ретроспектива
Позвольте представиться: меня зовут Артур, я программист и музыкант, основатель и исполнительный директор [интернет-радио "Моминьмай"](https://momingmy.tk).
Именно сегодня нашему радио исполняется 9 лет. Точную дату запуска установить вряд ли возможно, но мы условились считать таковой дату первого упоминания радио в [посте](https://juick.com/nibb13/2175829) моего микро-блога.
Я родился в семье кинооператора и моё детство прошло на донецкой студии телевидения. Там я на всю жизнь впечатлился эфирными медиа и усвоил принципы их создания. Редакции, пультовые, съёмочные павильоны, передвижные теле-студии — всё это было моим "вторым домом". И, хоть я выбрал позже путь программиста, любовь к эфирному медиа превратилась в хобби на грани IT и искусства.
Ещё на рубеже 1990-х — 2000-х в городской "локалке" ( г. Евпатория ) я держал своё первое радио. Эфир состоял то из музыки с моего жёсткого диска, то из коротких дайджестов городских новостей, то просто из ретрансляции FM-радиостанций. Всё это в программном плане осуществлялось связкой WinAMP + Shoutcast. В аппаратном - мой домашний компьютер + офисный микрофон + дешёвый китайский радио-приёмник, подключенный 3.5-"джеком" в line-in аудиокарты. Радио пользовалось местной популярностью: мне присылали композиции для дополнения плейлиста, просили передать приветы друзьям по "локалке" и уделяли особое внимание на общих офф-лайновых сборах. Я тогда казался обществу каким-то волшебником, а всего-то чуть больше остальных понимал как это работает и делился результатами собственных экспериментов.
Таким я был в далёком 2002-м годуВ середине 2000-х я вернулся в Донецк чтобы учиться и впоследствии работать. В то время я продолжал интересоваться музыкой и историей развития эфирных медиа. И в 2012-м произошли два ключевых события, благодаря которым появилось радио "Моминьмай".
Первое из них — приобретение роутера D-Link DIR-620. На нём обнаружился один USB-порт, который предназначался в первую очередь для подключения 3G-модемов в качестве резервного канала. Но он же на родной прошивке позволял монтировать USB-накопители, причём даже с ext-файловыми системами. Telnet-доступ к роутеру так же существовал. После недолгого изучения доступных инструментов в прошивке на базе Linux я понял, что роутер вполне можно использовать как микро-веб-сервер. "Флэшки" на 512 Мб хватало для размещения с лихвой. Толку от такого "сервера" было немного. И так бы оно и осталось в виде эксперимента без особых выводов, если бы не второе событие.
Вторым оказался просмотр фильма "Рок-волна" ( "Boat that Rocked" ) На тот момент я знал многое о "[пиратских радиостанциях](https://ru.wikipedia.org/wiki/%D0%9F%D0%B8%D1%80%D0%B0%D1%82%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B0%D0%B4%D0%B8%D0%BE%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D1%8F)" и, в частности, о "[Радио Кэролайн](https://ru.wikipedia.org/wiki/Radio_Caroline)" Но, одно дело — читать ретроспективу, а совсем другое — проникнуться "вау-эффектом" от замечательного фильма. Тут-то в голове и щёлкнула мысль: *«А смогу ли я запустить интернет-радио на свободных ресурсах роутера?»* Пара вечеров вдумчивого чтения документации, неделя оптимизации кода под конкретные условия — и, вот: для роутера собраны icecast2 и ices, которые сносно отдают OGG-поток в сеть. Роутер, тем временем, продолжал исполнять свои основные обязанности — раздавал Интернет по квартире.
Так выглядел наш первый сервер в 2012-мИменно тогда и появилось радио "Моминьмай". Эфир состоял из относительно небольшого плейлиста, лежащего на той же "флэшке". Музыка воспроизводилась "24 / 7" и отбиралась в ротацию по принципу "что нам самим хотелось бы слушать". На тот момент моими единомышленниками и первыми же слушателями были моя супруга Наталья и мой друг Валентин ( привет, [@Evolik](https://habr.com/ru/users/Evolik/) ! ) Ни о какой аудитории мы поначалу не задумывались, делали "для себя" и "экспериментов ради".
Эксперименты заключались не только в формировании плейлиста, но и в техническом плане. На роутере было всего 32 Мб оперативной памяти и не слишком производительный процессор. При кросс-компиляции для него приходилось учитывать различные оптимизации, а весь бэкенд писался на shell-script. Да, на том, который `!#/bin/sh` (точнее — ash в busybox), а не на bash. Последний, как оказалось, был несколько тяжеловесен в плане памяти и процессора, когда речь заходит о сильно ограниченных ресурсах. Обо всех технических тонкостях, которые только смогу вспомнить, я обязательно расскажу в следующих статьях.
Для удобства я со временем зарегистрировал бесплатный домен от Freenom ( тогда ещё Dot-Tk ) и, спустя примерно год, обнаружил что радио вдруг стали слушать по всему миру. Мне писали из Калифорнии: *«Чувак, я слушаю твоё радио утром в душе и в машине по дороге на работу! Круто! Вот тебе моя подборка — закинь в эфир если нравится.»* Писали из Италии: *Если тебе будет нужно "зеркало" — пиши, у меня есть свободные ресурсы.»* А из Германии слушатель вообще прислал мне небольшой donation биткоином в размере $2.42 по курсу на тот момент ( в феврале 2021-го я его обналичил в $270 ) Радио неожиданно стало чем-то бóльшим, чем просто "пет-проект для своих". Мне нечаянно удалось повторить свою "локалку", но теперь ей был весь мир.
Я стал чувствовать ответственность за работоспособность радио перед слушателями. При отвале канала меня среди ночи будила моя самописная система, а я будил техподдержку провайдера, если была на то необходимость. Пивом на сисопках компенсировал, конечно. В 2013-м году лютая гроза не пощадила роутер. Будучи временно безработным, я потратил последние деньги на покупку такой же модели и возобновил вещание меньше чем за сутки. В общем, я стал владельцем и, в некотором роде, рабом собственного радио.
Мы тогда начали задумываться о прямых студийных эфирах, но нехватка времени и последовавшие известные события на Донбассе не дали тогда этим планам сбыться. В конце 2014-го радио было упаковано в сумку рядом с ноутбуком и переехало из Донецка в Одессу.
512-ти мегабайтная "флэшка" сменилась на 16-ти гигабайтную. Количество музыки в ротации достигло почти пяти суток. А я, как музыкант, познакомился в Одессе с клубом "Выход", в котором проводились еженедельные блюз-фанковые джемы. После недолгих экспериментов я предложил клубу в качестве личной инициативы вести прямые трансляции джемов на моём радио. Забирал звук с аналогового пульта, цифровал на ноутбуке клуба и слал потоком к себе домой, на роутер. Так на радио появились первые прямые эфиры, пока ещё "as-is", без ведущих.
Сервер радио сейчас (флэшка переходная только, 8 Гб)В истории радио "Моминьмай" было ещё немало интересных случаев. Изо всех сил стараюсь не утомлять в первой статье, поэтому расскажу о них в следующих. А пока переходим к настоящему времени.
### Нынешнее на нашем радио
И опять "лирическое отступление", уж простите. В 2018-м я познакомился с Татьяной Волошиной. Татьяна — председатель неприбыльной организации "Одесское Городское Общество Защиты и Охраны Животных", наш "Биг Босс". У организации есть арендованный офис в центре Одессы и совершенно нет ресурсов для его содержания и развития. Татьяна, зная о моих связях с культурной сценой Одессы, попросила меня организовать культурное пространство на базе офиса организации. Довольно скоро офис стал полу-подпольным ( в т.ч. буквально: мы находимся в полу-подвале ) музыкально-поэтическим клубом под названием "Рога и Копыта". А многие музыканты, поэты и художники Одессы стали волонтёрами общества. И "волонтёр", в этом случае, не только тот, кто занимается проблемами животных непосредственно, а и тот, кто помогает в обустройстве офиса-пространства и популяризации зоозащитного движения с помощью своего искусства в окружающем социуме. Мы организовывали музыкальные джемы и благотворительные концерты. Вокруг "общества" начала создаваться культурная среда. А в перерывах клали плитку в офисе и крутили сантехнику.
Наша импровизированная студияНаш коллега и единомышленник из Латвии, Нико, летом 2020-го вдруг предложил мне провести прямой эфир на моём радио и выступить в роли ведущего. Я начал своё обычное: *"Ну-у, давай через пару дней попробуем..."*, на что получил резкое: *"А почему не сейчас? Сколько тебе надо времени на подготовку?"* Я сказал, что справлюсь за час. *"Окей, ты ж с оборудованием мобильный, через час встречаемся на углу Дерибасовской и Екатерининской, оттуда ведём эфир"* — ответил Нико.
Честно говоря, мне было страшно. Справимся ли? Не подведёт ли оборудование? Все опасения оказались зря: оснастка была "на высоте", а Нико показал себя отличным ведущим. Так появилась первая полноценная прямая передача на радио "Моминьмай" под названием "Эй, ты, подошёл!.." В эфире были байки от ведущих, живая музыка под акустическую гитару и саксофон, интервью с проходящими мимо одесситами и гостями города. Даже внезапные танцы от трёх пар профессионалов под наш разбитной рок-н-ролл! Наконец-то я ощутил, что моя мечта о создании прямых эфиров стала реальностью. И обрёл новых единомышленников, которые "загорелись" идеей радио.
Эфир на Дерибасовской / Екатериниской, ОдессаПередача "Эй, ты, подошёл!.." просуществовала недолго. Но в 2021-м мы вернулись к прямым эфирам уже с опытом и уверенностью. Сейчас мы ведём передачу "Чёрная Кошка" раз в две недели по пятницам. В прямом эфире мы с гостями обсуждаем вопросы зоозащиты и экосистем, делая перерывы на живую музыку от одесских коллективов и исполнителей, приходящих в нашу "студию" на основе офиса организации.
В гостях у нас были замечательные зоозащитники Одессы, эксперт-криминалист Павел Плевинскис и даже знаменитый директор одесского зоопарка Игорь Беляков, который исполнил в прямом эфире песню собственного сочинения.
Типичный эфир передачи "Чёрная Кошка", в гостях Игорь Беляков (справа на фото)К нам со временем присоединились профессионалы своего дела — ведущие: Дмитрий Адамовский ( журналист, репортёр ), Андрей Мельник ( поэт, музыкант ), Марк Пан ( актёр театра ) Видеооператор и специалист по видеомонтажу — Ольга Махонько. Стажёр инженерно-технической части — Никита Трач. И музыканты Одессы, которые играют в прямых эфирах.
Люди, работающие на радио сейчас — энтузиасты. Мы не получаем зарплат и не монетизируем вещание напрямую. Всё, что у нас есть — собственное оборудование, которое сотрудники принесли на радио во временное пользование и немногочисленные донейты, которых едва хватает на сопутствующие накладные расходы. Ну и вложение собственных умений сотрудников, разумеется. Главное — нам всем это нравится: и тем кто делает, и нашим слушателям.
Стажёр внимательно стажируетсяУ такого "аскетичного" подхода есть как плюсы, так и минусы. Плюсами можно считать независимость ( от инвесторов, к примеру ) и низкие финансовые риски. А также некоторую экологичность подхода: мы используем ровно столько ресурсов, сколько действительно нужно. Минусы — сложность в разработке и сопровождении, технические ограничения в отдельных случаях.
Нам придётся расширяться. Уже запланированы другие интересные передачи, а это потребует более напряжённой сетки вещания и расширения штата. Привлечение редакторов и ведущих, дизайнеров, специалистов по ведению аккаунтов в социальных сетях и т.д. Нужно будет обновить парк техники. Ну, хотя бы заменить роутер на какой-нибудь микро-компьютер вроде пресловутой "малинки". Её, я уверен, нам хватит надолго.
Сейчас мы готовим краудфандинговую программу и пробуем подавать заявки на гранты по поддержке гражданских инициатив. Но мы определённо сохраним направленность на минимизацию необходимых ресурсов.
Я, образца 2021-го года### Некоторые технические детали
Основной и единственный сервер — роутер D-Link DIR-620 на относительно медленном канале в 100 мегабит. Поток — OGG/Vorbis, 127 Kbps.
Использование штатной прошивки не необходимость, а, скорее, "хакерская" лихость. Мне просто было интересно как далеко можно зайти с такими ограничениями. На каком-нибудь OpenWRT не так интересно.
Стабильность дополнительно обеспечивается CDN Cloudflare и сервисом ретрансляции интернет-радио [Zeno.fm](http://Zeno.fm)
Владимир экстренно приводит в порядок оборудование за 10 минут до эфираВ качестве студийного оборудования используются: пульт "Alesis MultiMix 8 FireWire", звуковая карта "Lexicon Alpha Studio", нетбук-трансформер "Asus TX201LA", различные электретные и динамические микрофоны.
Программное обеспечение: icecast2, ices, lighttpd, ffmpeg, OBS Studio, бэкенд на shell-script.
Немногочисленные данные хранятся просто в текстовых файлах. Какие-нибудь выборки на самом роутере не нужны, поэтому никаких движков баз данных мы не используем. Очень забавно при этом наблюдать в логах попытки просунуть SQL-иньекцию.
### И ещё общей философии о радио
Мне часто задают вопросы о выборе именно такого формата вещания. Опишу своё видение на их основе и моих ответах. Я, разумеется, могу оказаться неправ и буду рад, если вы поправите меня в комментариях.
Радио-формат справедливо противопоставляется телевизионному. В случае с радио задействуется лишь звуковое восприятие, а телевидение требует визуального в том числе. При этом любое активное восприятие требует внимания от слушателя / зрителя. Внимание — ресурс ограниченный. В случае восприятия информации в аудиовизуальной форме, внимание будет неизбежно "размываться" между конкурирующими потоками. "Видео без звука" осталось в эре "немого кино" ( да и то в кинозале всегда играл музыку тапёр ) А, вот, "звук без видео" отлично существует до сих пор, как минимум, в форме подкастов и музыки.
Вдобавок я заметил и за собой и за друзьями тенденцию запускать студийные видео-эфиры на YouTube в фоновой вкладке и слушать только звук. Максимизируя: YouTube за рулём авто не посмотришь, а послушать что-то — вполне возможно.
А ещё для видео-стрима нужно не только хорошо звучать в студии, но и "выглядеть". Это требует хорошего света и оптики. И не каждый гость студии чувствует себя уютно при направленном на него объективе. Даже бывалые ведущие радио-эфиров со сценическим опытом несколько тушуются в таких ситуациях.
Собакена устраивает и слушать и выглядетьНу и банальный технический вопрос: для аудио-трансляции хватает минимального оборудования и канала. А для видео обязательно потребуется обращаться ко крупным площадкам, что исключает независимость вещания. Известных случаев проблем с тем же YouTube достаточно. Да и я сам попадал под автоматический бан всего аккаунта без каких-либо нарушений с моей стороны. UPD: совсем недавно поймал "страйк" по совершенно не связанной с опубликованным видео причиной. Апелляция, впрочем, быстро помогла.
Как итог, мы сознательно отказались от видео-вещания и даже от ретрансляции радио через крупные сервисы. При этом во время передач ведётся фото-видео съёмка с моментальной публикацией в телеграм-канал радио удачных моментов. И выкладыванием на YouTube-канал отредактированного материала.
Теперь по поводу *"Почему всё-таки прямые эфиры, а не запись подкастов?"* Я считаю, что "золотой век" радио пришёлся на 60-е — 70-е годы прошлого века. Примерно в то время радиостанции перешли от дикторских новостей и радиоспектаклей в более "живую", интерактивную форму. Появились радиоведущие, гости эфиров и звонки в студию от слушателей. Как выяснилось, каждый хочет стать "звездой". Или побыть. Пусть даже в эфире небольшой локальной радиостанции. Подкасты менее интерактивны: можно, в лучшем случае, обсудить произошедшее в комментариях и попросить раскрыть тему в следующем эфире. А особая "магия" происходящего "здесь и сейчас" слушателю интересней.
Мы до сих пор не сделали возможность полноценно принимать звонки в прямой эфир, но уже близки к этому технически и это обязательно будет. И записи эфиров уже [выкладываются в виде подкастов](https://podcasts.google.com/feed/aHR0cHM6Ly9wb2RjYXN0Lnplbm9tZWRpYS5jb20vYXBpL3B1YmxpYy9wb2RjYXN0cy9hZ3h6Zm5wbGJtOHRjM1JoZEhOeUt3c1NDa0YxZEdoRmJuUnBkSGtZZ0lDUXlOYUt4UXNNQ3hJSFVHOWtZMkZ6ZEJpQWdMRF9sTERnQ0F5aUFRZHNhV0p5WVhKNS9yc3M) для тех, кто не успел послушать нас вживую.
Другой, часто задаваемый вопрос: *"Почему интернет-радио, а не частотное?"* У интернет-радио есть очевидные плюсы: "дальность" вещания определяется наличием доступа в Интернет у слушателя. Мы действительно вещаем на весь мир и не несём каких-либо дополнительных трат на это. Несмотря на то, что наши прямые эфиры русскоязычные, география прослушиваний действительно впечатляющая. Всё просто — русскоязычные диаспоры существуют почти в каждой стране.
Нико берёт интервью у мимо проходивших гостей городаВ дополнение, получение лицензии на частотное радиовещание — это дорого для нас и налагает немаленькие обязательства. А мы позиционируем себя как независимое радио, помните?
В процессе мы немного похулиганили в разрешённом гражданском диапазоне частот, но лишь эксперимента и искусства ради. Быстро перестали, никого не разозлив. Всё ж радиолюбителей уважаем и больше так делать не будем.
### Планы на будущее
Будущее всегда туманно. Планировать всегда тяжело. Но общая тенденция и желаемое направление у нас есть. Мы хотим стать по-настоящему независимым и интересным для слушателей радио. В ближайших планах повышение популярности и интерактивности. Улучшение качества звука ( этот процесс бесконечный ) и расширение сетки вещания за счёт увеличения количества передач и рубрик в них. Взаимная реклама одесских ( и не только ) музыкальных коллективов и нас. Продуктивное общение с IT-сообществом. И всё прочее, что только придёт нам в головы и что вы нам сможете посоветовать.
Наша "пиратская шхуна" расправила паруса и продолжает идти полным ходом по интернет-радио-волнам. Добро пожаловать на борт!
Эй, там, на палубе!..### Позиция о пиратстве
Лично я и наш коллектив не считаем пиратство чем-то категорически плохим. Как музыкант и разработчик коммерческого ПО, я всегда искренне рад, если продукты моего труда распространяются на любых условиях. "Упущенную выгоду" не приемлю для себя и очень прохладно отношусь к ней в упоминаниях других.
Да, мы "крутим" в эфире много треков, на воспроизведение которых у нас нет прав. Но, во-первых, мы не получаем от этого прямой финансовой выгоды. А, во-вторых, благодаря этому мы создаём и свободно распространяем своё творчество.
Мы — пираты, но мы — честные пираты. Знаю, что это тема для возникновения порой острых и довольно паритетных дискуссий, но с радостью раскрою её в комментариях, если у кого-то возникнет желание.
I mean it!### Одесситам Хабра
Я знаю, вас много! Мы будем искренне рады видеть вас у нас в гостях. С удовольствием обсужу IT-шные, и не только, вопросы. Расскажу интересные байки за кружкой чая, или ещё чего. Пишите в комментариях или в личные сообщения.
Конечно же, гостей города будем тоже рады у нас видеть!
### Большое спасибо
Хочу лично поблагодарить [@RusakovMxL](https://habr.com/ru/users/RusakovMxL/) за совершенно неожиданное приглашение в полноправные пользователи Хабра. В частности оно меня сподвигло на написание первой статьи. Я очень ценю этот аванс и изо всех сил постараюсь оправдать доверие.
А также [@Exosphere](https://habr.com/ru/users/Exosphere/) за оперативную и замечательную рецензию черновика статьи. | https://habr.com/ru/post/597729/ | null | ru | null |
# Не нужно обижать «матрас»
Желаю доброго дня уважаемому Хабра-сообществу. Данная заметка навеяна [постом](http://habrahabr.ru/post/143512/) о правильной настройке телевизора. Я не лелею больших надежд на то, что внезапно начнется «неделя настройки телевизоров на Хабре», но поделиться некоторыми мыслями захотелось.
Обращаю ваше внимание на тот факт, что автор не является профессионалом в области ремонта/настройки телевизионных приемников, мониторов и другого проекционного оборудования, а все изложенные мысли лишь теоретические выкладки, с которыми более опытные товарищи могут легко не согласиться и отразить свое негодование в комментариях. За что, кстати, я буду весьма благодарен, ибо это может серьезно расширить мой кругозор.
##### Ближе к делу
Картинку, приведенную мной в начале поста, опытные и не очень телевизионщики называют матрасом. Название, несомненно, более удобное, чем «настроечный телевизионный сигнал», хотя и немного обидное. Ну да Бог с ним с названием, народная мудрость — она безгранична, раз уж матрас, значит спорить бесполезно.
Вертикальные полосы используются для настройки довольно часто, но большинство людей, находящихся «не в теме», с трудом представляют себе, что же полезного можно выжать из этой тривиальной картинки, а главное почему какие-то там изобретатели не догадались хотя бы расположить эти полосочки «по порядку», как в радуге, например.
Отвечу, радуга — это хорошо, но для настройки бесполезно! Матрас — это универсальный и простой способ настроить как цветной, так и черно-белый телевизор, именно этот факт делает его безумно, фантастически кошерным, халяльным и православным одновременно *(для атеистически настроенных граждан приведу другие синонимы: академический, правильный, незаменимый)*.
##### Немного теории
Все изложенное в этом разделе является результатом реверс-инжиниринга, если можно так выразиться в данной ситуации. Мое знакомство с матрасом было весьма интересным и поучительным, спешу поделиться с сообществом результатами своих исследований.
В те времена, когда интернет мне доставался только по выходным дням или неожиданным всплескам хорошего настроения у начальства, когда приходилось сохранять огромные кучи полезной и не очень информации, а потом разгребать все это долгими вечерами и строго в нерабочее время, когда я не мог спросить у гугла каждую мелочь, именно тогда инженерный склад ума и соответствующее образование, дали первые всходы в виде понимания ДАО Матраса.
Первая мысль, которая дала направление для исследований, содержала одну простую истину — полоски показывают по телевизору для всех одинаковые, а телевизоры у всех разные *(у меня в то время, все еще в рабочем состоянии, был телевизор Славутич-220, а он был, как известно, черно-белым)*. Значит в расположении цветов кроется какая-то тайна, загадка древних, наследие мудрых, ну и все такое в том же духе.
Итак свет который мы видим имеет некоторые базовые характеристики, до которых можно легко додуматься самостоятельно, а можно и с помощью литературы. Источником света для нас являются *(в контексте статьи)* экран телевизора/монитора или отраженные лучи проектора. Что же мы видим? Как мы видим? Вот вопросы на которые следовало ответить до того, как продолжить свой путь.
Человеческий глаз отдельно друг от друга распознает яркость светового пучка и его тон. Это научный факт и с ним я спорить не стал, а просто вооружился ним и пошел на штурм матраса.
Народная мудрость гласит: «Ночью все кошки серые». Согласен, а также требует уточнения то, что они не одинаково серые. Если смотреть черно-белый телевизор или просто выбраться ночью на улицу, то станет ясно, что цвет предметов пропадает, а в замен мы получаем градации серого.
Яркость *(или [светлота](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D0%B5%D1%82%D0%BB%D0%BE%D1%82%D0%B0_%28%D1%86%D0%B2%D0%B5%D1%82%29), если верить википедии)*, один из элементов, который приоткрывает дверцу, ведущую к пониманию сути матраса.
Прошу прощения у читателей, которые могут слегка оскорбиться таким разжевыванием прописных истин, но я это делаю не из природной вредности или желания обидеть кого-либо, а просто излагаю то как я доходил до тех или иных выводов.
Решая загадку матраса, я был в слегка неудобном положении, ибо не помнил чарующую последовательность его цветных полос, а решить хотелось «здесь и сейчас», «не отходя от кассы», ну или как-то менее пафосно, но пренепременно и сиюминутно.
Сначала пришлось определиться с количеством этих самых цветов. Как известно у человеческого глаза к разным частям спектра разная чувствительность *([метамерия](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%D0%BC%D0%B5%D1%80%D0%B8%D1%8F_%28%D1%86%D0%B2%D0%B5%D1%82%29))*, а также некоторые цвета при смешивании образуют новые, невиданные доселе оттенки. Вот и путеводная нить, радовался я, гордясь тем, что совсем недавно читал где-то о таких страшных для простого обывателя словах, как аддитивный и субтрактивный.
Проверим догадку, подумалось мне тогда и я выписал на бумажку, знакомые каждому с детства и несказанно любимые три цвета: красный, зеленый и синий. Потом я немного подумал и добавил к списку белый, как сумму трех предыдущих, а то что это именно сумма я не сомневался абсолютно, что тут же продемонстрировал, подкрепив шестнадцатиричными кодами все перечисленные цвета *(#ff0000, #00ff00, #0000ff, #ffffff)*. О цифры, сколько в вас Божественной красоты.
Далее необходимо было прикоснуться к таинству инверсии и получить еще четыре цвета. Не мудрствуя лукаво, я вывел бирюзовый *(#00ffff)*, пунцовый *(#ff00ff)*, желтый *(#ffff00)* и черный *(#000000)*. А что, раз есть основные цвета, почему не быть в списке и их антиподам? Я был весьма и весьма удовлетворен своей находчивостью, ибо таблица моя разрослась до восьми элементов и теперь, по моему субъективному мнению, была, вроде бы, заполнена полностью, ну, по крайней мере, количественно.
Далее, возвращаясь к первой мысли, я думал, а что же делать с порядком этих самых цветов?
Яркость решила все за меня, «сложим два и два»: набор цветов есть, универсальность таблицы есть, что в результате — конечно же сортировка по яркости. Именно в этом случае одна таблица сможет помочь в настройке, как цветного, так и черно-белого оборудования.
Яркость, зараза ты эдакая, ну ладно, в целом направление мысли мне тогда показалось безукоризненным и я приступил к расчетам *(на бумажке, естественно)*.
Мало того, что я знал страшные слова описывающие цветовые модели, умел пользоваться шестнадцатиричным счислением и математикой, я знал еще и три магические цифры, способные помочь мне в долгом и тернистом пути познания матраса. Пусть каждый помнит и чтит этих трех китов всех цветовых манипуляций — 0.30, 0.59, 0.11.
На самом деле все очень и очень просто. Эта троица представляет собой чувствительность нашего парного органа зрения к некоторым частям видимого спектра, а конкретно, к красной, зеленой и синей составляющей. В сумме эти три числа дают единицу, или 100%, если вам так удобнее.
Собрав воедино все накопленные данные, я был близок к финалу, как мне тогда показалось.
А сейчас, одним росчерком пера, я сокращу количество читателей вдвое:
**L = 0.30 · R + 0.59 · G + 0.11 · B**
Вот она, вот она формула моей мечты, иначе и не скажешь. Дальше все пошло самотеком. Не трудно было вычислить все показатели яркости для восьми цветов, именно таким способом цвета преобразуются к шкале серого, это придавало мне сил и уверенности в том, что путь мой верен. Сортировка заняла совсем немного времени и вот перед моими глазами *(в виде простенькой таблицы, наскоро сверстанной в простом HTML-файле)* предстал он — его величество Матрас.
Белый *(white)* – 255
Желтый *(yellow)* – 227
Бирюзовый *(cyan)* – 179
Зеленый *(green)* – 151
Пурпурный *(magenta)* – 104
Красный *(red)* – 76
Синий *(blue)* – 28
Черный *(black)* – 0
Мозг подсказывал, что все верно, именно такая картинка хранилась где-то в его глубинах и теперь при сопоставлении их он уверенно выдавал «Successfully complete», но для уверенности я, все же, разделил таблицу пополам и дополнил ее оттенками серого, для всех имеющихся цветов. Результат превзошел все ожидания, по яркости эти половинки мне показались весьма и весьма схожими. Любой, читающий эти строки, несомненно подумает: «А зачем текст продолжается дальше?».
А дальше мне нужно было дойти до методики настройки аппаратуры при помощи всего одной таблицы.
##### Немного практики
Один профессор нашей кафедры говорил, а я запомнил, прекрасную фразу: «Понимание выше запоминания». Именно это и двигало мной, ведь самостоятельно получив таблицу цветов и имея достаточную базу для маневров, я постиг ДЗЕН Матраса. Я не рассматриваю возможности преподавания дидактики матраса в высшей школе, но настаиваю на том, что бы каждый читатель, из оставшихся до сих строк, мог уметь воспользоваться таким простым и, как и все простое, гениальным средством для настройки/калибровки цветов выводящих устройств.
Собственно все очевидно. Для настройки нам нужно сначала убрать насыщение цветов, т. е. заставить оборудование вывести картинку в шкале серого – это даст нам возможность отрегулировать яркость и контраст. Все что нужно – добиться четкой различимости выведенных полос. Потом нужно добавить цветности и получить субъективно четкую картинку основных цветов, насколько это позволит ваш наметанный глаз.
Настроив нормальное отображение базовых оттенков мы сможем гарантировать, что и все остальные тона и полутона отобразятся устройством достаточно точно, ну или приемлемо для нас. Вот такая простая методика, выведенная по результатам недолгих, но продуктивных исследований.
##### Немного общих фраз
Простите великодушно за излишнее словоблудие, считаю, что даже около-научная статья, все же должна содержать немного эмоциональной составляющей, так она способна вызвать больший отклик в душах и умах людей.
##### PS
С помощью выведенной методики смог настроить картинку в телевизоре *(теперь уже цветном)* до приемлемого уровня, нормально настроил проектор на работе, в общем стал применять налево и направо. Чего и вам желаю.
---
###### Update
Учитывая комментарии сообщества, сделаю краткий конспект заметки в более сжатом виде.
###### Суть настроечной таблицы
* Матрас содержит 8 цветных полос *(три основных + белый, инверсии четырех предыдущих)*, расположенных в строгом и продуманном порядке.
* Порядок полос определен яркостью используемых цветов *(градация от наиболее яркого к наименее)*.
* Следуя логике хаба «Сделай сам», рассмотрим варианты получения настроечной таблицы:
+ Создать самостоятельно при помощи любого графического редактора или сверстать простенький HTML-документ.
`Коды цветных полос в правильном порядке:
#FFF, #FF0, #0FF, #0F0, #F0F, #F00, #00F, #000`
+ Собрать генератор цветных полос «в железе» *(методика в схематичном виде [отлично](http://habrahabr.ru/post/143854/#comment_4824943) продемонстрирована пользователем [AndreyNagih](https://habr.com/ru/users/andreynagih/), за что ему огромное спасибо)*
###### Использование
* При помощи доступных настроек оборудования убрать насыщение цвета. Данный шаг покажет матрас в градациях серого. Настроить яркость и контраст таким образом, чтобы четко различать все градации.
* Добавить насыщение и добиться нормального *(определяется индивидуальными особенностями зрения и оборудования)* отображения основных цветов.
###### PPS
Большое спасибо за добрые слова. Я совершенно не ожидал, что данная заметка займет место в избранном у такого большого количества пользователей. | https://habr.com/ru/post/143854/ | null | ru | null |
# Про бэкапы, черную пятницу и коммуникации между людьми: как мы накосячили и научились больше так не делать
13 октября мы провели вторую конференцию сообщества [Uptime](http://uptime.community). В этот раз дата проведения выпала на пятницу 13-е, поэтому основная тема — аварии, и как с ними справляться. Это первый из серии постов про доклады с прошедшей конференции.
У меня есть три страшные истории о том, как по нашей вине все сломалось, как мы это чинили, и что мы делаем теперь, чтобы это не повторилось.
Масштаб: количество алертов
===========================
Мы работаем с 2008 года, нас сейчас 75 человек (Иркутск, Питер, Москва), мы занимаемся круглосуточной технической поддержкой, системным администрированием и девопсом для веб сайтов по всему миру. У нас 300 клиентов и 2000 серверов на поддержке.
Основная наша работа заключается в том, что если происходит какая-то проблема, мы должны за 15 минут прийти и исправить ее.
В 2010 году было порядка 450 алертов в месяц в пике.
Эта маленькая красная линия — это то, сколько алертов у нас было до конца 2012 года.
В 2015 году — в пике доходило до 100 000 алертов в месяц.
Сейчас их приблизительно 130 000 — 140 000.
На наших дежурных приходит около 400 алертов в час. То есть 400 сообщений от системы мониторинга, которые нужно расследовать. Это может быть что-то довольно простое: к примеру, заканчивается место на диске; а может быть что-то сложное: все упало и ничего не работает, и нужно понять, что вообще случилось.
В «черную пятницу» у нас доходит до 900 алертов в час, хотя интернет магазины готовятся к этому событию и предупреждают администраторов. Три года назад «черная пятница» проходила в пятницу. Два года назад магазины решили обхитрить друг друга и сделали «черную пятницу» в четверг, все вместе. В прошлом году это была среда, очевидно, что эта «черная пятница» будет во вторник и, в конечном счете, все пройдет по кругу. Магазины не любят говорить, когда именно это произойдет, поэтому хорошие магазины готовятся к нагрузочному тестированию, а другие хорошие магазины не говорят об этом вообще, а после приходят и говорят: «Здравствуйте, мы только что сделали рассылку на 300 000 человек, пожалуйста, подготовьте сервер к нагрузке».
Если готовить сервер к нагрузке второпях, то возникает куча проблем. Уметь быстро соображать в таких условиях — особое умение. Обычно люди хотят работать по плану, им нужно хорошенько обдумать то, что они собираются сделать. Но в нашем случае это больше напоминает хирургическое отделение на поле боя.
Аварии
======
Алертов много, поэтому ошибки неизбежны. И иногда в процессе исправления одной проблемы, можно создать гораздо большую.
Мы разделяем наши ошибки на три категории:
1. Отсутствие процесса: случилась что-то, с чем мы раньше не сталкивались, что именно делать непонятно, пытаемся исправить на ходу — становится хуже.
2. Ошибки в уже отлаженном процессе: с проблемой уже вроде бы знакомы, вроде бы понятно что надо делать, но не были предусмотрены все возможные варианты.
3. Ошибки взаимодействия: вроде бы процесс отлажен, но есть проблема коммуникации между людьми.
И у меня есть страшная история по каждому пункту.
Отсутствие процесса
===================
Первая — одна из самых страшных историй, которые с нами происходили. Она случилась 31 марта 2016 года. К нам пришел клиент на поддержку, с 2 ТБ базой данных в MySQL без единого бэкапа, с 70 сотрудниками, которые работали на этой базе. Она была довольно сложной: где-то 300 ГБ на одну таблицу, сотни миллионов записей в таблицах. Вся компания работает только потому, что эта база существует.
Отдельная проблема — предыдущие администраторы строили flashcache на диске и иногда файлы удалялись, иногда нет, происходило что-то странное.
Первой и самой главной задачей было создать бэкап базы, потому что если с ней случится хоть что-нибудь, то компания просто перестанет работать.
У базы нет слейва и люди работают с 9 до 18 с этой базой очень плотно — работу останавливать нельзя. В базе есть 300 ГБ MyISAM таблиц и xtrabackup, который хорошо бэкапит InnoDB, но лочит все на моменте бэкапа MyISAM. То есть мы сначала пытались запустить xtrabackup и посмотреть что будет. Xtrabackup заблочил MyISAM таблицы, сайт лег, все перестало работать.
Мы отменили запуск xtrabackup и стали думать что делать. У нас есть xtrabackup, который хорошо работает с InnoDB и который плохо работает с MyISAM. Но MyISAM в данном случае оказался не так уж и нужен в самом бэкапе. План был такой: мы запустим xtrabackup вручную без MyISAM части. Перенесем данные на слейв, со слейва поднимем еще один слейв, который будем просто дампать копированием.
Мы коллективно обсудили такой вариант действий, но никак не могли решиться. Все звучало разумно, кроме того, что мы так никогда не делали.
В два ночи я сам запустил xbackup, распотрошив бэкап так, чтобы он не делал ничего связанного с MyISAM и просто переливал данные. Но, к сожалению, в тот момент не все наши администраторы знали, что когда xtrabackup работает (по сути, это такой дампер MySQL), он создает временный лог, и довольно хитро – он создает его как файл, который открывает на чтение и запись, и немедленно удаляет. На диске этот файл найти нельзя, но он растет и растет. При этом xtrabackup его не стримит на другой сервер. Соответственно, если записей очень много, то место на диске быстро кончается. Об этом к нам в 16 часов пришел алерт.
На сервере стало мало свободного места, и админ пошел разбираться, что происходит. Он увидел, что место заканчивается, а чем оно забито – непонятно. Зато есть xtrabackup, у которого есть «deleted file», который имеет к этому какое-то отношение. И решил, что это удаленный лог, случайно открытый xtrabackup’ом и нужно бы его занулить.
Админ написал скрипт, который читал файлы-дескрипторы, открытые xtrabackup’ом, и занулял все файлы с пометкой «deleted». Запустил скрипт в 18:00, и сайт немедленно упал.
К 18:30 мы понимали, что MySQL не поднимается и не отвечает. В это время я ехал на машине из Новосибирска, где я был на конференции, к друзьям в Барнаул. С друзьями я посидел буквально пять минут, потому что мне позвонил клиент и сказал, что в результате безобидной вроде бы операции, внезапно лег сайт. Я заглянул в чат админов. И увидел там фразу: «Ну, мы же не убили им базу». Ответ был: «Да, убили. И возможно с концами».
Админ, запуская скрипт, зануляющий уже предписанные файловые дескрипторы, запустил его по pid MySQL и убил ibdata, которая весила 200—300 ГБ.
После небольшой паники я пришел к клиентам и сказал что произошло. Это был трудный разговор. К 19 часам мы поняли, что xtrabackup успел перелить ibdata.
В MySQL есть старая структура данных, когда все лежит в одном файле в ibdata, и есть отдельная новая структура InnoDB, где таблицы лежат в отдельных файлах. В ibdata, к сожалению, по-прежнему лежат «last sequence numbers», то есть MySQL запускается, смотрит в каких позициях в файлах лежат данные, идет туда и тогда все хорошо, если ibdata нет – MySQL не запускается. Вообще.
У нас была перелитая на горячую ibdata, мы пытались просто подсунуть ее, но MySQL data recovery с этой таблицей работать отказался. Понятно было что наверное что-то сделать можно, но что именно – непонятно.
Мы позвонили в известную компанию, которая связана с MySQL, и, в том числе, занимается восстановлением данных. Мы сказали, что у замечательная ситуация: есть 2ТБ база с 300GB таблицами и убитой ibdata. Есть еще отдельная ibdata, которая скопирована на горячую и мы бы очень хотели, чтобы они попытались восстановить эту базу. Нам ответили, что посмотреть можно, но это стоит $5 000. Поскольку косяк был страшный, я спросил, куда платить, после чего оказалось, что $5 000 — это fuck off money этой компании, работать они все равно отказались. Как я потом узнал, когда мы описали всю проблему, ребята из этой компании долго спорили, сможем ли мы восстановить эту базу.
К 21 часу мы нашли блог человека по имени Александр Кузьминский, который до этого тоже работал в компании, куда мы обратились. Он очень крутой, я его недавно видел, 50 раз сказал ему спасибо. В его блоге было написано, что если вы случайно удалили ibdata, и при этом у вас есть скопированная на горячую ibdata, вы можете ее поставить на место, запустить MySQL под gdb, и во время запуска оперативно в памяти менять неправильные значения «last sequence numbers» на правильные.
Нам очень хотелось вернуть базу, потому что все предыдущее время до этого я думал, что мы только что уничтожили компанию, в которой работает 70 человек. В итоге мы попробовали сделать как было написано, и оно запустилось. К сожалению, MySQL запускается в recovery mode и туда, естественно, ничего нельзя писать, да и вообще страшно. Поэтому мы решили, что базу надо задампать. На этот раз мы делали это MySQL-дампом. Поэтому следующие двое суток мы дампали потаблично всю базу, и надеялись, что все заработает. Заработало.
Мы решили, что отныне мы будем проводить анализ инцидентов.
Эмоций было очень много, но давайте рассмотрим все чуть более отстраненно.
### Что именно случилось?
Дано:
```
2016-03-31
- Клиент пришел на поддержку без бэкапов БД
- Размер БД (MySQL) — 2ТБ, около 300гб на таблицу
- Нет слейва, работу останавливать нельзя
- 300гб MyISAM (лок xtrabackup)
```
План:
```
2016-03-31
- Запускаем xtrabackup вручную, без MyISAM части
- Переносим данные на слейв, поднимаем слейв со слейва
- Последующие бэкапы – остановка второго слейва
```
Жизнь:
```
2016-03-31 02:00 запуск xtrabackup
2016-03-31 02:00 — 2016-04-01 16:00 рост (deleted) redo-log-а
2016-04-01 16:00 алерт «мало места на диске»
2016-04-01 17:00 ответственный администратор не знает о redo-log-е, решает чистить (deleted) xtrabackup, создает скрипт для зануления file-handler-а с (deleted)
2016-04-01 18:00 ответственный администратор запускает скрипт
2016-04-01 18:00 сайт недоступен
```
Спасение:
```
2016-04-01 18:00 — 18:30 MySQL упал и не запускается
2016-04-01 18:30 зануленный file handler был ibdata процесса MySQL
2016-04-01 19:00 остался скопированный нагорячую ibdata в куске xtrabackup дампа
2016-04-01 20:00 компания data recovery MySQL отказывается работать в такой ситуации
2016-04-01 21:00 пост в блоге Кузьминского о восстановлении через gdb
2016-04-01 21:00 — 2016-04-02 03:00 попытки запуска, успешный запуск в recovery mode
2016-04-02 03:00 — 2016-04-03 06:00 MySQLdump
```
### Почему это случилось?
Админ не понимал как работает xtrabackup, что создается TMP-файл, который может расти.
Не было чек-листа. Пытались сделать все, что приходило в голову, без всякого плана, потому что было уже не до этого. Я вмешивался и спрашивал почему до сих пор не готово.
Нестандартные операции, о которых не были проинформированы сотрудники. Кто-то запустил xtrabackup, а дежурный админ считает, что это работает какая-то базовая штука и почему-то заканчивается место.
### Выводы
* Избегать нестандартных операций.
Если они происходят, то мы работаем только одной группой, и люди внутри группы должны знать, что именно происходит.
* Непонятная проблема -— доложить менеджеру. Раньше, если возникала непонятная проблема на сервере, админы сами пытались с ней разобраться. Теперь, если почему-то заканчивается место, то админ должен сообщить менеджеру, что по неизвестной причине заканчивается место. Поскольку менеджер, возможно, проинформирован почему это происходит, возможно, знает, кто лучше справится с этой проблемой, или скажет, что админ может попробовать сам ее решить. Любая рискованная операция теперь требует двойного контроля: человек, который собирается что-то сделать, сначала говорит об этом, и только потом делает. Как второй пилот в самолете.
Проблемы, связанные с нарушением отлаженного процесса
=====================================================
В январе 2017 года был «кибер вторник». Это был наш второй большой косяк, не такой страшный, но тоже приятного мало.
Для подготовки к «кибер вторнику» один большой магазин утром решил прямо на продакшене устроить нагрузочное тестирование, чтобы узнать, где реально могут возникнуть проблемы. Это была хорошая идея — мы будем знать, где самое уязвимое место и проект будет готов к серьезным нагрузкам.
Дежурный админ в процессе утреннего и дневного тестирования сделал заметку к алертам, что страницы могут тормозить, страницы могут не отвечать, все нормально, это идет тест. И так и передал это следующей смене, которая пришла уже к вечеру «кибер вторника». В момент рассылки кэш страницы акции оказался отключен, туда повалил трафик, вечер и ночь сайт не отвечал.
### Что именно случилось?
Весь «кибер вторник» магазин не работал.
Интересно, что тут очень сложно кого-то обвинить. Каждый по отдельности всё сделал правильно: первый админ отметил, что алерты летят потому, что идет нагрузочное тестирование, другой админ прочитал об этом и не стал ничего чинить, когда полетели алерты. Все было правильно, все соблюли процесс, все было хорошо. Но все в итоге оказалось плохо.
### Почему это случилось и какие выводы надо сделать?
Админы передавали сообщения друг другу. Сейчас мы делаем так, что админы передают сообщения при подтверждении менеджера. Если есть какая-то причина не реагировать на критические оповещения — требуется подтверждение менеджера. При этом дежурный менеджер подтверждает все текущие сообщения системы мониторинга при передаче админской смены.
Ошибки процесса взаимодействия
==============================
5 октября 2017 года – третий наш большой косяк.
Сотрудник отдела разработки мониторинга попросил дежурного администратора выключить модуль на продакшн-сервере клиента. Продажи в мобильном приложении не шли шесть часов.
### Что именно случилось?
Все было по протоколу, но теперь возникла ошибка взаимодействия.
Когда разработчик пришел и сказал выключить модуль на продакшене, админ решил, что если разработчик так уверенно это говорит, то, видимо, он уже спросил разрешения и у менеджера, и у клиента.
Разработчик решил, что админ — человек ответственный, можно его попросить выключить, а он спросит у менеджера и у клиента, и, если все нормально, то выключит.
В итоге этот модуль просто рубанули, никого не спрашивая. Все было довольно плохо.
### Почему это случилось и какие выводы надо сделать?
Дежурный админ ожидал, что отключение согласовал разработчик, а сам разработчик думал, что отключение согласует админ.
Любое ожидаемое действие должно быть подтверждено. Не стоит надеяться, что кто-то другой спросит. Разработчику надо было свою просьбу направить через менеджера, менеджер подтвердил бы у клиента и передал админу.
Заключение
==========
Ошибки неизбежны, любой может ошибиться. У нас очень плотный поток задач, между которыми, к тому же, надо постоянно переключаться. Мы стараемся учиться на своих ошибках и ни в коем случае их не повторять.
Большинство проблем уже случались раньше и для них есть готовые решения, но иногда происходит что-то непредвиденное. Чтобы лучше с этим справляться, в отделе поддержки мы выделили четырех тимлидов. Они давно работают, и мы знаем, что они совершают меньше ошибок. Все стандартные ситуации дежурная группа админов решает по стандартным протоколам, а если происходит что-то совсем непонятное, сообщают тимлидам, и они уже решают на ходу, вместе с клиентом. | https://habr.com/ru/post/341194/ | null | ru | null |
# DNSSec: Что такое и зачем
#### Предисловие
Как оказалось, не так много людей знают что такое DNSSec, для чего он нужен, для чего нет и стоит ли его внедрять у себя. Так как на русском языке информации на этот счет мало, я постараюсь пролить свет на эти вопросы.
#### Что такое DNSSec
##### Немного истории
Изначально система доменных имен не имела никаких механизмов для защиты от подмены информации в ответе — архитектура системы такова, что и запрос, и ответ передаются чистым текстом. При этом резолвер судил о верности полученной информации только по идентификатору запроса, длина которого всего 2 байта. То есть чтобы отравить кэш нужно было просто перебрать 65536 значений. говорить об этом начали еще в 90-х. При этом принялись неспешно описывать первую редакцию DNSSec. Она увидела свет в 1997, через два года появилась следующая. В 2005 появилась нынешняя редакция DNSSec, с которой все и работают. Знаковое событие случилось в 2008 году, когда Дэн Камински показал миру, что отравить кэш можно за 10 секунд. Производители DNS софта ответили тем, что кроме идентификатора запроса стали рандомно выбирать исходящий порт. Попутно началась истерия по поводу внедрения DNSSec.
##### Как это работает
Принцип работы DNSSec тот же, что и у цифровой подписи. То есть закрытым ключом подписываем, открытым сверяем.
Особенность состоит в том, что DNSSec использует два типа ключей — одним подписывается зона (ZSK, zone signing key), другим подписывается набор ключей (KSK, key signing key). Сделано это из таких соображений: зона может быть достаточно большой чтобы удалось подобрать закрытый ключ, поэтому его надо менять почаще, да и сделать его можно покороче, чтобы зоны подписывались быстрее; KSK же используется для небольших объемов данных, поэтому его можно и подлиннее сделать и менять пореже. Тем более, что хэш от открытой части KSK требуется отправить в родительскую зону, что хотелось бы делать не слишком часто.
###### ZSK
С помощью этого ключа подписываются все наборы записей в зоне (RRSET), кроме точек делегирования. То есть, допустим у вас есть зона example.com и в ней такой кусок:
````
$ORGIGIN example.com.
@ SOA dns.example.com ns.example.com {
Serial
Refresh
Retry
Expire
nTTL
}
NS ns.example.com.
NS ns1.example.com.
DNSKEY 256 3 5 (
AwEAAfETe4xtZy3Ml+9NceWE0zTUWk5WgTs5
ogRJ1fVuJ5U2QmBb+t3ltA4BrZObLRjX2
HcMmneVC4C3IdgluAiV6Jpj7hgRZIbbG8les
LaiL0/wOoH/byPvNi5T0OQpG3vgXyhoBdWxl
zghFU3eQSAnWF0xP/c323rtP0irdY7v5
) ; key id = 38754
DNSKEY 257 3 5 (
AwEAAdanjntZ82rOdV97sDS5+QH+w1pKnRJ/
b8gmuRBC91q5fQ2YiQ5zzYKi9+gENlqx/1MN
jAFXJ1Fvtf0pJYKjmkiBJoHdZoEVRnJz8ODx
FYgFX/fx+SBKsG3ZioaHP3CEdZQ4k3kutN6o
tawolvHfErSwnJT/3IhAplXDHZrLmwXgWU3M
PvMhnJRR9jd7S4f3WF10oq+3qPkBbJrqxB3x
RydCSaZYfVuJ5U2QmBb+t3ltA4BB8jL8jOLS
zvP2lufa6P8f0TJxtcpx/t9IfvUyWHmr9H7r
inl4k8xDTVvaPnmBScxbuBc=
) ; key id = 23179
doo IN A 127.0.0.1
IN A 127.0.0.2
IN MX mail
foo NS ns1.test.ru.
NS ns2.test.ru.
bar NS ns1.test.ru.
NS ns2.test.ru.
DS 4915 5 1 180DC61CD4A2772DC02EC18934AA4C024D77DC11
DS 4915 5 2 03EE2B29404BDF6D8891C0E0C89F714FE865E1D59A621F6FB4642648 4BC8C852
````
И вы решили эту зону подписать. Сделано будет следующее:
1. Создастся последовательность подписанных записей;
2. Добавятся записи NSEC (об этом чуть ниже);
3. Подпишутся записи SOA, набор NS для example.com, адресные и MX записи для doo, каждая NSEC RR и каждый набор DS.
4. В зависимости от настроек софта также может быть подписан набор DNSKEY.
Точки делегирования, т.е. NS записи для дочерних зон, подписаны не будут.
###### KSK
Этим ключом подписывается набор DNSKEY записей.
Кроме того, от открытой части KSK берется хэш, который в дальнейшем отправляется в родительскую зону. В вышеприведенном примере это DS записи (Delegation Signer).
В случае с корневой зоной предполагается, что открытая часть ключа будет сообщена резолверу вручную. А чтобы при смене ключа не обновлять его каждый раз вручную, существуют механизмы его автоматического обновления, например у BIND'а есть опция managed-keys.
Очевидно, что закрытую часть KSK следует хранить как зеницу ока — во-первых иначе исчезает весь смысл DNSSec, во-вторых в случае компрометации быстро сменить KSK не получится.
###### Next SECure
Ну, вот подписали мы зону, но все равно кто-то посторонний может добавить в нее свою информацию и, даже неподписанная, она будет отдаваться сервером наравне с подписанной.
Чтобы такого не происходило, при подписи зоны доменные имена сортируются в алфавитном порядке, к каждому из них добавляется запись NSEC, в которой указывается какое следующее доменное имя защищено и какие записи для него присутствуют в зоне. Последняя NSEC запись указывает на SOA.
Если авторитетный сервер возвращает ответ NXDOMAIN (RCODE=3) или NODATA (RCODE=0), то в ответе обязательно должна присутствовать NSEC запись. Пример такого ответа:
````
; <<>> DiG 9.7.3 <<>> jhbczxccva.se +dnssec
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 8766
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 6, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags: do; udp: 4096
;; QUESTION SECTION:
;jhbczxccva.se. IN A
;; AUTHORITY SECTION:
se. 300 IN SOA catcher-in-the-rye.nic.se. registry-default.nic.se. 2011053104 1800 1800 864000 7200
se. 300 IN RRSIG SOA 5 1 172800 20110613123930 20110531090447 24825 se. JJGWAvmcB/Bq7t5z7iTQGLr9c0LzQkdwpNFsrIClJctZUn/Z3YN2EMVQ 0r6DvufTGk1L8JMvTaxkI43ZmvasFeNNzfUFjr+td8Mv9h7FF5kTfEO5 R7JMh4j0Kxl/Gy4j+Ofcm0ZiCZTtcnNdHwCIHaVpz9KA6uIubnlJNSLw YXI=
````
*Так как ответ NXDOMAIN всегда сопровождается SOA записью, то в подписанной зоне возвращается SOA и подпись для нее.*
**````
se. 300 IN RRSIG NSEC 5 1 7200 20110613011140 20110530130445 24825 se. dKL3iGCxNI51FSNjx4p0NmAMtjhJVqLeAShrRH0rRmdV0Ej1nAH/Z/ip zn7PqB+7j6PguNPfEU4ySHfS8BTprvmod60J//Asi9/2ymadcNkB5VXg fJD1DMBpnCK1aUqG8ieJFsMQuMrrYRkhy0TdrCxGtZmTCpOOxfOMtmKR rcQ=
se. 300 IN NSEC 0-0.se. NS SOA TXT RRSIG NSEC DNSKEY
````**
*Эта NSEC запись показывает, что указанное имя не попадает под маску.*
**````
jhbatar.se. 300 IN RRSIG NSEC 5 2 7200 20110613032526 20110530130445 24825 se. DWXq1ZlzuA9w0McNHWjpLO55H08rkWjtBDd8TewUCYnljM//1oXEvVcJ ORT9AxXoz9TMOEku2wFGydceX5zs4PZLwnEC+ieXu3ri/B0S533XpmKe 6CgQTda6maCvoF8d1gOc2nIbd7zKjdOl2ujMVJKCb6Bv3yoy4WjL3gka Ufk=
jhbatar.se. 300 IN NSEC jhbeagleklubb.se. NS RRSIG NSEC
````**
*А уже эта NSEC запись говорит о том, что доменное имя не обнаружено.*
Недостаток NSEC очевиден — кто угодно может получить содержимое зоны просто опросив для каждого имени эту запись. В связи с этим механизм был доработан и появились записи NSEC3, в которых доменные имена хэшируются.
NSEC3 для вычисления хэша может использовать соль, помимо соли можно задать количество итераций. Стоит заметить, что увеличение количества итераций приводит к увеличению нагрузки как на резолвер, так и на авторитетный сервер, причем на последний в большей степени. Это происходит из-за того, что для возвращения NXDOMAIN, авторитетный сервер должен вычислить хэш, и не один. Процесс описан в [RFC 5155](http://tools.ietf.org/html/rfc5155).
Кроме того, NSEC3 запись имеет поле флагов, которого нет у NSEC. На данный момент определен только один флаг — OPT-OUT, благодаря которому существует возможность подписывать не всю зону (что при больших размерах может быть весьма длительным процессом), а только те доменные имена, для которых есть DS записи.
С одной стороны OPT-OUT позволяет сильно сократить время подписи, однако при его использовании, наличие у злоумышленника доступа к файлу зоны позволяет ему добавить незащищенную запись, которая в дальнейшем может доставить проблемы.
###### Механизм работы
Допустим мы хотим узнать адрес test.bar.example.com:
1. Мы запрашиваем доменное имя у резолвера;
2. Резолвер выставляет бит DO и запрашивает test.bar.example.com у корневого сервера;
3. Резолвер знает, что корневая доменная зона подписана — у него указан ключ или хэш ключа для нее (так называемый trust-anchor), поэтому он запрашивает у корневого сервера DNSKEY записи для корневой зоны и сверяет полученное с имеющимся;
4. Корневой сервер не знает такого доменного имени, да и вообще максимум что ему известно — на каких серверах располагается зона com, он и сообщает адреса этих серверов нашему резолверу вместе с подписанной DS записью для зоны com;
5. Резолвер валидирует DS запись полученным и проверенным ZSK ключом корневой зоны;
6. Теперь резолвер знает, что зона com подписана, так что он спрашивает у ее DNS сервера DNSKEY и валидирует их, после чего интересуется про bar.example.com. Естественно, что сервер зоны com про таких не знает, ему только известно, что зона example.com живет на ns.example.com и ns1.example.com, именно это он и отвечает резолверу вместе с — да-да — DS записью;
7. Так резолвер выстроил цепочку доверия до example.com, где он узнает серверы имен зоны bar.example.com и ее DS;
8. В конце концов резолвер итеративно узнает адреса DNS серверов, отвечающих за bar.example.com, идет к ним и наконец-то получает желаемое, валидирует всю информацию и отдает нам адресную запись, выставив в ответе бит AD.
При невозможности что-то провалидировать резолвер вернет servfail.
###### Оказываемые эффекты
1. Исходящий трафик авторитетного DNS сервера увеличивается примерно в 4 раза;
2. Размер файла зоны после подписи (без OPT-OUT) вырастает в 6-7 раз;
3. Увеличение длины ключа приводит к заметному снижению qps резолвера, на авторитетный сервер влияет в меньшей степени;
4. Наоборот действует увеличение кол-ва итераций при использовании NSEC3;
5. DNSSec приводит к значительному увеличению DNS ответа и, следовательно, необходимо чтобы все сетевое оборудование корректно работало с DNS пакетами более 512 байт.
#### Зачем это нужно
Это сложный вопрос. Во-первых, надо учитывать создаваемые эффекты; во-вторых, требуется организовать надежное хранилище для ключей; в-третьих, следить за ротацией ключей; в-четвертых, следить за сроком годности подписей; в-пятых, DNSSec усиливает эффект amplified ddos.
Все это является платой за то, чтобы быть уверенным в информации, получаемой от авторитетных DNS серверов. Сейчас, правда, сообщество придумывает что еще можно включить в DNSSec, чтобы его можно было монетизировать, а некоторые и вовсе задаются весьма смелыми и интересными вопросами, например Phil Regnauld, член научного совета AFNIC, поинтересовавшийся «Will DNSSEC bring down the certificate industry?» на семинаре этого совета.
#### Что почитать на эту тему
* [Отсюда стоит начать раскопки](http://dnssec.net);
* [Очень подробный гайд по внедрению](http://csrc.nist.gov/publications/nistpubs/800-81r1/sp-800-81r1.pdf);
* [Здесь рассказывается про зоны RU, SU, XN--P1AI](http://www.ripe.net/ripe/meetings/regional-meetings/moscow-2010/dnssecforru.pdf);
* И, конечно же, rfc 4033-4035. | https://habr.com/ru/post/120620/ | null | ru | null |
# Как организовать ваши зависимости во Vue-приложении
Все, кто знаком с Vue, знают, что у Vue-приложения одна точка входа — файл `main.js`. Там, помимо создания экземпляра Vue, происходит импорт и своего рода Dependency Injection всех ваших глобальных зависимостей (директив, компонентов, плагинов). Чем больше проект, тем больше становится зависимостей, которые, к тому же, имеют каждая свою конфигурацию. В итоге получим один огромный файл со всеми конфигурациями.
В этой статье речь пойдет о том, как организовать глобальные зависимости, чтобы этого избежать.
Для чего писать это самим?
--------------------------
Многие могут подумать – зачем это нужно, если есть, например, [Nuxt](https://nuxtjs.org/), который это сделает за вас? В своих проектах я использовал его тоже, однако в простых проектах это может оказаться избыточным. Кроме того, никто не отменял проекты с legacy-кодом, которые падают на вас, как снег на голову. И подключать туда фреймворк – практически делать его с нуля.
Идейный вдохновитель
--------------------
Вдохновителем такой организации явился Nuxt. Он был использован мной на крупном проекте с Vue.
У Nuxt есть прекрасная фича – plugins. Каждый плагин – это файл, который экспортирует функцию. В функцию передается конфиг, который также будет передан конструктору Vue при создании экземпляра, а также весь [store](https://vuex.vuejs.org/).
Кроме того, в каждом плагине доступна крайне полезная функция – `inject`. Она делает Dependency Injection в корневой экземпляр Vue и в объект `store`. А это значит, что в каждом компоненте, в каждой функции хранилища указанная зависимость будет доступна через `this`.
Где это может пригодиться?
--------------------------
Помимо того, что `main.js` существенно «похудеет», вы также получите возможность использования зависимости в любом месте приложения без лишних импортов.
Яркий пример Dependency Injection – это [vue-router](https://router.vuejs.org/). Он используется не так уж и часто – получить параметры текущего роута, сделать редирект, однако это глобальная зависимость. Если он может пригодиться в любом компоненте, то почему бы не сделать его глобальным? К тому же, благодаря этому его состояние тоже будет храниться глобально и меняться для всего приложения.
Другой пример – [vue-wait](https://github.com/f/vue-wait). Разработчики этого плагина пошли дальше и добавили свойство `$wait` не только в экземпляр Vue, но и во vuex store. Учитывая специфику плагина, это оказывается крайне полезным. Например, в store есть action, который вызывается в нескольких компонентах. И в каждом случае нужно показать лоадер на каком-то элементе. Вместо того, чтобы до и после каждого вызова action вызывать `$wait.start('action')` и `$wait.end('action')`, можно просто вызвать эти методы один раз в самом action. И это гораздо более читаемо и менее многословно, чем `dispatch('wait/start', 'action' {root: true})`. В случае со store это синтаксический сахар.
От слов к коду
--------------
### Базовая структура проекта
Посмотрим, как сейчас выглядит проект:
`src
- store
- App.vue
- main.js`
`main.js` выглядит примерно так:
```
import Vue from 'vue';
import App from './App.vue';
import store from './store';
new Vue({
render: h => h(App),
store
}).$mount('#app');
```
### Подключаем первую зависимость
Теперь мы хотим подключить в наш проект [axios](https://github.com/axios/axios) и создать для него некую конфигурацию. Я придерживался терминологии Nuxt и создал в `src` каталог `plugins`. Внутри каталога – файлы `index.js` и `axios.js`.
`src
- plugins
-- index.js
-- axios.js
- store
- App.vue
- main.js`
Как было сказано выше, каждый плагин должен экспортировать функцию. При этом внутри функции мы хотим иметь доступ к store и впоследствии – функцию `inject`.
`axios.js`
```
import axios from 'axios';
export default function (app) {
// можем задать здесь любую конфигурацию плагина – заголовки, авторизацию, interceptors и т.п.
axios.defaults.baseURL = process.env.API_BASE_URL;
axios.defaults.headers.common['Accept'] = 'application/json';
axios.defaults.headers.post['Content-Type'] = 'application/json';
axios.interceptors.request.use(config => {
...
return config;
});
}
```
`index.js`:
```
import Vue from 'vue';
import axios from './axios';
export default function (app) {
let inject = () => {}; // объявляем функцию inject, позже мы добавим в нее код для Dependency Injection
axios(app, inject); // передаем в наш плагин будущий экземпляр Vue и созданную функцию
}
```
Как можно заметить, файл `index.js` тоже экспортирует функцию. Это сделано для того, чтобы иметь возможность передать туда объект `app`. Теперь немного поменяем `main.js` и вызовем эту функцию.
`main.js`:
```
import Vue from 'vue';
import App from './App.vue';
import store from './store';
import initPlugins from './plugins'; // импортируем новую функцию
// объект, который передается конструктору Vue, объявляем отдельно, чтобы передать его функции initPlugins
const app = {
render: h => h(App),
store
};
initPlugins(app);
new Vue(app).$mount('#app'); // измененный функцией initPlugins объект передаем конструктору
```
### Результат
На данном этапе мы добились того, что убрали конфигурацию плагина из `main.js` в отдельный файл.
Кстати, польза от передачи объекта `app` всем нашим плагинам в том, что внутри каждого плагина у нас теперь есть доступ к store. Можно свободно использовать его, вызывая `commit`, `dispatch`, а также обращаясь к `store.state` и `store.getters`.
Если вы любите ES6-style, можете даже сделать так:
`axios.js`
```
import axios from 'axios';
export default function ({store: {dispatch, commit, state, getters}}) {
...
}
```
Второй этап – Dependency Injection
----------------------------------
Мы уже создали первый плагин и сейчас наш проект выглядит так:
`src
- plugins
-- index.js
-- axios.js
- store
- App.vue
- main.js`
Так как в большинстве библиотек, где это действительно необходимо, Dependency Injection уже реализована за счет `Vue.use`, то мы создадим свой собственный простой плагин.
Например, попробуем повторить то, что делает `vue-wait`. Это достаточно тяжелая библиотека, поэтому если вы хотите показать лоадер на паре кнопок, лучше от нее отказаться. Однако я не смог устоять перед ее удобством и повторил в своем проекте ее базовый функционал, включая синтаксический сахар в store.
### Wait Plugin
Создадим в каталоге `plugins` еще один файл – `wait.js`.
У меня уже есть vuex-модуль, который я также назвал `wait`. Он делает три простых действия:
— `start` — устанавливает в state свойство объекта с именем `action` в `true`
— `end` — удаляет из state свойство объекта с именем `action`
— `is` — получает из state свойство объекта с именем `action`
В этом плагине мы будем его использовать.
`wait.js`
```
export default function ({store: {dispatch, getters}}, inject) {
const wait = {
start: action => dispatch('wait/start', action),
end: action => dispatch('wait/end', action),
is: action => getters['wait/waiting'](action)
};
inject('wait', wait);
}
```
И подключаем наш плагин:
`index.js`:
```
import Vue from 'vue';
import axios from './axios';
import wait from './wait';
export default function (app) {
let inject = () => {}; Injection
axios(app, inject);
wait(app, inject);
}
```
### Функция inject
Теперь реализуем функцию `inject`.
```
// функция принимает 2 параметра:
// name – имя, по которому плагин будет доступен в this. Обратите внимание, что во Vue принято использовать имя с префиксом доллар для Dependency Injection
// plugin – непосредственно, что будет доступно по имени в this. Как правило, это объект, но может быть также любой другой тип данных или функция
let inject = (name, plugin) => {
let key = `$${name}`; // добавляем доллар к имени свойства
app[key] = plugin; // кладем свойство в объект app
app.store[key] = plugin; // кладем свойство в объект store
// магия Vue.prototype
Vue.use(() => {
if (Vue.prototype.hasOwnProperty(key)) {
return;
}
Object.defineProperty(Vue.prototype, key, {
get () {
return this.$root.$options[key];
}
});
});
};
```
#### Магия Vue.prototype
Теперь о магии. В [документации Vue](https://ru.vuejs.org/v2/cookbook/adding-instance-properties.html) сказано, что достаточно написать `Vue.prototype.$appName = 'Моё приложение';` и `$appName` станет доступно в `this`.
Однако на деле оказалось, что это не так. Вследствие гуглинга не нашлось ответа, почему такая конструкция не заработала. Поэтому я решил обратиться к авторам плагина, которые уже это реализовали.
#### Глобальный mixin
Как и в нашем примере, я посмотрел код плагина `vue-wait`. Они предлагают такую реализацию (исходный код очищен для наглядности):
```
Vue.mixin({
beforeCreate() {
const { wait, store } = this.$options;
let instance = null;
instance.init(Vue, store); // inject to store
this.$wait = instance; // inject to app
}
});
```
Вместо прототипа предлагается использовать глобальный mixin. Эффект в общем-то тот же, возможно, за исключением каких-то нюансов. Но учитывая, что и в store inject делается здесь же, выглядит не совсем right way и совсем не соответствует описанному в документации.
#### А если все же prototype?
Идея решения с прототипом, которая используется в коде функции `inject` была позаимствована у Nuxt. Выглядит она намного более right way, чем глобальный mixin, поэтому я остановился на ней.
```
Vue.use(() => {
// проверяем, что такого свойства еще нет в прототипе
if (Vue.prototype.hasOwnProperty(key)) {
return;
}
// определяем новое свойство прототипа, взяв его значение из ранее добавленной в объект app переменной
Object.defineProperty(Vue.prototype, key, {
get () {
return this.$root.$options[key]; // геттер нужен, чтобы использовать контекст this
}
});
});
```
### Результат
После этих манипуляций мы получаем возможность обратиться к `this.$wait` из любого компонента, а также любого метода в store.
Что получилось
--------------
Структура проекта:
`src
- plugins
-- index.js
-- axios.js
-- wait.js
- store
- App.vue
- main.js`
`index.js`:
```
import Vue from 'vue';
import axios from './axios';
import wait from './wait';
export default function (app) {
let inject = (name, plugin) => {
let key = `$${name}`;
app[key] = plugin;
app.store[key] = plugin;
Vue.use(() => {
if (Vue.prototype.hasOwnProperty(key)) {
return;
}
Object.defineProperty(Vue.prototype, key, {
get () {
return this.$root.$options[key];
}
});
});
};
axios(app, inject);
wait(app, inject);
}
```
`wait.js`
```
export default function ({store: {dispatch, getters}}, inject) {
const wait = {
start: action => dispatch('wait/start', action),
end: action => dispatch('wait/end', action),
is: action => getters['wait/waiting'](action)
};
inject('wait', wait);
}
```
`axios.js`
```
import axios from 'axios';
export default function (app) {
axios.defaults.baseURL = process.env.API_BASE_URL;
axios.defaults.headers.common['Accept'] = 'application/json';
axios.defaults.headers.post['Content-Type'] = 'application/json';
}
```
`main.js`:
```
import Vue from 'vue';
import App from './App.vue';
import store from './store';
import initPlugins from './plugins';
const app = {
render: h => h(App),
store
};
initPlugins(app);
new Vue(app).$mount('#app');
```
Заключение
----------
В результате проведенных манипуляций мы получили один импорт и один вызов функции в файле `main.js`. А также теперь сразу понятно, где искать конфиг для каждого плагина и каждую глобальную зависимость.
При добавлении нового плагина нужно всего лишь создать файл, который экспортирует функцию, импортировать его в `index.js` и вызвать эту функцию.
В моей практике такая структура показала себя очень удобной, к тому же она легко переносится из проекта в проект. Теперь нет никакой боли, если нужно сделать Dependency Injection или сконфигурировать очередной плагин.
Делитесь своим опытом организации зависимостей в комментариях. Успешных проектов! | https://habr.com/ru/post/423013/ | null | ru | null |
# Chisel — (не совсем) новый подход к разработке цифровой логики
С развитием микроэлектроники, rtl дизайны становились все больше и больше. Реюзабилити кода на verilog доставляет массу неудобств, даже с использованием generate, макросов и фишек system verilog. Chisel же, дает возможность применить всю мощь объектного и функционального программирования к разработке rtl, что является достаточно долгожданным шагом, который может наполнить свежим воздухом легкие разработчиков ASIC и FPGA.
В этой статье будет дан краткий обзор основного функционала и рассмотрены некоторые юзкейсы использования, также поговорим о недостатках этого языка. В дальнейшем, если тема будет интересна, продолжим статью в более детальных туториалах.
### Системные требования
* scala базовый уровень
* verilog и основные принципы построения цифровых дизайнов.
* держать документацию chisel под рукой
Я постараюсь разобрать основы chisel на простых примерах, но если что-то будет непонятно, то можете [подглядеть сюда](https://github.com/freechipsproject/chisel3/wiki).
Что касается scala для быстрого погружения может помочь этот [чит-лист](https://docs.scala-lang.org/cheatsheets/).
Подобный [есть и для chisel](https://chisel.eecs.berkeley.edu/doc/chisel-cheatsheet3.pdf).
Полный код статьи (в виде scala sbt проекта) вы сможете [найти тут](https://github.com/SpaceCowboyMax/counter).
### Простой счетчик
Как можно понять из названия 'Constructing Hardware In a scala Embedded Language' chisel — это язык описания аппаратуры надстроенный над scala.
Если коротко о том как все работает, то: из rtl описания на chisel строится hardware граф, который, в свою очередь, превращается в промежуточное описание на языке firrtl, а уже после встроенный бэкэнд интерпретатор генерит из firrtl verilog.
Посмотрим на две реализации простого счетчика.
verilog :
```
module SimpleCounter #(
parameter WIDTH = 8
)(
input clk,
input reset,
input wire enable,
output wire [WIDTH-1:0] out
);
reg [WIDTH-1:0] counter;
assign out = counter;
always @(posedge clk)
if (reset) begin
counter <= {(WIDTH){1'b0}};
end else if (enable) begin
counter <= counter + 1;
end
endmodule
```
chisel :
```
class SimpleCounter(width: Int = 32) extends Module {
val io = IO(new Bundle {
val enable = Input(Bool())
val out = Output(UInt(width.W))
})
val counter = RegInit(0.U(width.W))
io.out <> counter
when(io.enable) {
counter := counter + 1.U
}
}
```
Немного о chisel:
* `Module` — контейнер для rtl описания модуля
* `Bundle` — структура данных в chisel, в основном используется для определения интерфейсов.
* `io` — переменная для определения портов
* `Bool` — тип данных, простой однобитовый сигнал
* `UInt(width: Width)` — беззнаковое целое, конструктор принимает на вход разрядность сигнала.
* `RegInit[T <: Data](init: T)` — конструктор регистра, на вход принимает значение по сбросу и имеет такой же тип данных.
* `<>` — универсальный оператор соединения сигналов
* `when(cond: => Bool) { /*...*/ }` — аналог `if` в verilog
О том какой verilog генерирует chisel поговорим немного позже. Сейчас просто сравним эти два дизайна. Как можно заметить, в chisel отсутствует какое-либо упоминание сигналов `clk` и `reset`. Дело в том, что chisel по умолчанию добавляет эти сигналы к модулю. Значение по сбросу для регистра `counter` мы передаем в конструктор регистра со сбросом `RegInit`. Поддержка модулей с множеством тактовых сигналов в chisel есть, но о ней тоже немного позже.
### Счетчик чуть посложнее
Пойдем дальше и немного усложним задачу, например — сделаем многоканальный счетчик с входным параметром в виде последовательности разрядностей для каждого из каналов.
Начнем теперь с версии на chisel
```
class MultiChannelCounter(width: Seq[Int] = Seq(32, 16, 8, 4)) extends Module {
val io = IO(new Bundle {
val enable = Input(Vec(width.length, Bool()))
val out = Output(UInt(width.sum.W))
def getOut(i: Int): UInt = {
val right = width.dropRight(width.length - i).sum
this.out(right + width(i) - 1, right)
}
})
val counters: Seq[SimpleCounter] = width.map(x =>
Module(new SimpleCounter(x))
)
io.out <> util.Cat(counters.map(_.io.out))
width.indices.foreach { i =>
counters(i).io.enable <> io.enable(i)
}
}
```
Немного о scala:
* `width: Seq[Int]` — входной параметр для конструктора класса `MultiChannelCounter`, имеет тип `Seq[Int]` — последовательность с целочисленными элементами.
* `Seq` — один из типов коллекций в scala c четко определенной последовательностью элементов.
* `.map` — для всех знакомая функция над коллекциями, способная преобразовать одну коллекцию в другую за счет одной и той же операции над каждым элементом, в нашем случае последовательность целых значений превращается в последовательность `SimpleCounter`'ов с соответствующей разрядностью.
Немного о chisel:
* `Vec[T <: Data](gen: T, n: Int): Vec[T]` — тип данных chisel, является аналогом массива.
* `Module[T <: BaseModule](bc: => T): T` — обязательный метод обертки для инстантируемых модулей.
* `util.Cat[T <: Bits](r: Seq[T]): UInt` — функция конкатенации, аналог `{1'b1, 2'b01, 4'h0}` в verilog
Обратим внимание на порты:
`enable` — развернулся уже в `Vec[Bool]`\*, грубо говоря, в массив однобитных сигналов по одному для каждого канала, можно было сделать и `UInt(width.length.W)`.
`out` — расширился до суммы ширин всех наших каналов.
Переменная `counters` является массивом наших счетчиков. Подключаем `enable` сигнал каждого счетчика к соответствующему входному порту, а все сигналы `out` объединяем в один с помощью встроенной `util.Cat` функции и пробрасываем на выход.
Отметим еще и функцию `getOut(i: Int)` — эта функция высчитывает и возвращает диапазон битов в сигнале `out` для `i`'ого канала. Будет очень полезна при дальнейшей работе с таким счетчиком. Реализовать нечто подобное в verilog не выйдет
\*`Vec` не путать с `Vector`, первый это массив данных в chisel, второй же коллекция в scala.
Давайте теперь попробуем написать этот модуль на verilog, для удобства даже на systemVerilog.
Посидев подумав я пришел к такому варианту(скорее всего он не является единственно верным и самым оптимальным, но вы всегда можете предложить свою реализацию в комментариях).
**verilog**
```
module MultiChannelCounter #(
parameter TOTAL = 4,
parameter integer WIDTH_SEQ [TOTAL] = {32, 16, 8, 4}
)(clk, reset, enable, out);
localparam OUT_WIDTH = get_sum(TOTAL, WIDTH_SEQ);
input clk;
input reset;
input wire [TOTAL - 1 : 0] enable;
output wire [OUT_WIDTH - 1 :0] out;
genvar j;
generate
for(j = 0; j < TOTAL; j = j + 1) begin : counter_generation
localparam OUT_INDEX = get_sum(j, WIDTH_SEQ);
SimpleCounter #( WIDTH_SEQ[j] ) SimpleCounter_unit (
.clk(clk),
.reset(reset),
.enable(enable[j]),
.out(out[OUT_INDEX + WIDTH_SEQ[j] - 1: OUT_INDEX])
);
end
endgenerate
function automatic integer get_sum;
input integer array_width;
input integer array [TOTAL];
integer counter = 0;
integer i;
begin
for(i = 0; i < array_width; i = i + 1)
counter = counter + array[i];
get_sum = counter;
end
endfunction
endmodule
```
Выглядит уже куда внушительнее. Но что если, мы пойдем дальше и прикрутим к этому популярный wishbone интерфейс с регистровым доступом.
### Bundle интерфейсы
Wishbone — небольшая шина по типу AMBA APB, используется в основном для ip ядер с открытым исходным кодом.
Чуть подробнее на вики: <https://ru.wikipedia.org/wiki/Wishbone>
Т.к. chisel предоставляет нам контейнеры данных типа `Bundle` имеет смысл обернуть шину в такой контейнер, который в последствии можно будет использовать в любых проектах на chisel.
```
class wishboneMasterSignals(
addrWidth: Int = 32,
dataWidth: Int = 32,
gotTag: Boolean = false)
extends Bundle {
val adr = Output(UInt(addrWidth.W))
val dat_master = Output(UInt(dataWidth.W))
val dat_slave = Input(UInt(dataWidth.W))
val stb = Output(Bool())
val we = Output(Bool())
val cyc = Output(Bool())
val sel = Output(UInt((dataWidth / 8).W))
val ack_master = Output(Bool())
val ack_slave = Input(Bool())
val tag_master: Option[UInt] = if(gotTag) Some(Output(Bool())) else None
val tag_slave: Option[UInt] = if(gotTag) Some(Input(Bool())) else None
def wbTransaction: Bool = cyc && stb
def wbWrite: Bool = wbTransaction && we
def wbRead: Bool = wbTransaction && !we
override def cloneType: wishboneMasterSignals.this.type =
new wishboneMasterSignals(addrWidth, dataWidth, gotTag).asInstanceOf[this.type]
}
```
Немного о scala:
* `Option` — опциональная обертка данных в scala который может быть либо элементом либо `None`, `Option[UInt]` — это либо `Some(UInt(/*...*/))` либо `None`, полезно при параметризации сигналов.
Вроде ничего необычного. Просто описание интерфейса со стороны мастера, за исключением нескольких сигналов и методов:
`tag_master` и `tag_slave` — опциональные сигналы общего назначения в протоколе wishbone, у нас они будут появляться если параметр `gotTag`, будет равен `true`.
`wbTransaction`, `wbWrite`, `wbRead` — функции для упрощения работы с шиной.
`cloneType` — обязательный метод клонирования типа для всех параметризированых `[T <: Bundle]` классов
Но нам нужен еще и slave интерфейс, посмотрим как можно его реализовать.
```
class wishboneSlave(
addrWidth: Int = 32,
dataWidth: Int = 32,
tagWidht: Int = 0)
extends Bundle {
val wb = Flipped(new wishboneMasterSignals(addrWidth , dataWidth, tagWidht))
override def cloneType: wishboneSlave.this.type =
new wishboneSlave(addrWidth, dataWidth, tagWidht).asInstanceOf[this.type]
}
```
Метод `Flipped`, как можно было догадаться из названия переворачивает интерфейс, и теперь наш мастер интерфейс превратился в слейв, добавим такой же класс но для мастера.
```
class wishboneMaster(
addrWidth: Int = 32,
dataWidth: Int = 32,
tagWidht: Int = 0)
extends Bundle {
val wb = new wishboneMasterSignals(addrWidth , dataWidth, tagWidht)
override def cloneType: wishboneMaster.this.type =
new wishboneMaster(addrWidth, dataWidth, tagWidht).asInstanceOf[this.type]
}
```
Ну вот и все, интерфейс готов. Но прежде чем писать обработчик, посмотрим как можно будет пользоваться этими интерфейсами в случае если нам нужно сделать коммутатор или что-то с большим набором wishbone интерфейсов.
```
class WishboneCrossbarIo(n: Int, addrWidth: Int, dataWidth: Int) extends Bundle {
val slaves = Vec(n, new wishboneSlave(addrWidth, dataWidth, 0))
val master = new wishboneMaster(addrWidth, dataWidth, 0)
}
class WBCrossBar extends Module {
val io = IO(new WishboneCrossbarIo(1, 32, 32))
io.master <> io.slaves(0)
// ...
}
```
Это небольшая заготовка под коммутатор. Удобно объявить интерфейс типа `Vec[wishboneSlave]`, а соединять интерфейсы можно тем же оператором `<>`. Достаточно полезные фишки chisel когда речь идет об управлении большим набором сигналов.
### Универсальный контроллер шины
Как говорилось ранее про мощь функционального и объектного программирования, попробуем его применить. Дальше речь пойдет о реализации универсального контроллера шины wishbone в виде `trait`, это будет некий mixin для любого модуля с шиной `wishboneSlave`, для модуля лишь нужно определить карту памяти и замешать `trait` — контроллер к нему при генерации.
#### Реализация
**Для тех, кто все еще полон энтузиазма**Перейдем к реализации обработчика. Он будет простым и сразу отвечать на одиночные транзакции, в случае выпадения из пула адресов выдавать ноль.
Разеберем по частям:
* на каждую транзакцию нужно отвечать acknowlege-ом
```
val io : wishboneSlave = /* ... */
val wb_ack = RegInit(false.B)
when(io.wb.wbTransaction) {
wb_ack := true.B
}.otherwise {
wb_ack := false.B
}
wb_ack <> io.wb.ack_slave
```
* На чтение отвечаем данными
```
val wb_dat = RegInit(0.U(io.wb.dat_slave.getWidth.W)) // getWidth возращает разрядность
when(io.wb.wbRead) {
wb_dat := MuxCase(default = 0.U, Seq(
(io.wb.addr === ADDR_1) -> data_1,
(io.wb.addr === ADDR_3) -> data_2,
(io.wb.addr === ADDR_3) -> data_2
))
}
wb_dat <> io.wb.dat_slave
```
+ `MuxCase[T <: Data] (default: T, mapping: Seq[(Bool, T)]): T` — встроенная кобинационная схема типа `case` в verilog\*.
Как примерно выглядело бы в verilog:
```
always @(posedge clock)
if(reset)
wb_dat_o <= 0;
else if(wb_read)
case (wb_adr_i)
`ADDR_1 : wb_dat_o <= data_1;
`ADDR_2 : wb_dat_o <= data_2;
`ADDR_3 : wb_dat_o <= data_3;
default : wb_dat_o <= 0;
endcase
}
```
\*Вообще в данном случае это небольшой хак ради параметризируемости, в chisel есть стандартная конструкция которую лучше использовать если, пишите что-то более простое.
```
switch(x) {
is(value1) {
// ...
}
is(value2) {
// ...
}
}
```
Ну и запись
```
when(io.wb.wbWrite) {
data_4 := Mux(io.wb.addr === ADDR_4, io.wb.dat_master, data_4)
}
```
* `Mux[T <: Data](cond: Bool, con: T, alt: T): T` — обычный мультиплексор
Встраиваем нечто подобное к нашему мультиканальному счетчику, вешаем регистры на управление каналами и дело в шляпе. Но тут уже рукой подать до универсального контроллер шины WB которому мы будем передавать карту памяти такого вида:
```
val readMemMap = Map(
ADDR_1 -> DATA_1,
ADDR_2 -> DATA_2
/*...*/
)
val writeMemMap = Map(
ADDR_1 -> DATA_1,
ADDR_2 -> DATA_2
/*...*/
)
```
Для такой задачи нам помогут `trait` — что-то вроде mixin-ов в Sala. Основной задачей будет привести `readMemMap: [Int, Data]` к виду `Seq(условие -> данные)`, а еще было бы неплохо если бы можно было передавать внутри карты памяти базовый адрес и массив данных
```
val readMemMap = Map(
ADDR_1_BASE -> DATA_SEQ,
ADDR_2 -> DATA_2
/*...*/
)
```
Что будет раскрываться с в нечто подобное, где WB\_DAT\_WIDTH ширина данных в байтах
```
val readMemMap = Map(
ADDR_1_BASE + 0 * (WB_DAT_WIDHT)-> DATA_SEQ_0,
ADDR_1_BASE + 1 * (WB_DAT_WIDHT)-> DATA_SEQ_1,
ADDR_1_BASE + 2 * (WB_DAT_WIDHT)-> DATA_SEQ_2,
ADDR_1_BASE + 3 * (WB_DAT_WIDHT)-> DATA_SEQ_3
/*...*/
ADDR_2 -> DATA_2
/*...*/
)
```
Для реализации этого, напишем функцию конвертор из `Map[Int, Any]` в `Seq[(Bool, UInt)]`. Придется задействовать scala pattern mathcing.
```
def parseMemMap(memMap: Map[Int, Any]): Seq[(Bool, UInt)] = memMap.flatMap { case(addr, data) =>
data match {
case a: UInt => Seq((io.wb.adr === addr.U) -> a)
case a: Seq[UInt] => a.map(x => (io.wb.adr === (addr + io.wb.dat_slave.getWidth / 8).U) -> x)
case _ => throw new Exception("WRONG MEM MAP!!!")
}
}.toSeq
```
Окончательно наш трейт будет выглядеть так :
```
trait wishboneSlaveDriver {
val io : wishboneSlave
val readMemMap: Map[Int, Any]
val writeMemMap: Map[Int, Any]
val parsedReadMap: Seq[(Bool, UInt)] = parseMemMap(readMemMap)
val parsedWriteMap: Seq[(Bool, UInt)] = parseMemMap(writeMemMap)
val wb_ack = RegInit(false.B)
val wb_dat = RegInit(0.U(io.wb.dat_slave.getWidth.W))
when(io.wb.wbTransaction) {
wb_ack := true.B
}.otherwise {
wb_ack := false.B
}
when(io.wb.wbRead) {
wb_dat := MuxCase(default = 0.U, parsedReadMap)
}
when(io.wb.wbWrite) {
parsedWriteMap.foreach { case(addrMatched, data) =>
data := Mux(addrMatched, io.wb.dat_master, data)
}
}
wb_dat <> io.wb.dat_slave
wb_ack <> io.wb.ack_slave
def parseMemMap(memMap: Map[Int, Any]): Seq[(Bool, UInt)] = { /*...*/}
}
```
Немного о scala :
* `io , readMemMap, writeMemMap` — абстрактные поля нашего `trait`'a, которые должны быть определены в классе в который мы будем его замешивать.
#### Как им пользоваться
Чтобы замешать наш `trait` к модулю нужно соблюсти несколько условий:
* `io` должен наследоваться от класса `wishboneSlave`
* нужно объявить две карты памяти `readMemMap` и `writeMemMap`
```
class WishboneMultiChannelCounter extends Module {
val BASE = 0x11A00000
val OUT = 0x00000100
val S_EN = 0x00000200
val H_EN = 0x00000300
val wbAddrWidth = 32
val wbDataWidth = 32
val wbTagWidth = 0
val width = Seq(32, 16, 8, 4)
val io = IO(new wishboneSlave(wbAddrWidth, wbDataWidth, wbTagWidth) {
val hardwareEnable: Vec[Bool] = Input(Vec(width.length, Bool()))
})
val counter = Module(new MultiChannelCounter(width))
val softwareEnable = RegInit(0.U(width.length.W))
width.indices.foreach(i => counter.io.enable(i) := io.hardwareEnable(i) && softwareEnable(i))
val readMemMap = Map(
BASE + OUT -> width.indices.map(counter.io.getOut),
BASE + S_EN -> softwareEnable,
BASE + H_EN -> io.hardwareEnable.asUInt
)
val writeMemMap = Map(
BASE + S_EN -> softwareEnable
)
}
```
Создаем регистр `softwareEnable` он по 'и' складывается с входным сигналом `hardwareEnable` и заходит на enable `counter[MultiChannelCounter]`.
Объявляем две карты памяти на чтение и на запись: `readMemMap` `writeMemMap`, подробнее о структуре можете посмотреть главу выше.
В карту памяти чтения передаем значение счетчика каждого канала\*, `softwareEnable` и `hardwareEnable`. А на запись отдаем только `softwareEnable` регистр.
\*`width.indices.map(counter.io.getOut)` — странная конструкция, разберем по частям.
* `width.indices` — вернет массив с индексами элементов, т.е. если `width.length == 4` то `width.indices = {0, 1, 2, 3}`
* `{0, 1, 2, 3}.map(counter.io.getOut)` — дает примерно следующее:
`{ counter.io.getOut(0), counter.io.getOut(1), /*...*/ }`
Теперь для любого модуля на chisel с мы можем объявлять карты памяти на чтение и запись и просто подключать наш универсальный контроллер шины wishbone при генерации, как-то так :
```
class wishbone_multicahnnel_counter extends WishboneMultiChannelCounter with wishboneSlaveDriver
object countersDriver extends App {
Driver.execute(Array("-td", "./src/generated"), () =>
new wishbone_multicahnnel_counter
)
}
```
`wishboneSlaveDriver` — как раз и есть тот trait микс который мы описали под спойлером.
Конечно, этот вариант универсального контроллера далеко не окончательный, а скорей наоборот сырой. Его главная цель продемонстрировать один из возможных подходов к разработке rtl на chisel. Со всеми возможностями scala таких подходов может быть намного больше, так что у каждого разработчика свое поле для творчества. Правда вдохновляться особо пока неоткуда, кроме как :
* родная chisel библиотека utils, о которой немного дальше, там можно посмотреть на наследование модулей и интерфейсов
* <https://github.com/freechipsproject/rocket-chip> — risc-v ядро целиком реализованное на chisel, при условии что вы очень хорошо знаете scala, для новичков же без пол литра как говориться будете очень долго разбираться т.к. какой-либо официальной документации о внутренней структуре проекта нет.
### MultiClockDomain
Что если мы захотим вручную управлять тактовыми сигналами и сигналами сброса в chisel. До недавнего времени сделать это было нельзя, но c одним из последних релизов появилась поддержка `withClock {}`, `withReset {}` и `withClockAndReset {}`. Посмотрим на примере :
```
class DoubleClockModule extends Module {
val io = IO(new Bundle {
val clockB = Input(Clock())
val in = Input(Bool())
val out = Output(Bool())
val outB = Output(Bool())
})
val regClock = RegNext(io.in, false.B)
regClock <> io.out
val regClockB = withClock(io.clockB) {
RegNext(io.in, false.B)
}
regClockB <> io.outB
}
```
* `regClock` — регистр который будет тактироваться стандартным сигналом `clock` и сбрасываться стандартным `reset`
* `regClockB` — этот же регистр тактируется, как вы догадались, сигналом `io.clockB`, но сброс будет использоваться стандартный.
Если же мы хотим убрать стандартные сигналы `clock` и `reset` полностью, то можно использовать пока экспериментальную фичу — `RawModule`(модуль без стандартных сигналов тактирования и сброса, всем придется управлять вручную). Пример :
```
class MultiClockModule extends RawModule {
val io = IO(new Bundle {
val clockA = Input(Clock())
val clockB = Input(Clock())
val resetA = Input(Bool())
val resetB = Input(Bool())
val in = Input(Bool())
val outA = Output(Bool())
val outB = Output(Bool())
})
val regClockA = withClockAndReset(io.clockA, io.resetA) {
RegNext(io.in, false.B)
}
regClockA <> io.outA
val regClockB = withClockAndReset (io.clockB, io.resetB) {
RegNext(io.in, false.B)
}
regClockB <> io.outB
}
```
### Utils библиотека
На этом приятные бонусы chisel не заканчиваются. Его создатели потрудились и написали небольшую но весьма полезную библиотеку маленьких, интерфейсов, модулей, функций. Как ни странно на вики нет описания библиотеки, но можно посмотреть чит-листе ссылка на который в самом начале(там два последних раздела)
Интерфейсы:
* `DecoupledIO` — обкновенный частоиспользуемый ready/valid интерфейс.
`DecoupledIO(UInt(32.W))` — будет содержать в себе сигналы:
`val ready = Input(Bool())`
`val valid = Output(Bool())`
`val data = Output(UInt(32.W))`
* `ValidIO` — тоже что и `DecoupledIO` только без `ready`
Модули:
* `Queue` — модуль синхронного FIFO весьма полезная вещь интерфейс выглядит как
`val enq: DecoupledIO[T]` — перевернутый `DecoupledIO`
`val deq: DecoupledIO[T]` — обычный `DecoupledIO`
`val count: UInt` — количество данных в очереди
* `Pipe` — модуль задержки, вставляет n-ое количество регистровых срезов
* `Arbiter` — арбитр на `DecoupledIO` интерфейсах, имеет множество подвидов различающихся по виду арбитража
`val in: Vec[DecoupledIO[T]]` — массив входных интерфейсов
`val out: DecoupledIO[T]`
`val chosen: UInt` — показывает выбранный канал
На сколько можно понять из обсуждения на github — в глобальных планах есть существенное расширение этой библиотеки модули: типа асинхронного FIFO, LSFSR, делителей частоты, шаблонов PLL для FPGA; различные интерфейсы; контроллеры под них и многое другое.
### Chisel io-teseters
Следует упомянут и возможность тестирования в chisel, на данный момент сложилось два способа тестирования это:
* `peekPokeTesters` — чисто симулиционные тесты которые проверяют логику вашего дизайна
* `hardwareIOTeseters` — это уже интересней, т.к. с помощью этого подхода вы получите cгенерированный teset bench с тестами которые вы написали на chisel, и при наличае verilator даже получите временную диаграмму.
Но пока, подход к тестированию окончательно не выработан, а обсуждение еще идет. В будущем вероятней всего появится универсальный инструмент, для тестирования и тесты тоже можно будет писать на chisel. Но пока можете посмотреть на то что уже есть и как этим [пользоваться тут](https://github.com/freechipsproject/chisel-testers/wiki).
### Недостатки chisel
Нельзя сказать что chisel — это универсальный инструмент, и что всем стоит на него переходить. Он как и, пожалуй, все проекты на стадии разработки имеет свои недостатки, о которых стоит упомянуть для полноты картины.
Первый и пожалуй самый важный недостаток — это отсутствие асинхронных сбросов. Достаточно весомый, но его можно решить несколькими путями, и один из них это скрипты поверх verilog, которые превращают синхронный reset в асинхронный. Это легко сделать, т.к. все конструкции в генерируемом verilog с `always` достаточно однобразны.
Второй недостаток заключается, по мнению многих в нечитаемости сгенерированого verilog и как следствие усложнение отладки. Но давайте взглянем на сгенерированый код из примера с простым счетчиком
**generated verilog**
```
`ifdef RANDOMIZE_GARBAGE_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_INVALID_ASSIGN
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_REG_INIT
`define RANDOMIZE
`endif
`ifdef RANDOMIZE_MEM_INIT
`define RANDOMIZE
`endif
module SimpleCounter(
input clock,
input reset,
input io_enable,
output [7:0] io_out
);
reg [7:0] counter;
reg [31:0] _RAND_0;
wire [8:0] _T_7;
wire [7:0] _T_8;
wire [7:0] _GEN_0;
assign _T_7 = counter + 8'h1;
assign _T_8 = _T_7[7:0];
assign _GEN_0 = io_enable ? _T_8 : counter;
assign io_out = counter;
`ifdef RANDOMIZE
integer initvar;
initial begin
`ifndef verilator
#0.002 begin end
`endif
`ifdef RANDOMIZE_REG_INIT
_RAND_0 = {1{$random}};
counter = _RAND_0[7:0];
`endif // RANDOMIZE_REG_INIT
end
`endif // RANDOMIZE
always @(posedge clock) begin
if (reset) begin
counter <= 8'h0;
end else begin
if (io_enable) begin
counter <= _T_8;
end
end
end
endmodule
```
На первый взгляд сгенерированый verilog может оттолкнуть, даже в средних размеров дизайне, но давайте немного разберемся.
* RANDOMIZE дефайны — (могут пригодиться при тестировании средствами chisel-testers) — в целом бесполезны, но особо не мешают
* Как видим название нашик портов, и регистра сохранились
* \_GEN\_0 бесполезная для нас переменная, но необходимая firrtl интерпритатору для генерации verilog. На нее тоже не обращаем внимания.
* Остаются \_T\_7 и \_T\_8, вся комбинационная логика в сгенерированом verilog будет представлена пошагово в виде переменных \_T.
Самое главное, что все необходимые для отладки порты, регистры, провода сохраняют свои названия из chisel. И если смотреть не только на verilog но и на chisel, то вскоре процесс отладки пойдет так-же легко, как и с чистым verilog.
### Заключение
В современных реалиях разработка RTL будь то asic или fpga вне академической среды, давно ушла от использования только чистого рукописного verilog кода к тем или иных разновидностей скриптов генерации, будь то маленький скрипт на tcl или целая IDE c кучей возможностей.
Chisel же в свою очередь является логичным развитием языков для разработки и тестирования цифровой логики. Пусть на данном этапе он далек от совершенства, но уже способен предоставить возможности ради которых можно мириться с его недостатками. Важно что проект живой и развивается, и есть большая вероятность что в обозримом будущем таких недостатков станет ну очень мало а функционала ну очень много. | https://habr.com/ru/post/419413/ | null | ru | null |
# Сделай сам: SQL JOIN на Java
Я часто собеседую разработчиков и часто задаю им простой, как кувалда, вопрос — как внутри работает JOIN в SQL? В ответ я обычно слышу [бессвязное мычание](http://feldgendler.livejournal.com/155234.html) про волшебные деревья и индексы, которые быстрее. Когда-то мне казалось, что каждый ~~программист~~ специалист должен знать то, с чем работает. Впоследствии жизнь объяснила мне, что это не так. Но мне все еще не понятно, как можно годами теребить базёнку, даже не догадываясь, а что там у нее «под капотом»?
Давайте проведем ликбез и вместе посмотрим, как же работают эти джойны, и даже сами реализуем парочку алгоритмов.
Постановка задачи
-----------------
Людям, которые утверждают, что много и плотно работали с SQL, я задаю на собеседованиях вот такую задачу.
Есть SQL команда
```
SELECT
left.K,
left.V1,
right.V2
FROM left
JOIN right
ON left.K = right.K;
```
Нужно выполнить то же самое на Java, т.е. реализовать метод
```
List> join(List> left, List> right);
```
Я не прошу прям закодить реализацию, но жду хотя бы устного объяснения алгоритма.
Дополнительно я спрашиваю, что нужно изменить в сигнатуре и реализации, чтобы сделать вид, что мы работаем с индексами.
Давайте сначала разберемся, для чего нам вообще думать об устройстве джойнов?
1. Знать теорию полезно из чисто познавательных соображений.
2. Если вы различаете типы джойнов, то план выполнения запроса, который получается командой EXPLAIN, больше не выглядит для вас как набор непонятных английских слов. Вы можете видеть в плане потенциально медленные места и оптимизировать запрос переписыванием или хинтами.
3. В новомодных аналитических инструментах поверх Hadoop планировщик запросов или малость туповат (см. Cloudera Impala), или его вообще нет (см. Twitter Scalding, Spark RDD). В последнем случае приходится собирать запрос вручную из примитивных операций.
4. ~~Наконец, есть риск, что однажды вы попадете на собеседование ко мне или к другому зануде.~~ Но на самом деле, статья не про собеседования, а про операцию JOIN.
Nested Loops Join
-----------------
Самый базовый алгоритм объединения двух списков сейчас проходят в школах. Суть очень простая — для каждого элемента первого списка пройдемся по всем элементам второго списка; если ключи элементов вдруг оказались равны — запишем совпадение в результирующую таблицу. Для реализации этого алгоритма достаточно двух вложенных циклов, именно поэтому он так и называется.
```
public static List> nestedLoopsJoin(List> left, List> right) {
List> result = new ArrayList<>();
for (Pair leftPair: left) {
for (Pair rightPair: right) {
if (Objects.equals(leftPair.k, rightPair.k)) {
result.add(new Triple<>(leftPair.k, leftPair.v, rightPair.v));
}
}
}
return result;
}
```
Основной плюс этого метода — полное безразличие к входным данным. Алгоритм работает для любых двух таблиц, не требует никаких индексов и перекладываний данных в памяти, а также прост в реализации. На практике это означает, что достаточно просто бежать по диску двумя курсорами и периодически выплёвывать в сокет совпадения.
Однако ж, фатальный минус алгоритма — высокая временная сложность O(N\*M) (квадратичная асимптотика, если вы понимаете, о чем я). Например, для джойна пары небольших таблиц в 100к и 500к записей потребуется сделать аж 100.000 \* 500.000 = 50.000.000.000 (50 млрд) операций сравнения. Запросы с таким джойном будут выполняться невежливо долго, часто именно они — причина беспощадных тормозов кривеньких самописных CMS’ок.
Современные РСУБД используют nested loops join в самых безнадежных случаях, когда не удается применить никакую оптимизацию.
UPD. [zhekappp](https://habrahabr.ru/users/zhekappp/) и [potapuff](https://habrahabr.ru/users/potapuff/) поправляют, что nested loops эффективен для малого числа строк, когда разворачивать какую-либо оптимизацию выйдет дороже, чем просто пробежаться вложенным циклом. Есть класс систем, для которых это актуально.
Hash Join
---------
Если размер одной из таблиц позволяет засунуть ее целиком в память, значит, на ее основе можно сделать [хеш-таблицу](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0) и быстренько искать в ней нужные ключи. Проговорим чуть подробнее.
Проверим размер обоих списков. Возьмем меньший из списков, прочтем его полностью и загрузим в память, построив HashMap. Теперь вернемся к большему списку и пойдем по нему курсором с начала. Для каждого ключа проверим, нет ли такого же в хеш-таблице. Если есть — запишем совпадение в результирующую таблицу.
Временная сложность этого алгоритма падает до линейной O(N+M), но требуется дополнительная память.
```
public static List> hashJoin(List> left, List> right) {
Map hash = new HashMap<>(right.size());
for (Pair rightPair: right) {
hash.put(rightPair.k, rightPair.v);
}
List> result = new ArrayList<>();
for (Pair leftPair: left) {
if (hash.containsKey(leftPair.k)) {
result.add(new Triple<>(leftPair.k, leftPair.v, hash.get(leftPair.k)));
}
}
return result;
}
```
Что важно, во времена динозавров считалось, что в память нужно загрузить правую таблицу, а итерироваться по левой. У нормальных РСУБД сейчас есть статистика cardinality, и они сами определяют порядок джойна, но если по какой-то причине статистика недоступна, то в память грузится именно правая таблица. Это важно помнить при работе с молодыми корявыми инструментами типа Cloudera Impala.
Merge Join
----------
А теперь представим, что данные в обоих списках заранее отсортированы, например, по возрастанию. Так бывает, если у нас были индексы по этим таблицам, или же если мы отсортировали данные на предыдущих стадиях запроса. Как вы наверняка помните, два отсортированных списка можно склеить в один отсортированный за линейное время — именно на этом основан алгоритм [сортировки слиянием](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC). Здесь нам предстоит похожая задача, но вместо того, чтобы склеивать списки, мы будем искать в них общие элементы.
Итак, ставим по курсору в начало обоих списков. Если ключи под курсорами равны, записываем совпадение в результирующую таблицу. Если же нет, смотрим, под каким из курсоров ключ меньше. Двигаем курсор над меньшим ключом на один вперед, тем самым “догоняя” другой курсор.
```
public static , V1, V2> List> mergeJoin(
List> left,
List> right
) {
List> result = new ArrayList<>();
Iterator> leftIter = left.listIterator();
Iterator> rightIter = right.listIterator();
Pair leftPair = leftIter.next();
Pair rightPair = rightIter.next();
while (true) {
int compare = leftPair.k.compareTo(rightPair.k);
if (compare < 0) {
if (leftIter.hasNext()) {
leftPair = leftIter.next();
} else {
break;
}
} else if (compare > 0) {
if (rightIter.hasNext()) {
rightPair = rightIter.next();
} else {
break;
}
} else {
result.add(new Triple<>(leftPair.k, leftPair.v, rightPair.v));
if (leftIter.hasNext() && rightIter.hasNext()) {
leftPair = leftIter.next();
rightPair = rightIter.next();
} else {
break;
}
}
}
return result;
}
```
Если данные отсортированы, то временная сложность алгоритма линейная O(M+N) и не требуется никакой дополнительной памяти. Если же данные не отсортированы, то нужно сначала их отсортировать. Из-за этого временная сложность возрастает до O(M log M + N log N), плюс появляются дополнительные требования к памяти.
Outer Joins
-----------
Вы могли заметить, что написанный выше код имитирует только INNER JOIN, причем рассчитывает, что все ключи в обоих списках уникальные, т.е. встречаются не более, чем по одному разу. Я сделал так специально по двум причинам. Во-первых, так нагляднее — в коде содержится только логика самих джойнов и ничего лишнего. А во-вторых, мне очень хотелось спать. Но тем не менее, давайте хотя бы обсудим, что нужно изменить в коде, чтобы поддержать различные типы джойнов и неуникальные значения ключей.
Первая проблема — неуникальные, т.е. повторяющиеся ключи. Для повторяющихся ключей нужно порождать декартово произведение всех соответствющих им значений.
В Nested Loops Join почему-то это работает сразу.
В Hash Join придется заменить HashMap на MultiHashMap.
Для Merge Join ситуация гораздо более печальная — придется помнить, сколько элементов с одинаковым ключом мы видели.
Работа с неуникальными ключами увеличивает асимптотику до O(N\*m+M\*n), где n и m — среднее записей на ключ в таблицах. В вырожденном случае, когда n=N и m=M, операция превращается в CROSS JOIN.
Вторая проблема — надо следить за ключами, для которых не нашлось пары.
Для Merge Join ключ без пары видно сразу для всех направлений JOIN’а.
Для Hash Join сразу можно увидеть нехватку соответствующих ключей при джойне слева. Для того, чтобы фиксировать непарные ключи справа, придется завести отдельный флаг “есть пара!” для каждого элемента хеш-таблицы. После завершения основного джойна надо будет пройти по всей хеш-таблице и добавить в результат ключи без флага пары.
Для Nested Loops Join ситуация аналогичная, причем все настолько просто, что я даже осилил это закодить:
```
public static List> nestedLoopsJoin(
List> left,
List> right,
JoinType joinType
) {
// Массив для обозначения ключей из правого списка, которым не нашлось пары в левом
BitSet rightMatches = new BitSet(right.size());
List> result = new ArrayList<>();
for (Pair leftPair: left) {
// Флаг для обозначения ключей в левом списке, которым не нашлось пары в правом
boolean match = false;
for (ListIterator> iterator = right.listIterator(); iterator.hasNext(); ) {
Pair rightPair = iterator.next();
if (Objects.equals(leftPair.k, rightPair.k)) {
result.add(new Triple<>(leftPair.k, leftPair.v, rightPair.v));
// Отмечаем пары
match = true;
rightMatches.set(iterator.previousIndex(), true);
}
}
// Заполняем несоответствия в левом списке
if ((joinType == JoinType.LEFT || joinType == JoinType.FULL) && !match) {
result.add(new Triple<>(leftPair.k, leftPair.v, null));
}
}
// Заполняем несоответствия в правом списке
if (joinType == JoinType.RIGHT || joinType == JoinType.FULL) {
for (int i = 0; i < right.size(); ++i) {
if (!rightMatches.get(i)) {
Pair rightPair = right.get(i);
result.add(new Triple<>(rightPair.k, null, rightPair.v));
}
}
}
return result;
}
```
Морализаторское послесловие
---------------------------
Если вы дочитали досюда, значит, статья показалась вам интересной. А значит, вы простите мне небольшую порцию нравоучений.
Я действительно считаю, что знания РСУБД на уровне SQL абсолютно не достаточно, чтобы считать себя профессиональным разработчиком ПО. Профессионал должен знать не только свой код, но и примерное устройство соседей по стеку, т.е. 3rd-party систем, которые он использует — баз данных, фреймворков, сетевых протоколов, файловых систем. Без этого разработчик вырождается до кодера или оператора ЭВМ, и в по настоящему сложных масштабных задачах становится бесполезен.
UPD. Несмотря на это послесловие, статья, на самом деле, про JOIN'ы.
Дополнительные материалы
------------------------
* Роскошная статья про [устройство РСУБД](https://habrahabr.ru/company/mailru/blog/266811/)
* Роскошная книга про [алгоритмы](https://www.ozon.ru/context/detail/id/33769775/). Полезно полистать перед собеседованием.
Disclaimer: вообще-то, я обещал еще одну статью про Scalding, но [предыдущая](https://habrahabr.ru/post/273611/) не вызвала большого интереса у публики. Из-за этого тему решено было сменить. | https://habr.com/ru/post/278087/ | null | ru | null |
# Фронтенд-2019: итоги года
В 2019 году мир фронтенд-разработки, как уже бывало, развивался с головокружительной скоростью. Материал, перевод которого мы сегодня публикуем, посвящён обзору важных событий, новостей и трендов 2019 года.
[](https://habr.com/ru/company/ruvds/blog/481576/)
А [вот](https://habr.com/ru/company/ruvds/blog/433396/), кстати, аналогичный материал, опубликованный нами в 2018 году. Там, в конце, есть раздел прогнозов на 2019 год. На наш взгляд, многие из них оправдались. Не обойдётся без прогнозов и эта статья, но не будем забегать вперёд.
О загрузках популярных фронтенд-фреймворков и библиотек из npm
--------------------------------------------------------------
Библиотека React снова забирает пальму первенства и продолжает расти, а jQuery, как ни странно, попала на второе место. Недалеко от лидеров ушли Angular и Vue. Оба эти фреймворка отличаются мощной базой увлечённых своим делом разработчиков. Фреймворк Svelte в этом году пользовался немалым вниманием общественности, но его внедрение идёт пока не особенно активно.
*Загрузки фронтенд-фреймворков и библиотек из npm ([источник](https://www.npmtrends.com/@angular/core-vs-react-vs-vue-vs-jquery-vs-svelte-vs-backbone-vs-react-native))*
WebAssembly становится четвёртым языком веба, присоединяясь к HTML, CSS и JavaScript
------------------------------------------------------------------------------------
После довольно-таки тихого года технология WebAssembly, в начале декабря, оказалась у всех на слуху. Дело в том, что она официально [рекомендована](https://www.w3.org/2019/12/pressrelease-wasm-rec.html.en) для веб-разработки W3C. W3C (World Wide Web Consortium) — это центральная международная организация, занимающаяся стандартизацией веб-технологий.
Технология WebAssembly, с момента её появления в 2017 году, привлекает к себе всеобщее внимание. Многие ей уже пользуются. В предыдущие годы вышла спецификация WebAssembly 1.0, поддержка этой технологии была интегрирована во все основные браузеры.
Ещё одна новость 2019 года, касающаяся WebAssembly, связана с формированием [Bytecode Alliance](https://bytecodealliance.org/articles/announcing-the-bytecode-alliance). Цель организаций, входящих в альянс, заключается в том, чтобы обеспечить будущее WebAssembly за пределами браузера, совместно работая над реализацией стандартов и предлагая новые стандарты.
Мы всё ещё ждём того момента, когда положение WebAssembly по-настоящему упрочится, когда эта технология будет внедряться массово. Каждое улучшение WebAssembly приближает нас к этому моменту. Заявление W3C — это, безусловно, огромный шаг в направлении легитимизации этой технологии в корпоративном мире. Нам нужно продолжать снижать входные барьеры в мир WebAssembly-программирования, что позволит упростить разработку новых WebAssembly-проектов.
Уровень использования TypeScript стремительно растёт, многие разработчики признаются в любви к этому языку
----------------------------------------------------------------------------------------------------------
2019 можно назвать годом TypeScript. Этот язык не только стал стандартом де-факто в решении задачи типизации JS-кода. Многие разработчики ещё и отдают ему предпочтение перед обычным JavaScript как в личных проектах, так и на работе.
В [исследовании](https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted) StackOverflow, опубликованном в начале этого года, TypeScript, в рейтинге языков, которые больше всего любят разработчики, разделил второе место с Python, уступив лишь Rust. И не будет ничего удивительного, если TypeScript поднимется ещё выше в таком же исследовании, выход результатов которого ожидается в начале 2020.
*Многие разработчики любят TypeScript*
TypeScript буквально захватил мир веб-разработки. Это касается и фронтенда, и бэкенда. Некоторые программисты пытались отмахнуться от TypeScript как от очередного кратковременного веяния. Они думали, что он разделит печальную судьбу Coffeescript. Но TypeScript доказал свою пригодность в решении базовой проблемы JS-разработки. Возникает такое ощущение, что со временем его популярность лишь растёт.
TypeScript даёт веб-разработчикам серьёзные удобства благодаря интеграции со всеми основными редакторами кода. JavaScript-разработчики рассматривают TypeScript как инструмент, применение которого приводит к уменьшению количества ошибок. TypeScript в их глазах — это типизированный код, который читается легче JavaScript-кода. Это — объектные интерфейсы, которые способствуют созданию самодокументирующихся программ.
Если говорить о популярности TypeScript, то стоит отметить хотя бы то, что он в 2019 году обошёл React по количеству загрузок из NPM. У него, кроме того, гораздо больше загрузок, чем у его конкурентов — у таких проектов, как Flow и Reason.
Хотелось бы обратить ваше внимание на то, что TypeScript и React — это совершенно разные технологии, рассчитанные на решение разных задач. Поэтому подобное сравнение — это как сравнение тёплого с мягким. Это — лишь демонстрация популярности TypeScript.
*TypeScript обходит React в NPM*
TypeScript 3.0 вышел в конце 2018 года. В 2019 году он добрался до версии 3.7, куда вошли свежие возможности стандарта ECMAScript, такие, как опциональные цепочки и проверка значений только на `null` и `undefined`. В новой версии TypeScript улучшен и функционал, касающийся работы с типами.
React продолжает лидировать, разработчики увлечены хуками
---------------------------------------------------------
У Vue и Angular есть увлечённые своим делом сообщества пользователей. Vue даже обошёл React по количеству звёзд на GitHub. Но в деле практического использования, будь то личные проекты программистов, или их работа, React уверенно держит первое место.
В конце 2018 года команда React выпустила так называемые хуки. В 2019 хуки буквально захватили мир React. Подавляющее большинство React-разработчиков использует их как основной механизм для управления состоянием компонентов и для работы с событиями их жизненного цикла. В течение года было написано бесчисленное множество статей о хуках, всё чётче вырисовывались паттерны их использования, важнейшие React-пакеты начали предоставлять пользовательские хуки, которые можно применять для работы с этими пакетами.
Хуки дают программисту способ управления состоянием и жизненным циклом функциональных компонентов с использованием простого и лаконичного синтаксиса. Кроме того, React позволяет создавать пользовательские хуки, которые помогают разработчикам писать код, подходящий для многократного использования, помогают создавать логику, которую можно использовать совместно. При этом отпадает необходимость в применении компонентов высшего порядка или свойств рендеринга.
Команда разработчиков React обращает особое внимание на удобство работы программистов и на инструменты, которые помогают трудиться продуктивнее. После громкого появления хуков в React 16.8, по мере того, как библиотека добралась в 2019 году до версии 16.4., остальные нововведения были не столь масштабными.
Можно сказать, что команда разработчиков React после выпуска хуков сосредоточилась на удобстве программистов за счёт создания вспомогательных инструментов. Удобство работы программиста, те ощущения, которые он испытывает, разрабатывая React-приложения, стали главной темой конференции React Conf 2019. Том Оччино, ведущий докладчик конференции и менеджер команды React, сказал, что ощущения разработчика от использования React основаны на трёх идеях: низкий входной барьер, высокая продуктивность, масштабируемость решений. Взглянем на то, что было выпущено (или планировалось выпустить) командой React для поддержки этих идей:
* Новая версия инструментов разработчика React.
* Новый профилировщик производительности.
* Create React App v3.
* Обновления утилиты для тестирования.
* Конкурентный режим (ожидается).
* Система CSS-in-JS, используемая в Facebook (ожидается).
* Прогрессивная/селективная подготовка заранее отрендеренного кода страницы к работе (ожидается).
* Улучшения в ядре React, касающиеся доступности (ожидается).
Есть мнение, что если программисту приятно работается, то у него получится то, что вызовет положительные впечатления у пользователей. В результате вышеописанная инициатива разработчиков React — это выигрыш для всех. [Вот](https://youtu.be/uXEEL9mrkAQ) выступление с React Conf 2019, посвящённое ожидаемым возможностям React, а [вот](https://youtu.be/UxoX2faIgDQ) — ссылка на все выступления с этого мероприятия.
Фреймворк Vue готовится к релизу версии 3, объём его использования растёт
-------------------------------------------------------------------------
Вероятно, пока Vue нельзя назвать самым распространённым фреймворком, но сложно не заметить то, что вокруг него сложилось сообщество, члены которого увлечены своим делом как никто другой. Известно, что Vue взял лучшее от React и Angular, но при этом устроен проще, чем они. Ещё одно важное преимущество Vue заключается в его более сильной открытости, и в том, что его не контролирует какая-нибудь крупная компания вроде Facebook (React — это её детище) или Google (эта компания поддерживает Angular).
Главная новость в мире Vue — это грядущий релиз 3.0. Появление альфа-версии ожидается в конце года. В этом году Vue 2.x получил лишь несколько обновлений, было это ближе к началу года. Дело в том, что все силы разработчиков направлены на выпуск Vue 3.0.
То, что у Vue в этом году было не особенно много релизов, не значит, что с этим фреймворком не происходит ничего интересного. Когда Эван Ю выпустил RFC для третьей версии Vue, в сообществе разгорелись обширные обсуждения, касающиеся изменений. Например, почитать их можно [здесь](https://www.reddit.com/r/vuejs/comments/c319el/vue_3_will_change_vue_in_a_big_way_current_syntax/) и [здесь](https://news.ycombinator.com/item?id=20237568).
Главная проблема, которая беспокоила Vue-разработчиков, заключается в серьёзном изменении API фреймворка. Правда, после возникновения подобной негативной реакции, было сказано, что новые API будут добавляться к старым, и что они будут обратно совместимыми с Vue 2. Многие разработчики заявляют, что если новый релиз Vue будет выглядеть не так, как им хотелось бы, они рассмотрят возможность перехода на Svelte. Люди опасаются того, что изменения Vue сделают этот фреймворк слишком сильно похожим на React. Хотя многие члены сообщества всё ещё обеспокоены будущим фреймворка, возникает такое ощущение, что шум поутих и все просто ждут нового релиза.
В Vue 3, помимо спорного функционала, ожидается появление некоторых новых интересных возможностей и полезных изменений:
* API Composition.
* Изменения в API конфигурирования и монтирования.
* Фрагменты.
* Поддержка технологии Time Slicing (экспериментальная).
* Поддержка нескольких v-model.
* Порталы.
* Новый API пользовательских директив.
* Улучшенная реактивность.
* Переписанная виртуальная DOM.
* Поднятие статических свойств.
* Поддержка API хуков (экспериментальная).
* Оптимизация генерирования слотов (разделение рендеринга для родительских и дочерних компонентов).
* Улучшенная поддержка TypeScript.
Заметным событием в мире Vue стал выход в этом году 4-й версии Vue CLI, где основное внимание уделено обновлению базовых инструментов.
[Вот](https://youtu.be/ANtSWq-zI0s) выступление Эвана Ю о Vue.
Выходят 8 и 9 версии Angular, а также — новый движок компиляции/рендеринга Ivy
------------------------------------------------------------------------------
Философия Angular, когда фреймворк предписывает разработчику определённые схемы действий, помогла этому инструменту набрать большую пользовательскую базу. Angular говорит разработчикам о том, что правильно, а что — нет, но при этом предоставляет все необходимые разработчикам инструменты.
Это устраняет множество поводов для обсуждения того, какие библиотеки и зависимости нужно включать в состав проекта. Надо отметить, что подобные вопросы часто встают в командах, использующих React. Кроме того, Angular-приложения пишут на TypeScript. Так как тот, кто выбирает Angular, вынужден согласиться с тем, что множество решений уже принято за него, этот фреймворк очень нравится различным компаниям. Такое положение дел позволяет разработчикам сосредоточиться на разработке программных продуктов, а не тратить время на размышления о пакетах.
В 2019 вышла 8 версия Angular. В этом же году увидел свет новый движок компиляции/рендеринга Ivy. Самая главная сильная сторона Ivy заключается в том, что благодаря ему уменьшаются размеры бандлов. Но, на самом деле, он приносит в Angular и многие другие полезности. Сейчас, до выхода Angular 9, Ivy — это опциональная возможность. [Здесь](https://blog.angular.io/a-plan-for-version-8-0-and-ivy-b3318dfc19f7) можно почитать подробности том, что нового появилось в Angular 8. Особо же хотелось бы отметить следующее:
* Дифференциальная загрузка современного JavaScript-кода.
* Возможность ознакомиться с технологией Ivy.
* Обеспечение обратной совместимости маршрутизатора Angular.
* Улучшенная сборка веб-воркеров.
* Возможность передавать разработчикам Angular сведения об использовании Angular CLI.
* Обновления зависимостей.
В течение декабря 2019 года команда Angular готовилась к выпуску Angular 9. Похоже, что данная версия фреймворка выйдет либо в конце этого года, либо в начале следующего. Главнейшее новшество Angular 9 заключается в том, что Ivy станет стандартным движком рендеринга. [Вот](https://youtu.be/5wmWtgr7LQ0) видео, просмотрев которого можно узнать подробности об Angular 9.
Теперь на доступность (a11y) и на интернационализацию (i18n) обращают больше внимания, чем раньше
-------------------------------------------------------------------------------------------------
Веб должен быть пространством, открытым для всех людей и пригодным для использования всеми людьми. В результате во фронтенде доступность и интернационализация стали приоритетными задачами. После быстрого развития JavaScript и веб, начавшегося в 2015 году, паттерны и фреймворки наконец начинают стабилизироваться. В наши дни, когда технологии более устойчивы чем несколько лет назад, ситуация позволяет разработчикам уделять больше внимания инструментам для локализации приложений и для повышения уровня их доступности. Это делает веб более гостеприимным местом для всех категорий пользователей. Нам стоит гордиться тем путём в этих направлениях, который мы уже прошли, но многое ещё впереди.
Вот что говорится о доступности на [MDN](https://developer.mozilla.org/ru/docs/Learn/%D0%94%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%BD%D0%BE%D1%81%D1%82%D1%8C/What_is_accessibility): «Доступность — это практика, позволяющая использовать ваши сайты как можно большему числу людей. Мы традиционно думаем об этом как о доступности для людей с ограниченными возможностями, но на самом деле, в это число входят и другие группы пользователей, которые используют мобильные устройства либо имеют медленное сетевое соединение».
А вот что сказано об интернационализации на [w3.org](https://www.w3.org/standards/webdesign/i18n): «Если вы интернационализируете проект — это значит, что вы так проектируете или создаёте свои материалы, приложения, спецификации и прочие подобные ресурсы, что это позволяет им нормально работать для пользователей, принадлежащих к любой культуре, проживающих в любом регионе, говорящих на любом языке, или позволяет легко адаптировать их для таких пользователей».
Возможности ES2019
------------------
ECMAScript (спецификация, на которой основан JavaScript), по-прежнему следует в этом году ежегодному циклу обновления. В стандарте ES2019 появилось немало [новых возможностей](https://levelup.gitconnected.com/javascript-es10-es2019-features-d80c4fca6094). Вот некоторые из них:
* Метод `Object.fromEntries()`.
* Метод `String.trimStart()` и `String.trimEnd()`.
* Улучшенная поддержка unicode в методе `JSON.stringify()`.
* Метод `Array.flat()`.
* Метод `Array.flatMap()`.
* Улучшенная работа с `try/catch`.
* Свойство `description` объектов `Symbol`.
Хотя в ES2019 появились очень интересные новые возможности, в ожидаемом стандарте [ES2020](https://levelup.gitconnected.com/new-features-of-javascript-that-we-can-use-soon-or-now-6199981bd2f) могут появиться такие вещи, которые, вероятно, станут самыми ожидаемыми со времён ES6/ES2015:
* Приватные поля классов.
* Опциональные цепочки — `obj.field?.maybe?.exists`.
* Проверка значений только на `null` и `undefined` — `item ?? 'use this only if item is null/undefined'`.
* Тип данных `BigInt`.
Взрывной рост популярности Flutter
----------------------------------
Flutter вышел через 2 года после React Native, но быстро обрёл популярность. Этот проект очень близок к React Native по количеству звёзд на GitHub. А если популярность проекта будет продолжать расти теми же темпами, то он скоро обгонит React Native. Flutter конкурирует с React и представляет собой ещё один отличный инструмент разработки кросс-платформенных мобильных приложений.
Если учесть то, что Flutter не может похвастаться тем же сообществом дружественных разработчиков, которое есть у React Native и представлено веб-разработчиками, пользующимися React, то такие успехи выглядят особенно впечатляюще. Цель Flutter — быть лучшим фреймворком для кросс-платформенной мобильной разработки.
Вот таблица, в которой React Native и Flutter сопоставлены по некоторым показателям.
| Показатель | React Native | Flutter |
| --- | --- | --- |
| Описание | Фреймворк для разработки нативных приложений с использованием React | Упрощает и ускоряет разработку привлекательных мобильных приложений |
| Звёзды на GitHub | 83 тысячи | 80.5 тысяч |
| Первый выпуск | Март 2015 | Май 2017 |
| Разработчики | Facebook | Google |
| Язык | JavaScript | Dart |
| Производительность приложений | Близка к нативной | Высокая (60 fps) |
| Поддержка IDE | Множество IDE и инструментов с поддержкой JS | Android Studio, VS Code, IntelliJ Idea |
| Поддержка нативных возможностей | Хуже. Зависит от сторонних приложений | Лучше. Есть доступ к базовым возможностям устройств. |
| «Горячее» обновление материалов приложений | Да | Да |
| Графический интерфейс | Используются нативные контроллеры пользовательского интерфейса | Используются особые виджеты, формирующие интерфейс |
| Время вывода проектов на рынок | Медленнее, чем Flutter | Достаточно быстро |
| Уровень повторного использования кода | Более 90% | 50-90% |
| Тестирование | Мобильное устройство или эмулятор | Мобильное устройство или эмулятор |
| Приложения | Tesla, Discord, Instagram | KlasterMe, PostMuse, Reflectly |
Node.js Foundation и JS Foundation объединились, сформировав OpenJS Foundation; Node.js 12 станет LTS-релизом
-------------------------------------------------------------------------------------------------------------
Для того чтобы поддержать экосистему JavaScript и ускорить рост языка, Node.js Foundation и JS Foundation объединились, сформировав [OpenJS Foundation](https://foundation.nodejs.org/announcements/2019/03/12/node-js-foundation-and-js-foundation-merge-to-form-openjs-foundation). Основная идея этого шага заключается в налаживании сотрудничества и в развитии технологий под эгидой нейтральной организации, которая сейчас объединяет 31 опенсорсный проект. В состав этих проектов входят Node, jQuery и Webpack. Эту инициативу можно рассматривать как позитивное движение для всего JS-сообщества. Его поддерживают ведущие технологические компании, такие, как Google, IBM и Microsoft.
12 версия Node.js, вышедшая в этом году, по сложившейся традиции получит долговременную поддержку (LTS, long term support) до апреля 2023 года. Node.js 12 предлагает множество новых возможностей, обновлений безопасности и улучшений производительности. Среди некоторых заметных новшеств можно отметить нативную поддержку конструкций `import/export`, поддержку приватных полей классов, совместимость с движком V8 версии 7.4, поддержку TLS 1.3 и появление дополнительных диагностических средств. [Вот](https://levelup.gitconnected.com/whats-new-in-node-12-e00111ffb83f) материал о новшествах Node.js 12.
Фреймворк Svelte привлекает к себе немало внимания, но используется пока недостаточно широко
--------------------------------------------------------------------------------------------
Фреймворк Svelte смог найти своё место в и без того переполненном мире фронтенд-фреймворков. Однако, как уже говорилось, это пока не привело к широкому использования этого фреймворка. Если выразить суть Svelte в двух словах, то можно сказать, что это «простой, но мощный» инструмент. На сайте проекта отмечается три его ключевых сильных стороны:
* Svelte-разработчики пишут меньше кода.
* Фреймворк не использует виртуальную DOM.
* Он по-настоящему реактивен.
Svelte пытается перенести основную часть работы на этап компиляции, вместо того, чтобы делать что-то в браузере во время работы страницы. Svelte обладает архитектурой, основанной на компонентах, структуры которой компилируются в чистые HTML и JavaScript. Это обещает необходимость в меньших объёмах шаблонного кода. Фреймворк использует идеи реактивного программирования, что позволяет выполнять непосредственные изменения в DOM вместо того, чтобы менять виртуальную DOM, а потом согласовывать изменения с реальной.
Svelte предлагает фронтенд-разработчикам что-то новое и интересное, давая им не больше возможностей, а меньше. В 2020 году интересно будет наблюдать за ростом и развитием Svelte. Хочется надеяться на то, что нам удастся увидеть примеры его использования в крупномасштабных проектах. Это позволит узнать о том, как он выглядит в сравнении со своими более крупными конкурентами — React, Vue и Angular.
Статические сайты по-прежнему актуальны, разработчики внедряют JAMStack
-----------------------------------------------------------------------
Статические сайты доказали, что они являются составной частью веба и не собираются сдавать позиции. В пользу этого утверждения говорит расширение использования фреймворков наподобие Gatsby, быстрый рост хостингов статических сайтов вроде Netlify, бесчисленное множество новых компаний, создающих CMS без пользовательского интерфейса.
Статические сайты комбинируют то, что уже было в вебе, с новыми инструментами и библиотеками. Они позволяют создавать проекты, несравнимые ни с чем другим. Мы можем создавать сайты, используя современные библиотеки наподобие React, а потом можем компилировать их в статические HTML-страницы во время сборки проекта. Так как теперь все страницы хранятся в готовом виде, сервер не тратит ресурсы на заполнение их данными при обращении к нему клиента. Страницы могут быть доставлены клиенту мгновенно, проекты способны в полной мере пользоваться преимуществами CDN-кэширования. Это позволяет держать содержимое сайтов так близко к их пользователям, как это возможно.
При создании статических сайтов весьма популярен паттерн [JAMStack](https://jamstack.org/) (JavaScript, API, Markup). Это — гибридный подход, комбинирующий статические сайты и одностраничные приложения (SPA, single page application). При использовании такого подхода страницы отдаются клиенту в статическом виде, но, оказываясь на клиенте, они ведут себя как SPA, которые используют API и действия пользователя для изменения состояния интерфейса.
PWA растут, увеличиваются объёмы их внедрения
---------------------------------------------
Использование статических сайтов — это один из способов создания чрезвычайно быстрых веб-проектов. Но они подходят не для всех случаев. Ещё один интереснейший вариант — это прогрессивные веб-приложения (PWA, progressive web application). PWA позволяют кэшировать ресурсы в браузере для того, чтобы ускорить время реакции страниц на воздействия пользователя и для обеспечения работоспособности проектов без подключения к интернету. Кроме того, они позволяют пользоваться фоновыми рабочими процессами, которые сближают эти приложения с нативными приложениями, реализуя, например, функционал push-уведомлений.
Кое-кто даже заявляет, что PWA способны заменить обычные мобильные приложения. Как бы там ни было, можно отметить, что нет сомнений в том, что PWA ещё долго будут важной частью наборов технологий, используемых компаниями при разработке своих проектов.
Фронтенд-инструменты становятся по-настоящему качественными
-----------------------------------------------------------
Фронтенд-разработчики уже несколько лет жалуются на «усталость» от JavaScript. Но можно видеть, как эта проблема постепенно уходит благодаря огромным усилиям тех, кто поддерживает опенсорсные проекты.
Раньше, если нужно было создать SPA, требовалось собирать собственный набор зависимостей, пользуясь Bower или NPM. Нужно было разбираться с тем, как транспилировать код с помощью Browserify или Webpack, нужно было с нуля писать Express-сервер и поддерживать свои приложения на плаву в штормах обновлений библиотек.
Сообщество разработчиков страдало от этого всего несколько лет, но теперь мы постепенно добрались до такого уровня развития технологий, когда в нашем распоряжении оказалась чрезвычайно мощная и проработанная экосистема поддержки пакетов. Существуют инструменты, которые помогают абстрагировать наиболее проблемные процессы разработки приложений. Это, например, Create React App, Vue CLI, Angular CLI. Это — проект Gatsby, который помогает создавать статические сайты, это платформа Expo, облегчающая разработку мобильных приложений на React Native. У нас есть Next и Nuxt для решения задач серверного рендеринга, генераторы для создания серверов. GraphQL-серверы можно создавать автоматически с помощью Hasura, можно автоматически генерировать TypeScript-типы с использованием GraphQL Code Generator. Продолжает развиваться Webpack. Короче говоря — в распоряжении современного разработчика есть инструменты, которые позволяют ему решить практически любую встающую перед ним задачу.
Кстати, может уже пора говорить об «усталости от инструментов веб-разработки»?
GraphQL продолжает пользоваться любовью разработчиков, расширяются масштабы внедрения этой технологии
-----------------------------------------------------------------------------------------------------
Технологи GraphQL обещает решить множество проблем, сопутствующих традиционным приложениям, основанным на REST. Разработчики очень скоро буквально влюбились в эту технологию, а теперь это чувство разделяют и технологические компании, которые начали внедрять GraphQL. Например, новейший API GitHub был написан на GraphQL несколько лет назад, в сторону этой технологии двигаются и другие компании.
В основе GraphQL-приложений лежат данные а не конечные точки. Это позволяет клиентам запрашивать именно те данные, которые им нужны и получать от сервера соответствующие JSON-ответы. API GraphQL предоставляют разработчику схему, документирующую все данные и их типы, что делает такие API полностью прозрачными для программиста.
Так как API GraphQL дают в наше распоряжение полностью типизированную схему, эта технология, кроме того, хорошо интегрируется с TypeScript-приложениям. Инструмент наподобие [GraphQL Code Generator](https://graphql-code-generator.com/) может читать запросы в коде клиента, сопоставлять их со схемой и предоставлять нам TypeScript-типы, которые будут использоваться во всём приложении.
Количество загрузок GraphQL за прошедший год более чем удвоилось. Разработчики Apollo начинают позиционировать свой проект как наиболее широко применяемый фреймворк.
*Число загрузок GraphQL за год более чем удвоилось*
Технологии CSS-in-JS набирают популярность
------------------------------------------
Если понаблюдать за развитием веб-разработки, то может возникнуть такое ощущение, что технологии находятся на пути объединения абсолютно всего под знаком JavaScript. Это видно и в сфере внедрения технологий CSS-in-JS, которые используют технику создания стилей, основанную на JavaScript-строках.
Это позволяет работать со стилями и зависимостями, например, совместно использовать их, применяя обычные JavaScript-конструкции `import/export`. Это, кроме того, упрощает создание динамических стилей, так как компоненты, стилизованные средствами CSS-in-JS могут включать значения передаваемых им свойств в строки, описывающие стили. Как уже было сказано, вполне вероятно то, что в видении Facebook CSS-in-JS — это будущее стилизации, поэтому компания может выпустить соответствующую библиотеку собственной разработки.
Ниже показан пример, в котором классический CSS сравнивается с CSS-in-JS. Для обеспечения поддержки динамических стилей в обычном CSS нужно работать в компонентах с именами классов и обновлять их, основываясь на состоянии или на свойствах компонента. Кроме того, для каждой вариации стиля нужен собственный CSS-класс:
```
// JS-файл компонента
const MyComp = ({ isActive }) => {
const className = isActive ? 'active' : 'inactive';
return HI
}
// CSS-файл
.active { color: green; }
.inactive { color: red; }
```
При использовании CSS-in-JS работать с CSS-классами больше не нужно. Достаточно просто передать стилизованному компоненту соответствующее свойство, а компонент обеспечит динамическую стилизацию средствами декларативного синтаксиса. Код получается гораздо более чистым, в нашем распоряжении оказывается более чёткое разделение функционала стилей и React, так как управление динамической стилизацией основано на свойствах, передаваемых компоненту. Теперь код стилизации читается как обычный JS-код, написанный для React:
```
const Header = styled.div`
color: ${({ isActive }) => isActive ? 'green' : 'red'};
`;
const MyComp = ({ isActive }} => (
HI
)
```
Библиотеки [styled-components](https://www.styled-components.com/) и [emotion](https://emotion.sh/) — это два ведущих CSS-in-JS-решения. При этом emotion в 2019 году опередила styled-components по количеству загрузок. Эти две библиотеки значительно обходят, в плане популярности, другие инструменты, реализующие технологию CSS-in-JS. Возникает такое ощущение, что их быстрый рост продолжится.
*Загрузки CSS-in-JS-библиотек*
VS Code лидирует в сфере редакторов кода
----------------------------------------
Разработчики трепетно относятся к своим IDE и редакторам кода. Они, не стесняясь, готовы вступать в споры, доказывая безусловное преимущество их инструментов над всеми остальными. Но современные фронтенд-разработчики, похоже, забыли о спорах. Они, будто сговорившись, поголовно выбирают VS Code. Это — опенсорсный бесплатный редактор, который, благодаря возможности использования плагинов, даёт разработчикам возможность настраивать его именно так, как им того хочется.
Вот данные по использованию текстовых редакторов из [State of JS Survey 2019](https://2019.stateofjs.com/other-tools/).
*VS Code — самый популярный редактор кода*
Webpack 5 входит в стадию бета-версии и приближается к релизу
-------------------------------------------------------------
Webpack стал ключевым звеном практически всех современных цепочек инструментов, используемых в JavaScript-проектах. Это — самое популярное средство для сборки проектов. Webpack продолжает улучшаться, как в плане производительности, так и в плане удобства работы с ним с точки зрения разработчика. В 5 версии Webpack упор делается на следующее:
* Повышение производительности при сборке проектов с использованием постоянного кэширования.
* Улучшение долговременного кэширования с использованием усовершенствованных алгоритмов и хорошо подобранных стандартных параметров.
* Переработка внутренних механизмов без введения изменений, способных нарушить работоспособность проектов, использующих существующие версии Webpack.
Jest переходит с Flow на TypeScript
-----------------------------------
Facebook поддерживает популярную библиотеку для тестирования, которая называется [Jest](https://jestjs.io/). Компания занимается и проектом [Flow](https://flow.org/) — конкурентом TypeScript. Сделав соответствующее громкое заявление в начале 2019 года, компания решила перевести Jest с Flow на TypeScript. Это даёт лишний повод говорить о том, что TypeScript стал стандартным решением для типизации JS-кода. Можно ожидать роста масштабов использования TypeScript как в 2020 году, так и в более отдалённом будущем.
Вышли стабильные версии Chrome 72-78
------------------------------------
Разработка Chrome продолжает идти в быстром темпе. В браузер оперативно добавляются новые возможности, ориентированные как на веб-технологии, так и на поддержку разработчиков. В 2019 вышло 7 стабильных версий Chrome. Сейчас Chrome 79 находится на стадии бета-версии, Chrome 80 представляет собой dev-версию, а Chrome 81 — это canary-версия. [Здесь](https://en.wikipedia.org/wiki/Google_Chrome_version_history) можно найти сведения о том, что нового появилось в Chrome в 2019 году.
Браузер Microsoft Edge переходит на Chromium
--------------------------------------------
Internet Explorer, в своём новейшем воплощении называемый Edge, всегда давал веб-разработчикам поводы для шуток. Правда, работать с этим браузером было очень неудобно, а это уже совсем не смешно. Этот браузер постоянно отставал от конкурентов в плане поддерживаемых возможностей, его существование серьёзно усложняло задачу написания кросс-браузерного кода. Большой удачей для разработчиков стало то, что Microsoft решила [воспользоваться](https://www.pcworld.com/article/3433198/microsoft-edge-in-chromium-goes-beta-and-microsoft-says-its-ready-for-everyday-use.html) опенсорсным проектом Chromium от Google. Эта разработка достигла в середине 2019 года бета-версии.
Facebook выпускает Hermes — JavaScript-парсер для Android, направленный на совершенствование React Native
---------------------------------------------------------------------------------------------------------
Компания Facebook решила, что JavaScript-движок Android недостаточно быстр. Поэтому компания создала собственный движок — [Hermes](https://facebook.github.io/react-native/blog/2019/07/17/hermes). Facebook чрезвычайно заинтересована в успехе React Native. Этот ход показывает то, что компания хочет создать среду, которая позволит React Native максимально эффективно работать на всех платформах.
Прогноз на 2020 год
-------------------
А теперь давайте подумаем о том, что ждёт фронтенд в 2020 году:
* Веб-разработчики продолжат уделять повышенное внимание производительности. Для достижения высокой скорости работы сайтов будут использоваться технологии разделения кода и PWA.
* Технология WebAssembly станет более привычной, появится больше примеров её реального использования.
* GraphQL обойдёт REST, находя использование во всё большем количестве новых проектов и новых компаний, в то время как существующие компании будут продолжать постепенный переход на GraphQL.
* TypeScript станет стандартным выбором для стартапов и новых проектов.
* Начнут появляться реальные приложение, созданные без сервера, основанные на блокчейн-технологиях. Это сделает веб более открытым.
* Технологии CSS-in-JS могут стать, вместо обычного CSS, стандартным средством стилизации.
* «Бескодовые» приложения станут более популярными. В наши дни развиваются технологии искусственного интеллекта, растёт число уровней абстракции. А это значит, что создавать приложения становится всё легче и легче. В 2020 году мы можем увидеть значительный сдвиг в области создания приложений без написания кода.
* Flutter может обойти React Native и стать основным инструментом для разработки кросс-платформенных мобильных приложений.
* Появится больше реальных проектов, основанных на Svelte.
* Мы увидим практическое применение [Deno](https://github.com/denoland/deno) (среды выполнения TypeScript, разработанной создателем Node.js).
* Технологии AR/VR будут развиваться в сфере использования библиотек наподобие [A-Frame](https://aframe.io/), [React VR](https://facebook.github.io/react-vr/) и [Google VR](https://developers.google.com/vr/?hl=en). Произойдут улучшения и в браузерной поддержке AR/VR.
* Во фронтенд-разработке больший вес приобретут технологии контейнеризации (Docker, Kubernetes).
**Уважаемые читатели!** Каким вы видите фронтенд-2020?
[](https://ruvds.com/ru-rub)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/481576/ | null | ru | null |
# Rust с 0 до 80% для JavaScript разработчиков
Эта статья — перевод оригинальной статьи Michael Salim "[Rust from 0 to 80% for JavaScript Developers](https://michaelsalim.co.uk/blog/rust-from-0-to-80-for-js-dev/)"
Также я веду телеграм канал “[Frontend по-флотски](https://t.me/frontend_pasta)”, где рассказываю про интересные вещи из мира разработки интерфейсов.
Вступление
----------
Это список тем, которые помогут вам быстро понять [Rust](https://www.rust-lang.org/), если вы разработчик JavaScript. Есть много учебников, которые начинаются с нуля. Но если вы уже знаете что-то еще, почему бы не сравнить их?
Это различия, на которые я хотел бы сослаться перед тем, как приступить к Rust, вкратце.
#### Предупреждение!
Я очень далек от того, чтобы хорошо разбираться в Rust. Документация по Rust обширна, поэтому, если вам нужны подробности, поищите их в Google. [Эта книга также является хорошей отправной точкой для изучения Rust](https://doc.rust-lang.org/book/title-page.html). Моя цель — перечислить важные вещи, чтобы вы (и я в будущем) могли пропустить общие концепции программирования и сосредоточиться на различиях, основанных на уже известных вам знаниях.
Типы
----
Rust — типизированный язык, поэтому он ближе к TypeScript. У вас будет гораздо лучший опыт, если вы уже знаете TS.
По большей части синтаксис похож (variable\_name: Type). Ура!
### snake\_case
Ага, не обойти.
Что это за символ?
------------------
### 1. Вопросительный знак (?)
Вы можете встретить (?) после вызова функции, например: my\_function()?;.
Нет, это не optional chaning. [Это магия обработки ошибок для функций, которые могут дать сбой (функции с ошибкой)](https://stackoverflow.com/a/42921174/3101690). Вы часто будете видеть это при работе с асинхронными функциями. Подробнее об этом позже.
[Документация](https://rust-lang.github.io/async-book/07_workarounds/02_err_in_async_blocks.html)
2. Восклицательный знак на функциях (!)
---------------------------------------
Пример: `println!("{:?}", my_variable);`
[Это указывает на то, что это макрос](https://doc.rust-lang.org/book/ch19-06-macros.html). В JS нет ничего подобного. Макросы — это способ написания кода, который пишет другой код. Вы можете думать об этом как о пользовательском синтаксическом сахаре. Просто используйте его, если пример функции показывает это.
3. Символ (&)
-------------
Пример: `&my_var`
Это способ получить ссылку. Вы встречали это, если использовали языки низкого уровня, такие как C. Подробнее позже.
Синтаксис
---------
1. Точка с запятой (;) в конце каждой строки обязательна.
2. Исключение: точка с запятой (;) не обязательна в последней строке функции. В данном случае это [сокращение для возврата этой строки](https://doc.rust-lang.org/std/keyword.return.html).
3. [Синтаксис функций немного отличается](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html). Не ахти какое дело.
```
fn foo(num: i32) -> i32 {
3 // See no.2
// or
// return 3;
}
```
4. [Синтаксис декоратора также отличается](https://doc.rust-lang.org/reference/attributes.html). Его также называют атрибутами.
Что это за ключевые слова?
--------------------------
#### struct
Это объект JSON. (Хорошо, может быть, сложнее, но см. документы для этого).
```
type Person = {
firstName: string;
lastName: string;
};
```
```
struct Person {
first_name: String,
last_name: String,
}
```
#### trait
[Интерфейс](https://doc.rust-lang.org/book/ch10-02-traits.html?highlight=trait#traits-as-parameters)
#### impl
[Реализация trait](https://doc.rust-lang.org/book/ch10-02-traits.html). Ближе всего к этому у нас есть классы. Это связь между `trait` и типом. я не использовал его
#### enum
[В некотором смысле очень похоже на enum в Typescript](https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html?highlight=enum#enum-values). Но вы можете хранить в нем данные. Это довольно изящная и довольно важная концепция для понимания асинхронности.
### Console.log
Не так просто, к сожалению. [Больше похоже на printf из других языков](https://doc.rust-lang.org/std/fmt/index.html)
`println!("{:?}", my_variable);`
### Library/Dependencies
Используйте Cargo.toml вместо package.json. [Вам надо будет добавить их вручную](https://github.com/rust-lang/cargo/issues/4) (вместо использования такой команды, как yarn add)
[Документация](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html)
Пример:
```
[dependencies]
chrono = "0.4"
egg-mode = "0.16.0"
```
Импорт
------
[В Rust есть модули](https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html?highlight=module#defining-modules-to-control-scope-and-privacy). Они сильно отличается от JS, но в основном:
Это что-то вроде пространств имен. Вот разбивка по импорту зависимости
`use rocket::serde::{json::Json, Deserialize, Serialize};`
`use` - используется вместо`import`
`rocket` - это название пакета
`::` - доступ к модулю
`serde` - это название модуля
`{json::Json, Deserialize, Serialize}` - штуки, которые нужно импортировать
Еще немного синтаксиса:
`use chrono::prelude::*;`
`use rusqlite::Result;`
### Импортирование из локальных файлов
Лучшее объяснение: <https://doc.rust-lang.org/rust-by-example/mod/split.html>
Используйте `mod` для пути/файла, который вы хотите импортировать, чтобы компилятор включил модуль.
Затем используйте `use` для импорта. Примечание: `mod` также автоматически импортирует его. В этом случае вам понадобится префикс `crate`.
Пример:
```
use crate::your_file_or_module;
```
Примечание: mod.rs — это специальное имя файла, которое действует как `index.js`.
### Const vs let
В JavaScript вы бы использовали **const** большую часть времени, потому что она неизменяемая.
В Rust лучше использовать let. Он не переопределяемый по умолчанию. Если вы хотите, чтобы он был изменяемым, используйте ключевое слово [mut](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html). const зарезервированы для фактических констант (поэтому вы не можете вычислить значение из другой переменной)
```
let immutable_variable = ...;
let mut mutable_variable = ...;
const MY_CONSTANT = "CONSTANT";
```
### Документация библиотек
Если в репозитории Github нет ссылки на страницу документации, вы, вероятно, можете перейти к ней следующим образом:
Асинхронность
-------------
Безусловно, две самые запутанные темы — это **futures** и **ownership**. Я бы порекомендовал прочитать более полную документацию для них. Сначала поговорим о Future.
Future похоже на Promise. В отличие от JS, в Rust есть тип результата promise/future который называется Result. Он также принимает тип ошибки в дженериках (хотелось бы, чтобы JS имел это). Вы также можете использовать Result без future.
Вызов Future
------------
Стандартной библиотеки обычно не хватает, поэтому вам нужно будет импортировать что-то еще (например, bluebird для JS). Вам нужен исполнитель, чтобы управлять Future. Я рекомендую использовать [tokio](https://github.com/tokio-rs/tokio) и читать их документацию.
#### .await чтобы подождать функцию
`async_function().await;` Интересный синтаксис, да? На самом деле он довольно приятный, так как вам не нужно оборачивать его скобками, как в JS.
Управление Result
-----------------
[Это еще один важный момент](https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html). Rust безопасен, поэтому вам нужно будет обработать все ошибки. Да, обязательно все случаи ошибок в отличие от JS!
В `Result enum` есть `Ok` и `Err`. Если Future успешно, оно возвращает `Ok`, иначе `Err`.
Наиболее полный способ обработки обоих случаев:
```
let f = File::open("hello.txt");
let mut f = match f {
Ok(file) => file,
Err(e) => return Err(e),
};
```
В приведенном выше примере используется синтаксис [match](https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html), который тоже хорош.
Но он довольно многословный, поэтому есть 2 распространенных способа сократить его:
1. Используя `.unwrap()`
Пример: `let my_value = async_function().await.unwrap();`
Он получает значение [успеха или кидает ошибку, если Err](https://This%20gets%20the%20success%20value%20and%20panics%20if%20Err)
Используйте этот способ только тогда, когда вы уверены, что это не приведет к ошибке или только в тестовой среде.
2. Используя `?` синтаксис
Это передает ошибку вверх. Таким образом, ваша функция также должна иметь возможность возвращать ошибку (либо Result, либо Option).
[Глянь этот пример и его эквивалент](https://stackoverflow.com/a/42921174/3101690)
### Ownership и References
Слышали о borrow checker? Здесь мне особо нечего сказать. Это самая сложная вещь в этом списке, поскольку она уникальна для Rust. И если вы никогда раньше не работали со ссылками, эта тема может быть немного сложной.
[К счастью, книга о Rust снова спасает положение.](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html)
Заключение
----------
Этот список на самом деле короче, чем я ожидал. Я надеюсь, что это вам поможет. | https://habr.com/ru/post/666246/ | null | ru | null |
# Сетевая безопасность — IPS с использованием BGP
В вопросах именно сетевой безопасности функционально выделяются два компонента:
* IDS - Intrusion Detection System, система обнаружения вторжений, компонент, который обнаруживает сам факт злонамеренного сетевого вторжения. Это может быть выделенная система типа DPI (Deep Packet Inspection), пропускающая через себя трафик, анализатор статистики NetFlow или же эта функция может быть встроена в приложение, ну или реализована как анализатор логов (fail2ban).
* IPS - Intrusion Prevention System, система предотвращения вторжений, компонент, блокирующий злоумышленнику сетевой доступ к атакуемому приложения. Реализована эта система может быть как встроенная в приложение функция, настраиваемый пакетный фильтр на хосте, как фаерволл на периметре защищаемого сегмента сети или же обычный сетевой маршрутизатор с BGP. Вот про этот вариант сегодня и поговорим.
Все маршрутизаторы имеют возможность устанавливать пакетные фильтры - наборы правил, в соответствии с которыми фильтруется проходящий трафик. Эти наборы правил обычно приходится вносить в конфигурацию маршрутизатора в виде ACL (access control list), а затем применять на интерфейсах, что не очень оперативно на самом деле и не очень хорошо поддается автоматизации. Нужно же эти списки распространить по всей сети. Так же следует учитывать, что размеры ACL обычно ограничены возможностями маршрутизатора.
Эти проблемы давно известны, и на самом деле в жизни для оперативного предотвращения вторжений используется чуть-чуть другой подход - блекхолинг (интересно, можно ли сейчас на англоязычных ресурсах применять этот термин?). Для всей провайдерской сети выбирается один "проклятый" адрес, из числа немаршрутизируемых сетей, например, из сети 198.18.0.0/15 или даже 192.0.0.0/24 - 192.0.0.0/32. Далее на каждом роутере в сети маршрут на этот хост заворачивается в Null, а затем маршруты на адреса злоумышленников объявляются в сеть с nexthop как раз 192.0.0.0 ну и, разумеется, с community no-export. Маршруты распространяются по всей сети по протоколу BGP - и готово, трафик НА адреса злоумышленников будет уничтожен на первом же маршрутизаторе.
И вот тут Вы имеете полное право воскликнуть "Ну а что толку? Мне же нужно заблокировать трафик ОТ злоумышленника!". Но толк будет. Даже если не применять опцию unicast reverse path forwarding check, которая "занулит" так же и трафик ОТ злоумышленника, "ломатель" не сможет получать ответы от жертв, что не позволит провести сложные типы атак. Он перестанет быть "ломателем", а будет в лучшем случае DOS-ером.
Если же у Вас стоят маршрутизаторы с поддержкой BGP address family flow, то все концептуально упрощается - эта address family как раз и предназначена для распространения ACL по сети. А в этих ACL можно запретить трафик ОТ адреса злоумышленника и все будет работать самым правильным образом. Но увы, не все это умеют.
Таким образом, для обеспечения IPS нужно просто обеспечить передачу адресов злодеев в виде ACL (или маршрутов) по сети. Это делается легко и непринужденно, если у Вас на сети развернуто решение наподобие Arbor Peakflow SP, и тогда дальше можно не читать.
А вот если нет, если хочется обеспечить такой IPS на основе информации из логов сетевых устройств, nginx, sshd, snort, suricata и т.п., то думаю тут может помочь ban2bgp.
Это приложение продолжает тему полезных мелочей для админа с BGP на Rust ([BGPExplorer](https://habr.com/ru/post/562218)).
ban2bgp позволяет обеспечить временный бан указанных через http rest api адресов в виде анонсов по BGP flow acl и/или blackhole routes. В контрибе есть пример настройки для fail2ban - злодей после попытки взлома Вашего сервера или попыток логинов на сетевые устройства может быть отключен на часик не только от одного устройства, но и от всей Вашей сети.
Для установки проще взять исходники с гитхаба, предполагается что уже есть git и rust.
```
$ git clone https://github.com/wladwm/ban2bgp
$ cd ban2bgp
$ cargo build
```
Настроим BGP route-reflector (считаем что RR имеет адрес 10.0.0.1, наша AS 65535, машина с ban2bgp имеет адрес 10.1.1.1):
```
conf t
ip route 192.0.0.0 255.255.255.255 Null0
router bgp 65535
neighbor 10.1.1.1 remote-as 65535
neighbor 10.1.1.1 update-source Loopback0
neighbor 10.1.1.1 transport connection-mode passive
address-family ipv4
neighbor 10.1.1.1 activate
neighbor 10.1.1.1 route-reflector-client
end
```
Создадим ini с настройками ban2bgp:
```
$ cat > ban2bgp.ini <
```
И запустим
```
$ cargo run
```
Теперь попробуем забанить 198.18.0.1 на час:
```
curl "http://127.0.0.1:8080/api/add?net=198.18.0.1&dur=3600"
```
Проверяем на RR:
```
#show route 198.18.0.1
Routing entry for 198.18.0.1/32
Known via "bgp 65535", distance 200, metric 0, type internal
Routing Descriptor Blocks
192.0.0.0, from 10.1.1.1
```
По истечении времени бана маршрут будет отозван автоматически.
Для отдачи команд ban2bgp с других хостов его http rest api разумеется нужно спроксировать или запустить не на 127.0.0.1.
Параметры ban2bgp.ini:
* httplisten - адрес и порт для запуска http rest api, по умолчанию 0.0.0.0:8080
* listen - необязательный адрес с портом для прослушивания для входящих подключений BGP. По умолчанию 0.0.0.0:179. Разумеется, если порт <1024, то нужно быть рутом.
* nexthop - ipv4 nexthop для блокирующих маршрутов. На всех роутерах нужно статически завернуть в Null.
* nexthop6 - ipv6 nexthop для блокирующих маршрутов. На всех роутерах нужно статически завернуть в Null.
* communities - разделенный пробелами список community для маршрутов.
* peers - разделенный запятыми список пиров BGP, формат пира AS.
* duration - длительность бана по умолчанию в секундах.
* skiplist - разделенный запятыми список сетей, которые банить нельзя, защита от ошибок.
Список эндпоинтов http rest api:
* /api/add?net=198.18.0.0/32&dur=3600 добавить бан, net - ipv4/ipv6 маршрут для добавления, dur - время бана в секундах
* /api/remove?net=198.18.0.0/32 удалить бан
* /api/json блочная операция, в POST нужно отправить JSON со списком операций, например: {"add":{"duration":86400,"nets":["33.3.3.3"]},"remove":["11.1.1.1","22.2.2.2"]}
* /api/ping Проверка доступности, отвечает "pong"
* /api/dumprib Возвращает список блокируемых адресов | https://habr.com/ru/post/568336/ | null | ru | null |
# Светодиодная матрица: управляем домашним уютом с помощью голоса
Сейчас стало достаточно модно украшать свои дома с помощью светодиодов. Обычной светодиодной лентой, даже с голосовым управлением, уже сложно удивить кого-либо. Но очень часто забывают, что, расположив светодиоды в виде квадрата или прямоугольника, можно создать что-то похожее на многопиксельный экран. С его помощью можно оживить обстановку в помещении, например отображать на нём прогноз погоды или просто весёлые картинки...
Сегодня и мы попробуем сделать что-то такое, а также добавим управление голосом с помощью виртуальных ассистентов Салют.
Что понадобится?
----------------
* Контролер ESP32 – на самом деле, будет достаточно любого контроллера с возможностью подключения к интернету: это может быть и ESP8266, и обычная Arduino с подключенным Ethernet-шилдом. Код для платформ может отличаться, обратите на это внимание. *Примечание: весь код приведённый в статье тестировался на ESP32.*
* RGB – светодиодная матрица на основе адресных светодиодов WS2812B. Мы будем использовать матрицу 8x8, но не стоит ограничивать свою фантазию. Важно: для питания светодиодов напряжения контроллера не будет хватать, так что позаботьтесь о блоке питания на 5 вольт.
* Программа [Blynk](https://blynk.io/) – это платформа для разработки IoT-устройств. Понадобится установить приложение на ваш мобильный телефон.
* [Arduino IDE](https://www.arduino.cc/en/software) – среда разработки ПО для микроконтроллеров на C-подобном языке программирования.
* [SmartApp Code](https://smartapp-code.sberdevices.ru/) – среда для разработки смартапов (навыков для виртуальных ассистентов Салют).
Часть первая. Hardware
----------------------
Подключим нашу светодиодную матрицу к контроллеру и блоку питания. Важно, что **земля** должна быть общая и у контроллера, и у матрицы, а вот питание на контроллер можно подавать отдельно. Например, через USB.
На данной схеме приведён пример подключения. Чёрные провода – это “земля”, красные – “питание”, а синий – для управления матрицей. Провода, выходящие за пределы макетной доски, подключаются к блоку питания. На матрице расположены три пина: **DIN**, **VIN** и **GND**. Первый необходим для управления матрицей и подключается к одному из пинов контроллера (я подключил к 26-му), второй и третий это питание – **плюс** и **минус**.
Часть вторая. Настройка Blynk
-----------------------------
После установки приложения Blynk на телефон и регистрации необходимо создать новый проект. Назовём его **Гирлянда**, выберем в качестве девайса **ESP32 Dev Board**, тип подключения – **Wi-Fi.**
 Проект в Blynk – это поле, на которое можно размещать различные виджеты, позволяющие общаться (отправлять и получать данные) с нашим девайсом. Для начала добавим на наше поле виджет, отвечающий за управление цветом – **zeRGBa** .
После добавления виджета на поле настроим его. Для того, чтобы перейти в меню настройки виджета, достаточно нажать на него.
1. Мы хотим, чтобы значение цвета передавалось в одной переменной, для этого поставим тумблер в положении **MEGRE**.
2. Укажем виртуальный пин, с которым будет связан этот виджет – **V0**.
3. В формате RGB значение каждого из цветовых каналов варьируется от 0 до 255, так что изменим максимальные значения с дефолтного 1023 на 255 на каждом из каналов.
Но с помощью этого виджета мы сможем управлять только цветом, а хотелось бы ещё включать и выключать режимы мигания и смены изображения. Для включения и выключения режима мигания создадим кнопку и привяжем её к виртуальному пину – **V1**. Кнопка – бинарная сущность, она может отправлять либо 0, либо 1.
Добавим ещё немного функций нашему девайсу. Будем хранить в памяти несколько изображений и переключаться между ними. Для этого добавим ещё один виджет – слайдер. В статье ограничимся только двумя изображениями, но не ограничивайте свою фантазию. (Кстати, матрицы могут быть не только 8x8.)
В текущей реализации все картинки хранятся на устройстве, в коде, так что нам нужно будет отправлять только её номер. Поскольку количество картинок может меняться, будем использовать слайдер, указав в качестве значений необходимый нам диапазон картинок. У нас их будет всего две – сердечко и смайлик – и номера будут соответственно 1 и 2. Слайдер также необходимо соединить с виртуальным пином, **V2**.
При создании проекта вам на почту пришёл **AUTH TOKEN**, он нам будет очень нужен и при программировании микроконтроллера, и при создании навыка для виртуальных ассистентов Салют. Его также всегда можно посмотреть в настройках проекта, для этого достаточно нажать на символ гайки.
Часть третья. Программирование микроконтроллера
-----------------------------------------------
Перед тем, как непосредственно программировать, рассмотрим, как вообще можно создавать изображение на матрице. Несмотря на то, что я постоянно упоминаю слово "матрица", привычной для программистов двумерной индексацией здесь и не пахнет. Дело в том, что хотя плата и выглядит квадратной, по своей схеме это просто светодиодная лента с вот такой нумерацией светодиодов:
Один из подходов, используемый для "рисования" – это “закрашивание” светодиодов с конкретным индексом. Таким образом, для рисунка сердечка нам понадобится закрасить эти светодиоды:
Это достаточно удобно: нам нужно хранить только номера, а цвет может быть любым. Но если мы захотим сделать изображение с использованием разных цветов, например такое, как на превью статьи:
то нам придётся хранить несколько массивов – по одному для каждого цвета.
Теперь перейдём в Arduino IDE и запрограммируем наш контроллер. *Описывать процесс настройки Arduino IDE для работы с ESP32 – слишком долго и скучно, кроме того, эту информацию легко найти в сети, например* [*здесь*](https://espsmart.ru/nastrojka-arduino-ide-dlja-raboty-s-esp32.html).
Разберём непосредственно код:
```
#include
#include
#include
#include
#define PIN 26
#define NUMPIXELS 64
// Флаг показывающий режим работы - 0 - свечение, 1 - мигание
int flag = 0;
// Флаг показывающий состояние светодиодов - 0 - горят, 1 - выключены
int neopixel\_status = 0;
// таймер
unsigned long timer = 0;
// флаг показывающий, какую картинку включать
int image = 1;
// Инициализация светодиодной ленты
Adafruit\_NeoPixel pixels = Adafruit\_NeoPixel(NUMPIXELS, PIN, NEO\_GRB + NEO\_KHZ800);
// AUTH TOKEN из приложения Blynk
char auth[] = "";
// Данные для подклчения к Wi-Fi сети
char ssid[] = "";
char pass[] = "";
// Глобальные переменные, отвечающие за цвет
int R = 100, G = 100, B = 100;
// Функция, окрашивающаяя всю матрицу в один цвет
void color(int R, int G, int B) {
for (int i = 0; i < NUMPIXELS; i++) pixels.setPixelColor(i, pixels.Color(R, G, B));
pixels.show();
}
// Функция по отрисовке разноцветного смайлика
void draw\_smile() {
color(0, 0, 0);
int circle[] = {2, 3, 4, 5, 9, 14, 16, 23, 24, 31, 32, 39, 40, 47, 49, 54, 58, 59, 60, 61};
int eyes[] = {18, 21};
int mouth[] = {42, 45, 51, 52};
for (int i = 0; i < 20; i++) {
pixels.setPixelColor(circle[i], pixels.Color(0, 50, 150));
}
for (int i = 0; i < 2; i++) {
pixels.setPixelColor(eyes[i], pixels.Color(0, 150, 50));
}
for (int i = 0; i < 4; i++) {
pixels.setPixelColor(mouth[i], pixels.Color(150, 0, 0));
}
pixels.show();
}
// Функция по отрисовке сердечка заданного цвета
void draw\_heart(int R, int G, int B) {
color(0, 0, 0);
int heart[] = {9, 10, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 41, 42, 43, 44, 45, 46, 50, 51, 52, 53, 59, 60};
for (int i = 0; i < 40; i++) {
pixels.setPixelColor(heart[i], pixels.Color(R, G, B));
}
pixels.show();
}
// Обработчик виртуального пина V2. Изменение положения слайдера - меняет изображения
BLYNK\_WRITE(V2)
{
image = param.asInt();
select\_image(image);
}
// Обработчик виртуального пина V1. В переменную флаг записывается положение кнопки
BLYNK\_WRITE(V1)
{
flag = param.asInt();
}
/\* Обработчик виртуального пина V0. В соответствующие переменные, отвечающие за составление цвета, записываются полученные значение, а затем отрисовывается картинка.
\*/
BLYNK\_WRITE(V0)
{
R = param[0].asInt();
G = param[1].asInt();
B = param[2].asInt();
select\_image(image);
}
// Функция отрисовывающая картинку, в зависимости от номера
void select\_image(int type) {
switch (type) {
case 1:
draw\_heart(R, G, B);
break;
case 2:
draw\_smile();
break;
};
}
void setup() {
Blynk.begin(auth, ssid, pass); // Подключение к Blynk-серверу
pixels.begin(); // Инициализация светодиодов
select\_image(image); // отображение значения по умолчанию (белое сердечко)
}
void loop() {
Blynk.run();
if (flag != 0) {
if (timer == 0) {
if (neopixel\_status == 0) {
neopixel\_status = 1;
color(0, 0, 0);
timer = millis();
} else {
neopixel\_status = 0;
select\_image(image);
timer = millis();
}
} else if (millis() - timer > 1000) {
if (neopixel\_status == 0) {
neopixel\_status = 1;
color(0, 0, 0);
timer = millis();
} else {
neopixel\_status = 0;
select\_image(image);
timer = millis();
}
}
}
}
```
Сначала подключим необходимые нам библиотеки – для работы с Wi-Fi, Blynk и светодиодной лентой ([*Adafruit\_NeoPixel*](https://github.com/adafruit/Adafruit_NeoPixel)). Затем зададим константы: количество светодиодов, пин, к которому подключена лента, и период срабатывания таймера (в миллисекундах).
После этого проинициализируем светодиодную ленту и заполним необходимые данные для подключения к Blynk: SSID и пароль от Wi-Fi, а также AUTH TOKEN.
У нас будет использоваться несколько функций:
* `void color(int R, int G, int B)` – окрашивает все светодиоды в матрице в заданный цвет. По своей сути это своеобразная "заливка";
* `void draw_smile()` – рисует разноцветный смайлик заранее заданными цветами. У нас есть три массива, каждый из которых отвечает за соответствующую часть смайлика, то есть за один цвет; void draw\_heart(int R, int G, int B) – рисует сердце, заданного цвета;
* `void select_image(int type)` – в зависимости от входного параметра выбирает, какое изображение отрисовывать.
Используя конструкцию BLYNK\_WRITE, мы опишем, что будет происходить, когда мы отправляем данные на тот или другой виртуальный пин (с помощью нашего приложения).
Поскольку распараллеливание задач на микроконтроллерах представляет собой довольно сложную задачу, мы сымитируем работу параллельного потока с помощью нескольких флагов. Это происходит в функции `loop`.
Если вы всё сделали правильно, то уже сейчас вы можете управлять своим устройством с помощью мобильного приложения Blynk. Но самое интересное ещё впереди!
Часть четвёртая. Голосовое управление
-------------------------------------
Для того, чтобы не открывать каждый раз приложение на телефоне, а использовать все преимущества голосового управления, создадим Chat App.
Chat App — это простой тип смартапа, который можно создать даже без навыков программирования. Он представляет собой диалоговое приложение между пользователем и виртуальным ассистентом, в котором пользователь отправляет запрос, а ассистент возвращает ответ. Для создания Chat App-ов будем использовать среду SmartApp Code, подробную документацию к которой можно найти [тут](https://developer.sberdevices.ru/docs/ru/developer_tools/ide/smartappcode_description_and_guide).
Для начала поймём, что мы хотим от нашего приложения. В нашем Chat App будут доступны следующие команды:
* выбор картинки;
* выбор цвета для картинки;
* включение и отключение режима мигания;
* полное выключение дисплея.
Чтобы обрабатывать сообщения пользователя в SmartApp Code, создадим интенты и сущности.
**Интент** — это намерение, которую пользователь формулирует в конкретной реплике. Например, фразы: “включи”, “зажги свет” и подобные для умных устройств или "какая сегодня погода?" при общении с ассистентом.
**Сущность** — это конкретное значение, которое может содержаться в запросе пользователя.
Например, в запросе пользователя “включи красный свет” “включи” – это намерение, а “красный” – сущность, отвечающая за цвет.
У нас будет два типа сущностей:
* Цвет – `color`, который в качестве значения будет отправлять массив, содержащий значения цвета в RGB-формате.
* Изображение – `image`, который в качестве значения будет отправлять порядковый номер изображения, что соответствует значению отправляемому с помощью слайдера.
Откроем SmartApp Code, создадим новый проект и в нём добавим необходимые нам сущности. Добавим сущность `color` и заполним справочник. В качестве значений для каждого из элементов необходимо указать список в формате ["R", "G", "B"]. Например, для красного цвета – ["255", "0","0"]. Это аналог значений, отправляемых с нашего **zeRGBa** в приложении.
Теперь нужно создать интенты. В качестве примера рассмотрим интент выбора цвета: `/EnableColor`.
Для корректной работы интента будем использовать так называемый "слотфиллинг". То есть сущности, которые будут извлекаться из фразы пользователя, будут помещаться в специальные поля – слоты.
Но слотфилинг нужен далеко не всегда. Очень часто интент можно задать просто набором фраз. Например, интент отвечающий за выключение – `/Off`.
Все интенты и сущности будут доступны в репозитории, ссылка на который будет в самом конце статьи. Подробную инструкцию по разворачиванию проекта можно найти [тут](https://developer.sberdevices.ru/docs/ru/developer_tools/flow/smartapp_settings/project_export_import).
После того, как мы создадим все интенты и сущности, нам необходимо создать сценарий, в котором и будет производиться взаимодействие между нашим приложением и устройством. Одной из причин выбора Blynk стало API, которое они предоставляют. Так что всё, что нам нужно, это отправлять запрос. Напишем небольшую функцию на js:
```
function set_pin_value(pin, value) {
var context = $jsapi.context();
var options = {
dataType: "json",
headers: {
"Content-Type": "application/json",
},
body: value
};
var response = $http.put("http://blynk-cloud.com/" + context.injector.TOKEN + "/update/" + pin, options);
}
```
Давайте разберёмся, что в ней происходит. Кажется, что всё стандартно, за исключением какого-то `context`, внутри которого лежит какой-то `injector`, из которого мы и достаём нужный нам TOKEN (это всё тот же токен, который мы получили в blynk). Где же лежит этот `injector`? А задаётся он, внутри автоматически создаваемого файла `chatbot.yaml`. Необходимо лишь добавить в конец этого файла строки:
```
injector:
TOKEN: YOUR_BLINK_TOKEN
```
Так, с функцией разобрались, но теперь нужно её где-то разместить, а затем и вызвать. В SmartApp Code, во вкладке "Сценарии", можно создать папку js, а в ней – файл blynk.js, в который и нужно поместить нашу функцию.
Но мало её создать, нужно где-то её вызывать. Для этого открываем файл сценария main.sc и начинаем создавать состояния:
```
require: zenflow.sc
module = sys.zfl-common
require: slotfilling/slotFilling.sc
module = sys.zb-common
require: js/blynk.js
theme: /
state: EnableColor
intent!: /EnableColor
script:
set_pin_value("V0",$parseTree._color);
a: Готово
state: Blink
intent!: /Blink
script:
set_pin_value("V1",["1"]);
a: Готово
state: StopBlink
intent!: /StopBlink
script:
set_pin_value("V1",["0"]);
a: Готово
state: Off
intent!: /Off
script:
set_pin_value("V1",["0"]);
set_pin_value("V0",["0","0","0"]);
a: Готово
state: ChangeImage
intent!: /ChangeImage
script:
set_pin_value("V2",[$parseTree._image]);
a: Готово
state: Fallback
event!: noMatch
a: Вы сказали: {{$parseTree.text}}
```
Рассмотрим для примера какой-нибудь стейт, например – смену цвета:
```
state: EnableColor
intent!: /EnableColor
script:
set_pin_value("V0",$parseTree._color);
if ($parseTree._image == 1){
set_pin_value("V2",[$parseTree._image])
}
a: Готово
```
В том случае, если срабатывает интент смены цвета, мы отправляем на виртуальный пин `V2` значение, которое попало в отвечающий за цвета слот (аналог модуля zeRGBa в приложении Blynk).
*На что важно обратить внимание*: когда мы создавали интенты, мы указывали переменные, в которые попадут извлечённые нами сущности. Чтобы получить эти значения в коде, мы должны обратиться к объекту $parseTree и запросить переменную с использованием нижнего подчёркивания перед названием. Например, $parseTree.\_color.
Давайте соберём наш навык и протестируем его с помощью тестового виджета внутри SmartApp Code. Для этого необходимо нажать на кнопку **Собрать**, а затем запустить тестовый виджет, нажав на зелёную стрелку. Напишем что-нибудь в поле для ввода. Например: `включи синее сердце`.
Осталось опубликовать ваше приложение, если вы хотите, чтобы им могли воспользоваться ваши друзья. После прохождения модерации и публикации оно появится в каталоге приложений на [устройствах Sber](https://sberdevices.ru/). Если девайсов под рукой нет, можно запустить приложение на смартфоне – в [Сбер Салют](https://sberdevices.ru/app/). Для этого необходимо просто создать черновик в [SmartMarket Studio](https://developers.sber.ru/studio/) и указать в качестве вебхука – вебхук из SmartApp Code. Его можно найти в разделе *Публикации*.
Заключение
----------
Это был пример несложного проекта, с помощью которого можно сделать первые шаги в разработке собственных умных устройств с использованием инструментов SmartApp Code. Этим, конечно, возможности платформы SmartMarket не ограничиваются, подробнее о возможностях разработки можно узнать [здесь](https://smartmarket.sber.ru/smartmarket/dev/). А исходный код для навыка и для микроконтроллера можно найти в [моём репозитории](https://github.com/AviPaperno/SberMatrix). | https://habr.com/ru/post/573628/ | null | ru | null |
# Автономный способ обхода DPI и эффективный способ обхода блокировок сайтов по IP-адресу
Провайдеры Российской Федерации, в большинстве своем, применяют системы глубокого анализа трафика (DPI, Deep Packet Inspection) для блокировки сайтов, внесенных в реестр запрещенных. Не существует единого стандарта на DPI, есть большое количество реализации от разных поставщиков DPI-решений, отличающихся по типу подключения и типу работы.
Существует два распространенных типа подключения DPI: пассивный и активный.
Пассивный DPI
-------------
Пассивный DPI — DPI, подключенный в провайдерскую сеть параллельно (не в разрез) либо через пассивный оптический сплиттер, либо с использованием зеркалирования исходящего от пользователей трафика. Такое подключение не замедляет скорость работы сети провайдера в случае недостаточной производительности DPI, из-за чего применяется у крупных провайдеров. DPI с таким типом подключения технически может только выявлять попытку запроса запрещенного контента, но не пресекать ее. Чтобы обойти это ограничение и заблокировать доступ на запрещенный сайт, DPI отправляет пользователю, запрашивающему заблокированный URL, специально сформированный HTTP-пакет с перенаправлением на страницу-заглушку провайдера, словно такой ответ прислал сам запрашиваемый ресурс (подделывается IP-адрес отправителя и TCP sequence). Из-за того, что DPI физически расположен ближе к пользователю, чем запрашиваемый сайт, подделанный ответ доходит до устройства пользователя быстрее, чем настоящий ответ от сайта.
### Выявляем и блокируем пакеты пассивного DPI
Поддельные пакеты, формируемые DPI, легко обнаружить анализатором трафика, например, Wireshark.
Пробуем зайти на заблокированный сайт:
Мы видим, что сначала приходит пакет от DPI, с HTTP-перенаправлением кодом 302, а затем настоящий ответ от сайта. Ответ от сайта расценивается как ретрансмиссия и отбрасывается операционной системой. Браузер переходит по ссылке, указанной в ответе DPI, и мы видим страницу блокировки.
Рассмотрим пакет от DPI подробнее:
```
HTTP/1.1 302 Found
Connection: close
Location: http://warning.rt.ru/?id=17&st=0&dt=195.82.146.214&rs=http%3A%2F%2Frutracker.org%2F
```
В ответе DPI не устанавливается флаг «Don't Fragment», и в поле Identification указано 1. Серверы в интернете обычно устанавливают бит «Don't Fragment», и пакеты без этого бита встречаются нечасто. Мы можем использовать это в качестве отличительной особенности пакетов от DPI, вместе с тем фактом, что такие пакеты всегда содержат HTTP-перенаправление кодом 302, и написать правило iptables, блокирующее их:
```
# iptables -A FORWARD -p tcp --sport 80 -m u32 --u32 "0x4=0x10000 && 0x60=0x7761726e && 0x64=0x696e672e && 0x68=0x72742e72" -m comment --comment "Rostelecom HTTP" -j DROP
```
Что это такое? Модуль u32 iptables позволяет выполнять битовые операции и операции сравнения над 4-байтовыми данными в пакете. По смещению 0x4 хранится 2-байтное поле Indentification, сразу за ним идут 1-байтные поля Flags и Fragment Offset.
Начиная со смещения 0x60 расположен домен перенаправления (HTTP-заголовок Location).
Если Identification = 1, Flags = 0, Fragment Offset = 0, 0x60 = «warn», 0x64 = «ing.», 0x68 = «rt.ru», то отбрасываем пакет, и получаем настоящий ответ от сайта.
В случае с HTTPS-сайтами, DPI присылает TCP Reset-пакет, тоже с Identification = 1 и Flags = 0.
Активный DPI
------------
Активный DPI — DPI, подключенный в сеть провайдера привычным образом, как и любое другое сетевое устройство. Провайдер настраивает маршрутизацию так, чтобы DPI получал трафик от пользователей к заблокированным IP-адресам или доменам, а DPI уже принимает решение о пропуске или блокировке трафика. Активный DPI может проверять как исходящий, так и входящий трафик, однако, если провайдер применяет DPI только для блокирования сайтов из реестра, чаще всего его настраивают на проверку только исходящего трафика.
Системы DPI разработаны таким образом, чтобы обрабатывать трафик с максимально возможной скоростью, исследуя только самые популярные и игнорируя нетипичные запросы, даже если они полностью соответствуют стандарту.
### Изучаем стандарт HTTP
Типичные HTTP-запросы в упрощенном виде выглядят следующим образом:
```
GET / HTTP/1.1
Host: habrahabr.ru
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/50.0
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
```
Запрос начинается с HTTP-метода, затем следует один пробел, после него указывается путь, затем еще один пробел, и заканчивается строка протоколом и переносом строки CRLF.
Заголовки начинаются с большой буквы, после двоеточия ставится символ пробела.
Давайте заглянем в последнюю версию стандарта HTTP/1.1 от 2014 года. Согласно RFC 7230, HTTP-заголовки не зависят от регистра символов, а после двоеточия может стоять произвольное количество пробелов (или не быть их вовсе).
```
Each header field consists of a case-insensitive field name followed
by a colon (":"), optional leading whitespace, the field value, and
optional trailing whitespace.
header-field = field-name ":" OWS field-value OWS
field-name = token
field-value = *( field-content / obs-fold )
field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
field-vchar = VCHAR / obs-text
obs-fold = CRLF 1*( SP / HTAB )
; obsolete line folding
```
OWS — опциональный один или несколько символов пробела или табуляции, SP — одинарный символ пробела, HTAB — табуляция, CRLF — перенос строки и возврат каретки (\r\n).
Это значит, что запрос ниже полностью соответствует стандарту, его должны принять многие веб-серверы, придерживающиеся стандарта:
```
GET / HTTP/1.1
hoSt:habrahabr.ru
user-agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/50.0
Accept-Encoding: gzip, deflate, br
coNNecTion: keep-alive ← здесь символ табуляции между двоеточием и значением
```
На деле же, многие веб-серверы не любят символ табуляции в качестве разделителя, хотя подавляющее большинство серверов нормально обрабатывает и отсутствие пробелов между двоеточием в заголовках, и множество пробелов.
Старый стандарт, RFC 2616, рекомендует снисходительно парсить запросы и ответы сломанных веб-северов и клиентов, и корректно обрабатывать произвольное количество пробелов в самой первой строке HTTP-запросов и ответов в тех местах, где требуется только один:
> Clients SHOULD be tolerant in parsing the Status-Line and servers tolerant when parsing the Request-Line. In particular, they SHOULD accept any amount of SP or HT characters between fields, even though only a single SP is required.
Этой рекомендации придерживаются далеко не все веб-серверы. Из-за двух пробелов между методом и путем ломаются некоторые сайты.
### Спускаемся на уровень TCP
Соединение TCP начинается с SYN-запроса и SYN/ACK-ответа. В запросе клиент, среди прочей информации, указывает размер TCP-окна (TCP Window Size) — количество байт, которые он готов принимать без подтверждения передачи. Сервер тоже указывает это значение. В интернете используется значение MTU 1500, что позволяет отправить до 1460 байтов данных в одном TCP-пакете.
Если сервер указывает размер TCP-окна менее 1460, клиент отправит в первом пакете данных столько, сколько указано в этом параметре.
Если сервер пришлет TCP Window Size = 2 в SYN/ACK-пакете (или мы его изменим на это значение на стороне клиента), то браузер отправит HTTP-запрос двумя пакетами:
Пакет 1:
```
GE
```
Пакет 2:
```
T / HTTP/1.1
Host: habrahabr.ru
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/50.0
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
```
### Используем особенности HTTP и TCP для обхода активного DPI
Многие решения DPI ожидают заголовки только в стандартном виде.
Для блокировки сайтов по домену или URI, они ищут строку "**Host:** " в теле запроса. Стоит заменить заголовок «Host» на «hoSt» или убрать пробел после двоеточия, и перед вами открывается запрошенный сайт.
Не все DPI можно обмануть таким простым трюком. DPI некоторых провайдеров корректно анализируют HTTP-заголовки в соответствии со стандартом, но не умеют собирать TCP-поток из нескольких пакетов. Для таких DPI подойдет «фрагментирование» пакета, путем искусственного уменьшения TCP Window Size.
В настоящий момент, в РФ DPI устанавливают и у конечных провайдеров, и на каналах транзитного трафика. Бывают случаи, когда одним способом можно обойти DPI вашего провайдера, но вы видите заглушку транзитного провайдера. В таких случаях нужно комбинировать все доступные способы.
### Программа для обхода DPI
Я написал программу для обхода DPI под Windows: [GoodbyeDPI](https://github.com/ValdikSS/GoodbyeDPI).
Она умеет блокировать пакеты с перенаправлением от пассивного DPI, заменять Host на hoSt, удалять пробел между двоеточием и значением хоста в заголовке Host, «фрагментировать» HTTP и HTTPS-пакеты (устанавливать TCP Window Size), и добавлять дополнительный пробел между HTTP-методом и путем.
Преимущество этого метода обхода в том, что он полностью автономный: нет внешних серверов, которые могут заблокировать.
По умолчанию активированы опции, нацеленные на максимальную совместимость с провайдерами, но не на скорость работы. Запустите программу следующим образом:
```
goodbyedpi.exe -1 -a
```
Если заблокированные сайты стали открываться, DPI вашего провайдера можно обойти.
Попробуйте запустить программу с параметром `-2` и зайти на заблокированный HTTPS-сайт. Если все продолжает работать, попробуйте режим `-3` и `-4` (наиболее быстрый).
Некоторые провайдеры, например, Мегафон и Yota, не пропускают фрагментированные пакеты по HTTP, и сайты перестают открываться вообще. С такими провайдерами используйте опцию `-3 -a`
Эффективное проксирование для обхода блокировок по IP
-----------------------------------------------------
В случае блокировок по IP-адресу, провайдеры фильтруют только исходящие запросы на IP-адреса из реестра, но не входящие пакеты с этих адресов.
Программа [ReQrypt](https://reqrypt.org/reqrypt.html) работает как эффективный прокси-сервер: исходящие от клиента пакеты отправляются на сервер ReQrypt в зашифрованном виде, сервер ReQrypt пересылает их серверу назначения **с подменой исходящего IP-адреса на клиентский**, сервер назначения отвечает клиенту напрямую, минуя ReQrypt.
Если наш компьютер находится за NAT, мы не можем просто отправить запрос на сервер ReQrypt и ожидать ответа от сайта. Ответ не дойдет, т.к. в таблице NAT не создана запись для этого IP-адреса.
Для «пробива» NAT, ReQrypt отправляет первый пакет в TCP-соединении напрямую сайту, но с TTL = 3. Он добавляет запись в NAT-таблицу роутера, но не доходит до сайта назначения.
Долгое время разработка была заморожена из-за того, что автор не мог найти сервер с возможностью спуфинга. Спуфинг IP-адресов часто используется для амплификации атак через DNS, NNTP и другие протоколы, из-за чего он запрещен у подавляющего большинства провайдеров. Но сервер все-таки был найден, хоть и не самый удачный. Разработка продолжается.
Заключение и TL;DR
------------------
[GoodbyeDPI](https://github.com/ValdikSS/GoodbyeDPI) — программа под Windows, позволяющая обходить пассивные и активные DPI. Просто скачайте и запустите ее, и заблокированные сайты станут снова доступны.
Для Linux есть аналогичная программа — [zapret](https://github.com/bol-van/zapret).
Используйте кроссплатформенную программу [ReQrypt](https://reqrypt.org/reqrypt.html), если ваш провайдер блокирует сайты по IP-адресу.
Определить тип блокировки сайтов можно программой [Blockcheck](https://github.com/ValdikSS/blockcheck). Если в тестах DPI вы видите, что сайты открываются, или видите строку «обнаружен пассивный DPI», то GoodbyeDPI вам поможет. Если нет, используйте ReQrypt.
Дополнительная полезная информация есть [здесь](https://rutracker.org/forum/viewtopic.php?t=5403670) и [здесь](https://rutracker.org/forum/viewtopic.php?t=5126394). | https://habr.com/ru/post/335436/ | null | ru | null |
# О сравнении объектов по значению — 3, или Type-specific Equals & Equality operators
#### Ранее мы [рассмотрели](https://habrahabr.ru/post/314500/) корректную реализацию минимально необходимого набора доработок класса для сравнения объектов класса по значению.
Теперь рассмотрим Type-specific реализацию сравнения объектов по значению, включающую реализацию Generic-интерфейса [IEquatable(Of T)](https://msdn.microsoft.com/library/ms131187.aspx) и перегрузку операторов "==" и "!=".
Type-specific сравнение объектов по значению позволяет достичь:
* Более стабильного, масштабируемого и мнемонического (читаемого) кода (последнее за счет перегруженных операторов).
* Более высокой производительности.
Кроме того, реализация Type-specific сравнения по значению необходима по причинам:
* Стандартные Generic-коллекции (List(Ot T), Dictionary(Of TKey, TValue) и др.) рекомендуют наличие реализации IEquatable(Of T) для всех объектов, помещаемых в коллекции.
* Стандартный компаратор [EqualityComparer(Of T).Default](https://msdn.microsoft.com/library/ms224763.aspx) использует (по умолчанию — при наличии) реализацию IEquatable(Of T) у операндов.
Реализация одновременно всех способов сравнения сопряжена определенными с трудностями, т.к. для корректной работы требуется обеспечить:
* Соответствие результатов сравнения у различных способов (включая сохранение соответствия при наследовании).
* Минимизацию copy-paste и общего объема кода.
* Учет того, что операторы сравнения технически являются статическими методами и, соответственно, у них отсутствует полиморфность (а также, что не все [CLS](https://msdn.microsoft.com/library/12a7a7h3.aspx)-совместимые языки поддерживают операторы или их перегрузку).
#### Рассмотрим Type-specific реализацию сравнения объектов по значению с учетом вышеизложенных условий, на примере класса Person.
Сразу приведем окончательный вариант кода с пояснениями, почему это сделано именно так, и как именно это работает.
(Демонстрация вывода решения с учетом каждого нюанса содержит слишком много итераций.)
#### Класс Person с реализацией полного набора способов сравнения объектов по значению:
**class Person**
```
using System;
namespace HelloEquatable
{
public class Person : IEquatable
{
protected static int GetHashCodeHelper(int[] subCodes)
{
if ((object)subCodes == null || subCodes.Length == 0)
return 0;
int result = subCodes[0];
for (int i = 1; i < subCodes.Length; i++)
result = unchecked(result \* 397) ^ subCodes[i];
return result;
}
protected static string NormalizeName(string name) => name?.Trim() ?? string.Empty;
protected static DateTime? NormalizeDate(DateTime? date) => date?.Date;
public string FirstName { get; }
public string LastName { get; }
public DateTime? BirthDate { get; }
public Person(string firstName, string lastName, DateTime? birthDate)
{
this.FirstName = NormalizeName(firstName);
this.LastName = NormalizeName(lastName);
this.BirthDate = NormalizeDate(birthDate);
}
public override int GetHashCode() => GetHashCodeHelper(
new int[]
{
this.FirstName.GetHashCode(),
this.LastName.GetHashCode(),
this.BirthDate.GetHashCode()
}
);
protected static bool EqualsHelper(Person first, Person second) =>
first.BirthDate == second.BirthDate &&
first.FirstName == second.FirstName &&
first.LastName == second.LastName;
public virtual bool Equals(Person other)
{
//if ((object)this == null)
// throw new InvalidOperationException("This is null.");
if ((object)this == (object)other)
return true;
if ((object)other == null)
return false;
if (this.GetType() != other.GetType())
return false;
return EqualsHelper(this, other);
}
public override bool Equals(object obj) => this.Equals(obj as Person);
public static bool Equals(Person first, Person second) =>
first?.Equals(second) ?? (object)first == (object)second;
public static bool operator ==(Person first, Person second) => Equals(first, second);
public static bool operator !=(Person first, Person second) => !Equals(first, second);
}
}
```
1. Метод Person.GetHashCode() вычисляет хеш-код объекта, основываясь на полях, сочетание которых образует уникальность значения конкретного объекта.
Особенности вычисления хеш-кодов и требования к перекрытию метода [Object.GetHashCode()](https://msdn.microsoft.com/library/system.object.gethashcode.aspx) приведены в [документации](https://msdn.microsoft.com/library/system.object.gethashcode.aspx), а также в [первой публикации](https://habrahabr.ru/post/314328/).
2. Статический protected метод-хелпер EqualsHelper(Person, Person) сравнивает два объекта по полям, сочетание значений которых образует уникальность значения конкретного объекта.
3. Виртуальный метод Person.Equals(Person) реализует интерфейс IEquatable(Of Person).
(Метод объявлен виртуальным, т.к. его перекрытие понадобится при наследовании — будет рассмотрено ниже.)
* На "нулевом" шаге закомментирован код, проверяющий на [null](https://msdn.microsoft.com/library/edakx9da.aspx) ссылку на текущий объект.
Если ссылка равна [null](https://msdn.microsoft.com/library/edakx9da.aspx), то генерируется исключение [InvalidOperationException](https://msdn.microsoft.com/library/system.invalidoperationexception.aspx), говорящее о том, что объект находится в недопустимом состоянии. Зачем это может быть нужно — чуть ниже.
* На первом шаге проверяется равенство по ссылке текущего и входящего объекта. Если да — то объекты равны (это один и тот же объект).
* На втором шаге проверяется на [null](https://msdn.microsoft.com/library/edakx9da.aspx) ссылка на входящий объект. Если да — то объекты не равны (это разные объекты).
(Равенство по ссылке проверяется с помощью операторов [==](https://msdn.microsoft.com/library/53k8ybth.aspx) и [!=](https://msdn.microsoft.com/library/3tz250sf.aspx), с предварительным приведением операндов к [object](https://msdn.microsoft.com/library/9kkx3h3c.aspx) для вызова неперегруженного оператора, либо с помощью метода [Object.ReferenceEquals(Object, Object)](https://msdn.microsoft.com/library/system.object.referenceequals.aspx). Если используются операторы [==](https://msdn.microsoft.com/library/53k8ybth.aspx) и [!=](https://msdn.microsoft.com/library/3tz250sf.aspx), то в данном случае приведение операндов к [object](https://msdn.microsoft.com/library/9kkx3h3c.aspx) обязательно, т.к. в данном классе эти операторы будут перегружены и сами будут использовать метод Person.Equals(Person).)
* Далее проверяется идентичность типов текущего и входящего объектов. Если типы не идентичны — то объекты не равны.
(Проверка идентичности типов объектов, вместо проверки совместимости, используется для учета реализации сравнения по значению при наследовании типа. Подробнее об этом в [предыдущей публикации](https://habrahabr.ru/post/314500/).)
* Затем, если предыдущие проверки не позволили дать быстрый ответ, равны объекты или нет, то текущий и входящий объекты проверяются непосредственно по значению с помощью метода-хелпера EqualsHelper(Person, Person).
4. Метод Person.Equals(Object), реализован как вызов метода Person.Equals(Person) с приведением входящего объекта к типу Person с помощью оператора [as](https://msdn.microsoft.com/library/cscsdfbt.aspx).
* Примечание. Если типы объектов не совместимы, то результатом приведения будет [null](https://msdn.microsoft.com/library/edakx9da.aspx), что приведет к получению результата сравнения объектов в методе Person.Equals(Person) на втором шаге (объекты не равны).
Однако, в общем случае, результат сравнения в методе Person.Equals(Person) может быть получен и на первом шаге (объекты равны), т.к. теоретически в [.NET](https://www.microsoft.com/net) возможен вызов экземплярного метода без создания экземпляра (подробнее об этом в [первой публикации](https://habrahabr.ru/post/314328/)).
И тогда, если ссылка на текущий объект будет равна [null](https://msdn.microsoft.com/library/edakx9da.aspx), ссылка на входящий объект будет не равна [null](https://msdn.microsoft.com/library/edakx9da.aspx), а типы текущего и входящего объектов будут несовместимы, то такой вызов Person.Equals(Object) с последующим вызовом Person.Equals(Person) даст неверный результат на первом шаге — "объекты равны", в то время на самом деле объекты не равны.
Представляется, что такой редкий случай не требует специальной обработки, т.к. вызов экземплярного метода и использование его результата не имеет смысла без создания самого экземпляра.
Если же потребуется его учесть, то достаточно раскомментировать код "нулевого шага" в методе Person.Equals(Person), что не только предотвратит получение теоретически возможного неверного результата при вызове метода Person.Equals(Object), но и, при непосредственном вызове метода Person.Equals(Person) у [null](https://msdn.microsoft.com/library/edakx9da.aspx)-объекта, сгенерирует на "нулевом" шаге более информативное исключение, вместо [NullReferenceException](https://msdn.microsoft.com/library/system.nullreferenceexception.aspx) на третьем шаге.
5. Для поддержки статического сравнения объектов по значению для [CLS](https://msdn.microsoft.com/library/12a7a7h3.aspx)-совместимых языков, не поддерживающих операторы или их перегрузку, реализован статический метод Person.Equals(Person, Person).
(В качестве Type-specific, и более быстродействующей, альтернативы методу [Object.Equals(Object, Object)](https://msdn.microsoft.com/library/w4hkze5k.aspx).)
(О необходимости реализации методов, соответствующих операторам, и рекомендации по соответствию операторов и имен методов, можно прочесть в книге Джеффри Рихтера (Jeffrey Richter) CLR via C# (Part II "Designing Types", Chapter 8 "Methods", Subchapter "Operator Overload Methods").)
* Метод Person.Equals(Person, Person) реализован через вызов экземплярного виртуального метода Person.Equals(Person), т.к. это необходимо для обеспечения того, чтобы "вызов x == y давал давал тот же результат, что и вызов "y == x", что соответствует требованию "вызов x.Equals(y) должен давать тот же результат, что и вызов y.Equals(x)" (подробнее о последнем требовании, включая его обеспечение при наследовании — в [предыдущей публикации](https://habrahabr.ru/post/314500/)).
* Т.к. статические методы при наследовании типа не могут быть перекрыты (речь именно о перекрытии — override, а не о переопределении — new), т.е. не имеют полиморфного поведения, то причина именно такой реализации — вызов статического метода Person.Equals(Person, Person) через вызов виртуального экземплярного Person.Equals(Person) — именно в необходимости обеспечить полиморфизм при статических вызовах, и, тем самым, обеспечения соответствия результатов "статического" и "экземплярного" сравнения при наследовании.
* В методе Person.Equals(Person, Person) вызове экземплярного метода Person.Equals(Person) реализован с проверкой на [null](https://msdn.microsoft.com/library/edakx9da.aspx) ссылки на тот объект, у которого вызывается метод Equals(Person).
Если этот объект — [null](https://msdn.microsoft.com/library/edakx9da.aspx), то выполняется сравнение объектов по ссылке.
6. Перегруженные операторы Person.==(Person, Person) и Person.!=(Person, Person) реализованы с помощью вызова "как есть" статического метода Person.Equals(Person, Person) (для оператора "!=" — в паре с оператором [!](https://msdn.microsoft.com/library/f2kd6eb2.aspx)).
#### Итак, мы нашли корректный и достаточно компактный способ реализации в одном классе всех способов сравнения объектов класса по значению, и даже учли корректность поведения на случай наследования, заложили в коде возможности, которые сможем использовать при наследовании.
При этом необходимо отдельно рассмотреть, как для данного варианта реализации сравнения объектов по значению корректно выполнить наследование, если в класс наследник вносится поле, входящее в множество полей объекта, образующих уникальное значение объекта:
Пусть есть класс PersonEx, наследующий класс Person, и имеющий дополнительное свойство MiddleName. В этом случае сравнение двух объектов класса PersonEx:
```
John Teddy Smith 1990-01-01
John Bobby Smith 1990-01-01
```
Любым реализованным способом даст результат "объекты равны", что неверно с предметной точки зрения.
Таким образом, при *кажущейся* тривиальности задачи, помимо достаточно больших затрат и рисков, реализация сравнения объектов по значению в текущей инфраструктуре .NET, чревата еще и тем, что как только в классе реализовано сравнение объектов по значению, то реализацию сравнения придется "тащить" (и делать это правильным образом) в классы-наследники, что несет дополнительные затраты и потенциал ошибок.
#### Как сделать решение этой задачи, насколько возможно, легким и компактным, поговорим в [продолжении](https://habrahabr.ru/post/315258/). | https://habr.com/ru/post/315168/ | null | ru | null |
# Создаем установочные пакеты для macOS средствами системы
**Disclaimer:** приведенные здесь методы успешно работают в macOS Mojave, Catalina и Big Sur, но для боевых систем рекомендуется всегда проводить собственные тесты собранных пакетов.
Как-то так вышло, что раньше я довольно скептически относился к macOS, поскольку не имел возможности поработать с ней в более-менее устоявшейся корпоративной среде (т.е. не когда на всю компанию в 500-600 человек есть 2 мака, и те у генерального с его замом, да еще и с виндой в буткемпе). Но несколько лет назад мне повезло познакомиться с очень масштабной гетерогенной средой, показавшей, что в современных компаниях macOS не только успешно сосуществует с привычной Windows, но иногда и превалирует над ней в общей доле клиентских машин.
Позднее я оказался в другой компании, где отсутствовали привычные инструменты управления парком (а непривычные оказались недоступны из-за серьезных ограничений для региональных подразделений, в одно из которых я и входил). Проводить настройку и устанавливать софт "руками" я не люблю практически с самого начала своей карьеры – отлаженный сценарий экономит время и нервы, поэтому я начал искать варианты установки ПО на macOS.
Часть приложений распространяется в формате PKG – это пакет, сформированный специально для обработки приложением Installer, позволяющий провести установку как из графического интерфейса, так и из консоли (например, так: `installer -pkg $pkgfile -target /Applications`). В идеале хотелось бы иметь пакеты в таком формате для всего стандартного ПО, распространяемого на клиентские машины, к этому и будем стремиться.
К сожалению, существенная часть ПО распространяется в виде DMG-образов, позволяющих просто примонтировать скачанный файл-образ и скопировать подготовленное приложение (обычно в формате .app) в каталог */Applications*. К счастью, перепаковать такое приложение практически не составляет труда:
1. монтируем dmg-образ;
2. копируем приложение к себе на машину (каталог не имеет большого значения, но лучше следовать канонам – стандартный каталог для приложений */Applications*);
3. выполняем в терминале следующую команду:
`productbuild --component /path/to/YourApplication.app /Applications/ /path/to/YourApplication.pkg`(сначала указываем путь к скопированному приложению, далее идет опция, говорящая, что установка из пакета будет проводиться в каталог /Applications, и в финале задаем путь к создаваемому пакету, рекомендую везде использовать полные пути)
В результате получаем установочный пакет, одинаково успешно ведущий себя как при графической, так и при консольной процедуре установки. Да, установку из DMG-образа вполне можно реализовать, монтируя образ через *hdiutil* и копируя приложение, но этот вариант показался мне менее универсальным.
Иногда может потребоваться выполнить какие-то действия с системой, которые в обычных условиях можно было бы реализовать с помощью удаленного вызова или, например, shell-скриптов, но, предположим, что удаленного доступа к машине нет, а пользователь не горит желанием открывать консоль (если вообще знает, что это, ну и будем реалистами, ему и не надо). Система позволяет создавать подобие т.н. payload-free пакетов (в которые при желании можно все равно запихнуть некоторый payload) – в формируемом пакете основной интерес для нас будет представлять файл *postinstall* – тот же shell-скрипт, но выполняющийся в рамках работы с установочным пакетом.
Создадим папку *scripts*(я предпочитаю создавать каталоги в местах, где точно обладаю необходимыми правами, например, домашний каталог и его дочерние папки), в нее необходимо поместить весь контент, который потребуется для выполнения сценария (например, если вы осуществляете настройку принтера на клиентской машине, в пакет можно включить файл драйвера .ppd).
После того, как все необходимые файлы скопированы, открываем терминал, переходим с его помощью внутрь каталога *scripts* и выполняем команду `pico postinstall`. Откроется стандартный консольный текстовый редактор (обычно, если вы ничего не меняли, это будет *nano*), в редактор необходимо ввести или скопировать текст вашего сценария, для примера приведу сценарий, меняющий параметры времени/таймзоны:
```
#!/bin/bash
ntp="time.euro.apple.com"
sudo /usr/sbin/systemsetup -setusingnetworktime on
sudo /usr/sbin/systemsetup -setnetworktimeserver "$ntp"
exit 0
```
После заполнения сценария всеми необходимыми операциями нажимаем Ctrl+X для выхода из редактора (жмем Y на вопрос о сохранении изменений, разумеется), но из терминала не выходим. Скрипт должен считаться исполняемым, добавляем ему соответствующие права командой `sudo chmod a+x postinstall` (вводим пароль при необходимости).
Создаем наш пакет следующей командой:
`sudo pkgbuild --identifier com.package.name --nopayload --scripts /path/to/scripts/ "/path/to/your_package.pkg"`(в качестве идентификатора по идее надо указывать что-то, что позволит однозначно определить назначение пакета, пути по традиции указываем полные).
В большинстве случаев я рекомендовал бы использовать более привычные, распространенные инструменты администрирования, но в случае их отсутствия, надеюсь, эти решения помогут вам хоть немного упростить некоторые рутинные процессы. | https://habr.com/ru/post/564490/ | null | ru | null |
# Flutter: флип-анимация
> *Перевод подготовлен в рамках курса* [*"****Flutter Mobile Developer****"*](https://otus.pw/4Iwj/)*.
>
> Всех желающих приглашаем на второй день двухдневного онлайн-интенсива* [***«Создаем приложение на Flutter для Web, iOS и Android»***](https://otus.pw/hVHd/)*. Продолжаем писать приложение (это будет приложение с работой по сети: загрузка списка сущностей + их фильтрация + сделаем блок настроек в приложении, где можно будет менять тему приложения (цвета)). Присоединяйтесь!*
>
>
---
Когда я впервые увидел виджет `AnimationSwitcher`, то подумал, что смогу его перевернуть, открыв его обратную сторону.
Я ошибался: `AnimationSwitcher` позволяет... переключаться между различными виджетами с заданной вами анимацией (анимация по умолчанию - затухающий переход). Этот компонент слишком универсальный для этой цели.
Я должен был внимательно читать…Его использование является весьма общим, поэтому я покажу вам, как можно сделать такую анимацию.
> Я обнаружил пакет flutter, который может делать такую флип-анимацию, под названием **animated\_card\_switcher**, но, похоже, он не поддерживается должным образом, и код слишком сложен.
>
>
Вот шаги по разработке:
* Создайте передний и задний виджеты
* Используйте виджет AnimationSwitcher для анимации
* Создайте свой собственный конструктор переходов для поворота вашей карточки.
* Добавить кривые
### Создание переднего и заднего виджетов
В этом примере я возьму упрощенные версии переднего и заднего виджетов, потому что это не так существенно.
Единственное, о чем следует помнить, это то, что вы должны установить ключ для виджетов верхнего уровня, чтобы `AnimationSwitcher` обнаружил, что виджет изменился (и, следовательно, выполнил анимацию).
Как кусок пирога!Вот пример макета виджетов, который я буду использовать:
```
Widget __buildLayout({Key key, String faceName, Color backgroundColor}) {
return Container(
key: key,
decoration: BoxDecoration(
shape: BoxShape.rectangle,
borderRadius: BorderRadius.circular(20.0),
color: backgroundColor,
),
child: Center(
child: Text(faceName.substring(0, 1), style: TextStyle(fontSize: 80.0)),
),
);
```
Итак, мои виджеты будут иметь вид спереди и сзади:
```
Widget _buildFront() {
return __buildLayout(
key: ValueKey(true),
backgroundColor: Colors.blue,
faceName: "F",
);
}
Widget _buildRear() {
return __buildLayout(
key: ValueKey(false),
backgroundColor: Colors.blue.shade700,
faceName: "R",
);
}
```
### Использование виджета AnimationSwitcher для анимирования
Теперь мы можем использовать виджет `AnimationSwitcher` для анимирования перехода между передним и задним сторонами.
В `StatefulWidget` я переопределяю метод `build`, чтобы создать страницу, которая будет показывать анимацию в ее центре.
```
class MyHomePage extends StatefulWidget {
MyHomePage({Key key, this.title}) : super(key: key);
final String title;
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State {
bool \_displayFront;
bool \_flipXAxis;
@override
void initState() {
super.initState();
\_displayFront = true;
\_flipXAxis = true;
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(this.widget.title),
centerTitle: true,
),
body: Center(
child: Container(
constraints: BoxConstraints.tight(Size.square(200.0)),
child: \_buildFlipAnimation(),
),
);
}
}
```
Я отделил анимацию от страницы в методе `_build Flip Animation`, чтобы сделать код более понятным.
Вот первая версия этого метода:
```
Widget _buildFlipAnimation() {
return GestureDetector(
onTap: () => setState(() =>_showFrontSide = !_showFrontSide),
child: AnimatedSwitcher(
duration: Duration(milliseconds: 600),
child: _showFrontSide ? _buildFront() : _buildRear(),
),
);
}
```
Когда мы кликаем на виджете, мы видим, что передняя часть виджета исчезает, открывая заднюю сторону. При повторном клике задний вид исчезает, открывая переднюю сторону.
По крайней мере, что-то происходит.Мы хотим повернуть виджеты по оси Y. Надеюсь, `AnimationSwitcher` позволит нам переопределить переход, благодаря входному `transitionBuilder`.
#### Закодируйте свой пользовательский конструктор переходов для вращения вашей карточки
Итак, вот план: мы хотим получить поворот на 180° (pi). Мы обернем наши виджеты в `AnimatedBuidler` и воспользуемся виджетом `Transform` для применения вращения.
```
Widget __transitionBuilder(Widget widget, Animation animation) {
final rotateAnim = Tween(begin: pi, end: 0.0).animate(animation);
return AnimatedBuilder(
animation: rotateAnim,
child: widget,
builder: (context, widget) {
return Transform(
transform: Matrix4.rotationY(value),
child: widget,
alignment: Alignment.center,
);
},
);
}
```
Это хороший старт, но не совсем то, что необходимо. Мы видим, что при анимации перехода задний виджет находится сверху от начала до конца.
Финальная часть появляется слишком быстро.Нам нужно, чтобы передний виджет постепенно заменялся задним.
Поэтому необходимо изменить две вещи:
* Порядок отображения должен быть обратным: заменяемый виджет должен быть на вершине стека.
* В середине анимации заменяемый виджет должен исчезнуть.
Для этого мы изменим вход `layoutBuilder` нашего экземпляра `AnimationSwitcher`.
```
layoutBuilder: (widget, list) => Stack(children: [widget, ...list]),
```
Затем, в середине анимации, в результате поворота на pi/2 ширина виджета станет равной 0.0. Поэтому мы заблокируем это вращение (**только**) для анимации предыдущего виджета.
```
Widget __transitionBuilder(Widget widget, Animation animation) {
final rotateAnim = Tween(begin: pi, end: 0.0).animate(animation);
return AnimatedBuilder(
animation: rotateAnim,
child: widget,
builder: (context, widget) {
final isUnder = (ValueKey(\_showFrontSide) != widget.key);
final value = isUnder ? min(rotateAnim.value, pi / 2) : rotateAnim.value;
return Transform(
transform: Matrix4.rotationY(value),
child: widget,
alignment: Alignment.center,
);
},
);
}
```
Уже лучше, но мы еще не закончили! Чтобы усилить ощущение того, что виджет вращается, мы добавим небольшой "tilt" (наклон) на виджеты.
Нам нужна глубина... Милая маленькая пушистая глубина.Это значение "наклона" должно быть равно 0,0 в начале и в конце анимации. Кроме того, поскольку мы будем применять анимацию для каждой стороны нашего виджета, то их наклон должен быть противоположным. Например, если наклон переднего виджета равен 0,2, то наклон заднего должен быть -0,2.
Чтобы применить наклон к виджету, мы вручную задаем одно конкретное значение объекту Matrix4, определяющему поворот.
```
Widget __transitionBuilder(Widget widget, Animation animation) {
final rotateAnim = Tween(begin: pi, end: 0.0).animate(animation);
return AnimatedBuilder(
animation: rotateAnim,
child: widget,
builder: (context, widget) {
final isUnder = (ValueKey(\_showFrontSide) != widget.key);
var tilt = ((animation.value - 0.5).abs() - 0.5) \* 0.003;
tilt \*= isUnder ? -1.0 : 1.0;
final value = isUnder ? min(rotateAnim.value, pi / 2) : rotateAnim.value;
return Transform(
transform: Matrix4.rotationY(value)..setEntry(3, 0, tilt),
child: widget,
alignment: Alignment.center,
);
},
);
}
```
*Более подробную информацию о Matrix4 можно получить здесь:* [*https://medium.com/flutter-community/advanced-flutter-matrix4-and-perspective-transformations-a79404a0d828*](https://medium.com/flutter-community/advanced-flutter-matrix4-and-perspective-transformations-a79404a0d828)*.*
### Добавить кривые
Наконец, чтобы добавить немного энергии и динамики в анимацию, вы можете изменить параметры кривых входа AnimationSwitcher.
С кривыми всегда лучше!Вот моя первая попытка:
```
Widget _buildFlipAnimation() {
return GestureDetector(
onTap: _switchCard,
child: AnimatedSwitcher(
duration: Duration(milliseconds: 4600),
transitionBuilder: __transitionBuilder,
layoutBuilder: (widget, list) => Stack(children: [widget, ...list]),
child: _showFrontSide ? _buildFront() : _buildRear(),
switchInCurve: Curves.easeInBack,
switchOutCurve: Curves.easeOutBack,
),
);
}
```
Я должен показать вам в замедленном режиме в чем проблема.
О Нееееееет….Поскольку кривые не полностью идентичны, и предыдущая анимация виджета воспроизводится в обратном порядке, вы получите артефакт, при котором два виджета не накладываются как следует один на другой. Между ними будет небольшой сдвиг.
Анимация в режиме нескольких кадров…Чтобы избежать этого, мы должны использовать свойство `flipped` для кривой, которую мы хотим использовать.
```
switchInCurve: Curves.easeInBack,
switchOutCurve: Curves.easeInBack.flipped,
```
Sloooow Mooooo (теперь идеально)Заключение
----------
Как видите, ничего особенного: я сделал эту анимацию примерно из 30 строк кода (только анимация), используя только один атрибут (отображаемая сторона виджета).
*Я не думаю, что имеет смысл создавать пакет для этого. Добавление зависимости в ваш код означает, что если он не будет работать при обновлении версии (например), ваш проект застопорится на определенное время. Хуже того, если зависимость больше не поддерживается, вы не сможете гарантировать, что ваш проект будет правильно компилироваться в следующие 6 месяцев, 1 или 2 года...*
Копируйте и вставляйте этот пример с умом :)Так что не стесняйтесь использовать мой код. Я не поклонник копипаста, поэтому точнее выразиться (не стесняйтесь использовать код) “соответствующий моему коду”, то есть скопируйте-вставьте его, **поймите** и **измените** в соответствии с вашими потребностями!
Демонстрацию, использованную в этой статье, [вы найдете здесь](https://github.com/GONZALEZD/flutter_demos/tree/main/flip_animation).
Следите за сообществом Flutter в [Twitter](https://www.twitter.com/FlutterComm)
---
> Узнать подробнее о курсе ["**Flutter Mobile Developer**"](https://otus.pw/4Iwj/)
>
> Участвовать в двухдневном онлайн-интенсиве [**«Создаем приложение на Flutter для Web, iOS и Android»**](https://otus.pw/hVHd/)
>
> | https://habr.com/ru/post/558246/ | null | ru | null |
# Уровень сигнала трансивера через SNMP в Cisco
Иногда нужно узнать уровень сигнала в трансивере. Причины бывают разные: внезапное падение канала связи, подключение новых оптических кроссировок, мониторинг. Инженер с необходимым уровнем доступа решает этот вопрос меньше чем за одну минуту с помощью команды:
```
#show interfaces Te1/49 transceiver
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Optical Optical
Temperature Voltage Tx Power Rx Power
Port (Celsius) (Volts) (dBm) (dBm)
--------- ----------- ------- -------- --------
Te1/49 53.3 3.25 -4.3 -2.8
```
Кому-то (у кого нет соответствующего доступа) приходится ждать этой минуты целую вечность. Например, когда канал упал в пиковые часы и на резервном линке какие-то потери, которые обнаружились только при загрузке линка трафиком. Или когда новый канал нужно было сдать вчера, а ничего не работает, потому что поставщик неправильно подписал оптику на CWDM-мультиплексоре, и требуется методом тыка отыскать «правильную волну». И все это происходит в условиях дефицита верховных сетевых инженеров и времени.
В статье рассматривается вариант того, как проверить сигнал, имея лишь read-only доступ по SNMP. Ждать при этом приходится не более 10 минут (обычный период обновления соответвтующей переменной). Выделение такого доступа кажется более ~~безопаным~~ логичным для ряда сотрудников, которые по тем или иным причинам не имеют CCNA или CCNP (инженеры мониторинга, операционисты, технические менеджеры). Также информация может быть полезна при настройке систем мониторинга.
#### Дано
* хост с IP-адресом, который имеет read-only доступ по SNMP к нескольким Cisco (7604, 7609, 4948-10GE)
* IP-адрес устройства Cisco (например, 10.0.7.35)
* номер порта (например, Te1/49)
#### Найти
* уровень сигнала трансивера, установленного в заданный порт
#### Решение
Для начала найдем нужный OID. Он будет состоять из ID [«entSensorValue»](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.4.1.9.9.91.1.1.1.1.4) и «индекса» самого сенсора. Последний можно найти, выполнив следующий запрос с хоста, который имеет доступ по snmp к сетевому устройству с management IP 10.0.7.35:
```
$ snmpwalk -v 2c -c community 10.0.7.35 1.3.6.1.2.1.47.1.1.1.1.7 | grep Te1/49
SNMPv2-SMI::mib-2.47.1.1.1.1.7.1107 = STRING: "Te1/49 Module Temperature Sensor"
SNMPv2-SMI::mib-2.47.1.1.1.1.7.1157 = STRING: "Te1/49 Supply Voltage Sensor"
SNMPv2-SMI::mib-2.47.1.1.1.1.7.1207 = STRING: "Te1/49 Bias Current Sensor"
SNMPv2-SMI::mib-2.47.1.1.1.1.7.1257 = STRING: "Te1/49 Transmit Power Sensor"
SNMPv2-SMI::mib-2.47.1.1.1.1.7.1307 = STRING: "Te1/49 Receive Power Sensor"
```
Воспользуемся последним числом в OID для «Te1/49 Transmit Power Sensor» и «Te1/49 Receive Power Sensor». Это соответственно 1257 и 1307. Используя эти числа, мы сразу можем получить уровень исходящего и входящего оптического сигнала (value):
```
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.4.1257
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.4.1257 = INTEGER: -28
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.4.1307
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.4.1307 = INTEGER: -35
```
Комбинируя аналогичным образом [«entSensorPrecision»](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.4.1.9.9.91.1.1.1.1.3) и «индекс» сенсора, находим точность измерения (количество знаков после запятой):
```
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.3.1257
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.3.1257 = INTEGER: 1
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.3.1307
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.3.1307 = INTEGER: 1
```
Цифра «1» в этом случае означает, что нужно поставить запятую перед одной цифрой справа в значении соответствующего сенсора.
Te1/49 Transmit Power = -2,8
Te1/49 Receive Power = -3,5
Чтобы определить единицы измерения, воспользуемся [«entSensorType»](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.4.1.9.9.91.1.1.1.1.1) в комбинации с «индексом» сенсора:
```
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.1.1257
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.1.1257 = INTEGER: 14
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.1.1307
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.1.1307 = INTEGER: 14
```
Значение 14 соответсвует единицам «dBm». Список значений дается в [описании](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.4.1.9.9.91.1.1.1.1.1) «entSensorType».
К единицам измерения может быть добавлена десятичная приставка. Какая именно — покажет [«entSensorScale»](http://tools.cisco.com/Support/SNMP/do/BrowseOID.do?local=en&translate=Translate&objectInput=1.3.6.1.4.1.9.9.91.1.1.1.1.2):
```
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.2.1257
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.2.1257 = INTEGER: 9
$ snmpget -v 2c -c community 10.0.7.35 1.3.6.1.4.1.9.9.91.1.1.1.1.2.1307
SNMPv2-SMI::enterprises.9.9.91.1.1.1.1.2.1307 = INTEGER: 9
```
В данном случае приставка «Units» (которая соответствует числу 9) фактически означает отсутствие приставки.
Таким образом, мы получили уровень сигнала трансивера, установленного в порту Te1/49, на свиче с IP 10.0.7.35
Te1/49 Transmit Power = -2,8 dBm
Te1/49 Receive Power = -3,5 dBm
Составим ответ по [учебнику](http://www.opennet.ru/docs/RUS/bash_scripting_guide/):
**light.bash**
```
#!/bin/bash
E_OPTERROR=65
verbose=0
get_type () {
if [ -z "$1" ] # Length of argument is 0?
then
exit $E_OPTERROR
elif [ "$1" -eq "1" ]
then truetype=other
elif [ "$1" -eq "2" ]
then truetype=unknown
elif [ "$1" -eq "3" ]
then truetype=voltsAC
elif [ "$1" -eq "4" ]
then truetype=voltsDC
elif [ "$1" -eq "5" ]
then truetype=amperes
elif [ "$1" -eq "6" ]
then truetype=watts
elif [ "$1" -eq "7" ]
then truetype=hertz
elif [ "$1" -eq "8" ]
then truetype=celsius
elif [ "$1" -eq "9" ]
then truetype=percentRH
elif [ "$1" -eq "10" ]
then truetype="rpm"
elif [ "$1" -eq "11" ]
then truetype=cmm
elif [ "$1" -eq "12" ]
then truetype=truthvalue
elif [ "$1" -eq "13" ]
then truetype=specialEnum
elif [ "$1" -eq "14" ]
then truetype=dBm
else echo type=$1,error; exit $E_OPTERROR
fi
return 0
}
get_scale () {
if [ -z "$1" ] # Length of argument is 0?
then
exit $E_OPTERROR
elif [ "$1" -eq "1" ]
then truescale=yocto
elif [ "$1" -eq "2" ]
then truescale=zepto
elif [ "$1" -eq "3" ]
then truescale=atto
elif [ "$1" -eq "4" ]
then truescale=femto
elif [ "$1" -eq "5" ]
then truescale=pico
elif [ "$1" -eq "6" ]
then truescale=nano
elif [ "$1" -eq "7" ]
then truescale=micro
elif [ "$1" -eq "8" ]
then truescale=milli
elif [ "$1" -eq "9" ]
then truescale=""
elif [ "$1" -eq "10" ]
then truescale=kilo
elif [ "$1" -eq "11" ]
then truescale=mega
elif [ "$1" -eq "12" ]
then truescale=giga
elif [ "$1" -eq "13" ]
then truescale=tera
elif [ "$1" -eq "14" ]
then truescale=exa
elif [ "$1" -eq "15" ]
then truescale=peta
elif [ "$1" -eq "16" ]
then truescale=zetta
elif [ "$1" -eq "17" ]
then truescale=yotta
else echo scale=$1,error; exit $E_OPTERROR
fi
return 0
}
#reading the options
while getopts ":c:h:i:v" Option
do
#echo $OPTIND
case $Option in
c ) community=$OPTARG;;
h ) host=$OPTARG;;
i ) interface=$OPTARG;;
v ) echo "Verbose mode is set";verbose=1;;
* ) echo "Usage: `basename $0` -c community -h host -i interface"; exit $E_OPTERROR;; # default options
esac
done
shift $(($OPTIND - 1)) #moving on to the next provided option
if [ -z "$community" ] || [ -z $host ] || [ -z $interface ] # if some of options is not submitted
then
echo "Usage: `basename $0` -c community -h host -i interface"
exit $E_OPTERROR
fi
if [ $verbose -eq 1 ]
then
echo "community is \"$community\""
echo "host is \"$host\""
echo "interface is \"$interface\""
fi
#looking for the index of sensor
if [ $verbose -eq 1 ]
then
echo "executing \"snmpwalk -v 2c -OX -c $community $host 1.3.6.1.2.1.47.1.1.1.1.7 | grep $interface\""
fi
# step1: getiing information about device
#snmpwalk -v 2c -OX -c $community $host 1.3.6.1.2.1.47.1.1.1.1.7 | grep $interface >
index=0
while read line; do
string[$index]="$line"
index=$(($index+1))
# done < <(cat tempcache)
done < <(snmpwalk -v 2c -OX -c $community $host 1.3.6.1.2.1.47.1.1.1.1.7 | grep $interface)
if [ $verbose -eq 1 ]
then
for ((a=0; a < ${#string[*]}; a++))
do
echo "have a string#$a as ${string[$a]}"
done
fi
# step2: parse/cut received strings
if [ $verbose -eq 1 ]
then
echo "parsing/cuting snmpwalk result"
fi
for ((a=0; a < ${#string[*]}; a++))
do
rx_string=`echo ${string[$a]} | grep Receive`;
tx_string=`echo ${string[$a]} | grep Transmit`;
if [ -n "$rx_string" ]
then rx_sensor=`echo ${string[$a]}| cut -d "[" -f2 | cut -d "]" -f1`
elif [ -n "$tx_string" ]
then tx_sensor=`echo ${string[$a]}| cut -d "[" -f2 | cut -d "]" -f1`
fi
done
if [ $verbose -eq 1 ]
then
echo "index of rx_sensor parsed to $rx_sensor"
echo "index of tx_sensor parsed to $tx_sensor"
fi
#getting the sensor value
if [ $verbose -eq 1 ]
then
echo "getting the sensor value"
fi
rx_value=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.4.$rx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
rx_precision=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.3.$rx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
rx_type=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.1.$rx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
get_type $rx_type
rx_type=$truetype
rx_scale=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.2.$rx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
get_scale $rx_scale
rx_scale=$truescale
tx_value=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.4.$tx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
tx_precision=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.3.$tx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
tx_type=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.1.$tx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
get_type $tx_type
tx_type=$truetype
tx_scale=`snmpget -v 2c -c $community $host 1.3.6.1.4.1.9.9.91.1.1.1.1.2.$rx_sensor | grep -o -e "INTEGER: [-+0-9]*" | cut -f2 -d" "`
get_scale $tx_scale
tx_scale=$truescale
let lengthrx=${#rx_value}-$rx_precision
let lengthtx=${#tx_value}-$tx_precision
echo RX=${rx_value:0:$lengthrx}.${rx_value:$lengthrx} $rx_scale$rx_type
echo TX=${tx_value:0:$lengthtx}.${tx_value:$lengthtx} $tx_scale$tx_type
exit 0
``` | https://habr.com/ru/post/260721/ | null | ru | null |
# Gatling. Тестирование Kafka
Привет! Меня зовут Александра, я работаю в отделе тестирования производительности Тинькофф. Мы продолжаем наш цикл статей, посвященных работе Gatling с различными протоколами. Ранее мы уже рассмотрели работу с [HTTP](https://habr.com/ru/company/tinkoff/blog/658479/), [JDBC](https://habr.com/ru/company/tinkoff/blog/663718/) и [gRPC](https://habr.com/ru/company/tinkoff/blog/664674/). В этой статье поговорим о работе Gatling с Kafka. Если вы еще не прочли нашу [вводную статью](https://habr.com/ru/company/tinkoff/blog/655341/), рекомендую это сделать: в ней мы поделились базовой информацией о работе с Gatling.
> **Дисклеймер**
>
> На момент написания статьи используемые плагины поддерживают версию Gatling не выше 3.7.6. Для получения работающего скрипта в будущем достаточно обновить версии плагинов в соответствии с их документацией.
>
>
Пишем скрипты Gatling для Kafka
-------------------------------
Kafka — распределенный брокер сообщений с высокой пропускной способностью. Он состоит из нескольких основных элементов:
1. Broker — сервер.
2. Producer — отвечает за отправку сообщений в топик.
3. Consumer — отвечает за считывание обращений.
4. ZooKeeper — хранилище метаданных и логов.
Также у Kafka особая структура данных: каждое сообщение содержит ключ, значение, временную метку и опционально может содержать метаданные. Сообщения отправляются в топики, которые могут состоять из нескольких партиций. Узнать о Kafka больше можно [в официальной документации.](https://kafka.apache.org/documentation/#gettingStarted)
### Разворачиваем тестовую Kafka
Для разработки скрипта Gatling развернем тестовую Kafka и Zookeeper. Для локального развертывания сервисов используем файл docker-compose.yml. Актуальные версии можно посмотреть [на странице в DockerHub.](https://hub.docker.com/)
```
services:
zookeeper:
image: wurstmeister/zookeeper
hostname: zoo1
environment:
ZOO_MY_ID: "1"
ZOO_PORT: "2181"
ZOO_SERVERS: server.1=zoo1:2888:3888
ports:
- '2181:2181'
volumes:
- "./zookeeper/data:/data"
- "./zookeeper/logs:/datalog"
restart: on-failure
kafka:
image: wurstmeister/kafka
depends_on:
- zookeeper
environment:
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_ADVERTISED_HOST_NAME: kafka
KAFKA_LISTENERS: BROKER://:9092,EXTERNAL://:9093
KAFKA_ADVERTISED_LISTENERS: BROKER://kafka:9092,EXTERNAL://localhost:9093
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: BROKER:PLAINTEXT,EXTERNAL:PLAINTEXT
KAFKA_INTER_BROKER_LISTENER_NAME: BROKER
KAFKA_BROKER_ID: "1"
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: "1"
KAFKA_CREATE_TOPICS: myTopic:1:1
ports:
- '9093:9093'
- '9092:9092'
volumes:
- /var/run/docker.sock:/var/run/docker.sock
```
Для запуска создаем файл docker-compose.yml и выполняем команду docker-compose up. Обратите внимание: для выполнения команды нужно установить и запустить Docker.
После выполнения команды будет развернута тестовая Kafka. Чтобы проверить ее доступность, устанавливаем [KafkaTool](https://www.kafkatool.com/) и подключаемся к ней. Для этого создаем новое подключение. В открывшемся окне произвольно называем кластер, на вкладке Advanced вводим адрес localhost:9093.
### Разрабатываем скрипт
Для написания скриптов берем [тот же шаблон](https://gitlab.tcsbank.ru/perf-core/gatling-template.g8), что и в предыдущей статье. В качестве IDE для разработки скриптов будем использовать IntelliJ IDEA.
#### Шаг 1. Обновление зависимостей
В файле *project/Dependencies.scala* добавим плагин для работы Gatling с Kafka и его зависимости. Актуальную версию можно посмотреть [в GitHub.](https://github.com/Tinkoff/gatling-kafka-plugin)
```
lazy val gatlingKafka: Seq[ModuleID] = Seq(
"ru.tinkoff" %% "gatling-kafka-plugin",
).map(_ % "")
lazy val avro4s: Seq[ModuleID] = Seq(
"com.sksamuel.avro4s" %% "avro4s-core")
.map(\_ % "" % "provided")
```
В файле *build.sbt* добавляем новые зависимости.
```
libraryDependencies ++= gatlingKafka,
libraryDependencies ++= avro4s,
```
Для обновления зависимостей нажимаем *Load sbt Changes* через интерфейс IntelliJ IDEA.
#### Шаг 2. Переменные сервиса
Для локального подключения к Kafka указываем ее адрес в файле *src/test/resources/simulation.conf.*
```
kafkaBroker: "localhost:9093"
```
#### Шаг 3. Запросы
В директории cases создаем новый scala-класс, где будем писать запросы. Назовем его KafkaActions. Пишем запрос для отправки сообщения в топик *myTopic*, который мы создали в момент разворачивания Kafka.
```
package ru.tinkoff.load.myKafkaSample.cases
import io.gatling.core.Predef.
import ru.tinkoff.gatling.kafka.Predef.kafka
import ru.tinkoff.gatling.kafka.request.builder.RequestBuilder
object kafkaActions {
val sendMyMessage: RequestBuilder[_, Any] =
// Указываем имя запроса
kafka("my message")
// Указываем ключ и сообщение
.send("myMessage", "Hello!")
val sendOtherMessage: RequestBuilder[_, Any] = kafka("my other message")
.send("myMessage", "Hello, ${name}!")
}
```
Для отправки сообщения *sendOtherMessage* используем feeder, создаем для него директорию *feeders*. И в ней же — *object Feeders*.
```
package ru.tinkoff.load.myKafkaSample.feeders
import ru.tinkoff.gatling.feeders.RandomStringFeeder
object Feeders {
// Создаем фидер для генерации строки 6 случайных символов
val myRandomStringFeeder = RandomStringFeeder("name", 6)
}
```
#### Шаг 4. Сценарий теста
В *CommonScenario* меняем код для выполнения наших запросов. При такой реализации запросы будут выполняться последовательно в указанном порядке.
```
package ru.tinkoff.load.myKafkaSample.scenarios
import io.gatling.core.Predef.
import io.gatling.core.structure.ScenarioBuilder
import ru.tinkoff.load.myKafkaSample.cases.
import ru.tinkoff.gatling.kafka.Predef.
import ru.tinkoff.load.myKafkaSample.feeders.Feeders.myRandomStringFeeder
object CommonScenario {
def apply(): ScenarioBuilder = new CommonScenario().scn
}
class CommonScenario {
val scn: ScenarioBuilder =
// Указываем название сценария
scenario("Common Scenario")
// Подключаем feeder
.feed(myRandomStringFeeder)
// Отправляем сообщения
.exec(kafkaActions.sendMyMessage)
.exec(kafkaActions.sendOtherMessage)
}
```
#### Шаг 5. Описание Kafka-протокола
В файле *myKafkaSample.scala* описываем протокол для работы с Kafka.
```
package ru.tinkoff.load
import org.apache.kafka.clients.producer.ProducerConfig
import ru.tinkoff.gatling.config.SimulationConfig.
import ru.tinkoff.gatling.kafka.Predef.kafka
import ru.tinkoff.gatling.kafka.protocol.KafkaProtocolBuilder
package object myKafkaSample {
val kafkaProtocol: KafkaProtocolBuilder = kafka
// Указываем название топика
.topic("myTopic")
.properties(
Map(
ProducerConfig.ACKS_CONFIG -> "1",
// Указываем kafka brokers
ProducerConfig.BOOTSTRAP_SERVERS_CONFIG -> getStringParam("kafkaBroker"),
// Указываем тип ключа и сообщения
ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringSerializer",
ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringSerializer",
),
)
}
```
#### Шаг 6. Нагрузочные тесты
Описываем, как будем подавать нагрузку, в файле *Debug.scala*.
```
package ru.tinkoff.load.myKafkaSample
import io.gatling.core.Predef.
import ru.tinkoff.gatling.kafka.Predef._
import ru.tinkoff.load.myKafkaSample.scenarios.CommonScenario
class Debug extends Simulation {
setUp(
// Вызываем сценарий
CommonScenario()
// Задаем интенсивность
.inject(atOnceUsers(1)),
).protocols(
// Указываем протокол
kafkaProtocol,
)
}
```
По аналогии изменяем протокол в *MaxPerformance* и *Stability*.
#### Шаг 7. Запуск Debug-теста
Для запуска теста используем *GatlingRunner*. После выполнения скрипта можно подключиться к нашей тестовой Kafka, используя KafkaTool, и проверить, что сообщения появились в топике.
```
package ru.tinkoff.load.myKafkaSample
import io.gatling.app.Gatling
import io.gatling.core.config.GatlingPropertiesBuilder
object GatlingRunner {
def main(args: Array[String]): Unit = {
// Указывает имя симуляции Debug (можно использовать любую симуляцию)
val simulationClass = classOf[Debug].getName
val props = new GatlingPropertiesBuilder
props.simulationClass(simulationClass)
Gatling.fromMap(props.build)
}
}
```
Заключение
----------
В этой статье цикла о Gatling мы узнали, как с помощью плагина можно формировать и отправлять сообщения в Kafka. Если вам нужно использовать avro-схемы, скачать их можно, используя плагин [SBT Schema Registry.](https://github.com/Tinkoff/sbt-schema-registry-plugin) Мы планируем расширять функционал плагина — в следующих версиях с его помощью можно будет читать сообщения из Kafka.
Все плагины, использованные в цикле статей о Gatling, есть в открытом доступе. Если вы хотите внести свой вклад в развитие плагинов, которые упоминались в нашем цикле статей, мы будем рады получить PR или issue на [GitHub.](https://github.com/Tinkoff) В следующей статье мы разберемся, как писать скрипты Gatling для протокола AMQP.
Полезные ссылки
---------------
1. [Gatling Kafka Plugin](https://github.com/TinkoffCreditSystems/gatling-kafka-plugin)
2. [SBT Schema Registry Plugin](https://github.com/Tinkoff/sbt-schema-registry-plugin)
3. [Официальная документация Kafka](https://kafka.apache.org/documentation/#gettingStarted)
4. [Gatling Feeders](https://gatling.io/docs/gatling/reference/current/session/feeder/)
5. [Проект Gatling из примеров статьи](https://github.com/Tinkoff/gatling-samples/tree/main/gatling-kafka) | https://habr.com/ru/post/666886/ | null | ru | null |
# ScribeJava — даже ваша бабушка сможет работать с OAuth
Именно этой фразой нас приветствует библиотека для работы с OAuth — ScribeJava (<https://github.com/scribejava/scribejava>). Если быть точнее, то фраза звучит так: “Who said OAuth/OAuth2 was difficult? Configuring ScribeJava is **so easy your grandma can do it!** check it out:”.
И это действительно похоже на правду:
```
OAuth20Service service = new ServiceBuilder().apiKey(clientId).apiSecret(clientSecret)
.callback("http://your.site.com/callback").grantType("authorization_code").build(HHApi.instance());
String authorizationUrl = service.getAuthorizationUrl();
OAuth2AccessToken accessToken = service.getAccessToken(code);
```
Готово! Этих трех строчек достаточно, чтобы начать делать OAuth запросы. А сам OAuth запрос можно будет сделать так:
```
OAuthRequest request = new OAuthRequest(Verb.GET, "https://api.hh.ru/me", service);
service.signRequest(accessToken, request);
String response = request.send().getBody();
```
Данные о пользователе у нас в руках (в переменной response). И ни капли понимания, как в деталях работает OAuth. Хотим асинхронные http-запросы? Нам хватит тех же трех строчек. Ниже рассмотрим это на примере.
### 1. OAuth? О чем это?
Большинству сайтов в том или ином виде нужна регистрация пользователей: для комментариев, отслеживания заказов, откликов на вакансии — не важно.
При этом в интернете люди обычно демонстрируют ленивое поведение и не любят заполнять регистрационные формы, особенно если они это уже где-то сделали. На помощь таким сайтам приходит OAuth. Однако статья посвящена не самому протоколу OAuth, поэтому мы поговорим о том, как работать с OAuth, не вдаваясь в подробности и механизм его работы.
Если говорить в двух словах, то OAuth создан для того, чтобы давать авторизацию стороннему серверу (сайту) на получение каких-либо данных с другого ресурса (например, соц.сети). Т.е., например, пользователь ВКонтакте с помощью OAuth может дать право какому-нибудь сайту (например, hh.ru) запросить его данные или сделать от его лица какие-либо действия в сети ВКонтакте. Нужно отметить, что OAuth не создан для идентификации пользователя. Однако, в числе прочего, мы почти всегда можем запросить данные “о себе”, таким образом получив id пользователя и идентифицировав его.
Если пошагово попробовать описать OAuth, то получится примерно так (на примере OAuth2 — он попроще).
1. Мы регистрируем свое приложение на стороннем сайте, получаем client\_id и client\_secret — это делается один раз.
2. Когда к нам приходит пользователь, наш сайт формирует ссылку на сторонний сайт, на котором мы хотим получить авторизацию на получение данных о пользователе. В ссылке обязательно фигурирует client\_id нашего приложения на этом сайте. Далее наш сайт дает пользователю эту ссылку.
3. Пользователь идет по ссылке на сторонний сайт, логинится (если еще не залогинен), одобряет запрашиваемые нами права (например, получение его ФИО) и возвращается к нам с дополнительным GET-параметром ‘code’.
4. Наш сайт напрямую (сервер-сервер) отсылает полученный GET параметр на сторонний сайт и в ответ получает токен (access\_token).
5. Мы делаем запросы на получение данных или совершение каких-либо активностей от имени пользователя, и в каждый запрос добавляем этот access\_token.
### 2. Даже ваша бабушка сможет использовать OAuth
Попробуем разобрать подробнее пример из начала статьи, сделав OAuth запрос на hh.ru. Для этого нам потребуется создать OAuthService, используя билдер ServiceBuilder. Эта строчка кода будет выглядеть так:
```
OAuth20Service service = new ServiceBuilder()
.apiKey(clientId)
.apiSecret(clientSecret)
.callback("http://your.site.com/callback")
.grantType("authorization_code")
.build(HHApi.instance());
```
Вам нужно будет только подставить clientId и clientSecret вашего приложения, которое вы можете получить, зарегистрировав новое приложение на <https://dev.hh.ru>. Также нужно будет указать callback url, куда будет перенаправлен пользователь с нужным нам кодом (code).
```
String authorizationUrl = service.getAuthorizationUrl();
```
Отправляем пользователя на этот адрес. В нашем случае он будет выглядеть примерно так:
[hh.ru/oauth/authorize?response\_type=code&client\_id=UHKBSA...&redirect\_uri=https%3A%2F%2Fhhid.ru%2Foauth2%2Fcode](https://hh.ru/oauth/authorize?response_type=code&client_id=UHKBSA...&redirect_uri=https%3A%2F%2Fhhid.ru%2Foauth2%2Fcode)
Если открыть этот адрес в браузере, пользователь увидит форму логина, затем форму выдачи прав приложению. Если он уже залогинен и/или давал права приложению ранее, то его сразу же перенаправит на указанный нами callback. В нашем случае такой:
[hhid.ru/oauth2/code?code=I2R6O5](https://hhid.ru/oauth2/code?code=I2R6O5)…
Вот этот GET параметр ‘code’ нам и нужен. Меняем его на токен:
```
String code = "I2R6O5...";
OAuth2AccessToken accessToken = service.getAccessToken(code);
```
На этом все! У нас есть токен (OAuth2AccessToken accessToken), если вывести его в консоль, то увидим внутренности:
```
OAuth2AccessToken {
access_token=I55KQQ...,
token_type=bearer,
expires_in=1209599,
refresh_token=PGELQV...,
scope=null}
```
Теперь попробуем получить какие-нибудь данные. Создаем запрос:
```
OAuthRequest request = new OAuthRequest(Verb.GET, "https://api.hh.ru/me", service);
```
Подписываем запрос токеном:
```
service.signRequest(accessToken, request);
```
Отсылаем запрос на hh.ru:
```
Response response = request.send();
```
Выводим результат:
```
System.out.println(response.getCode());
System.out.println(response.getBody());
```
Профит! В консоли мы увидим нечто подобное:
```
200
{"first_name": "Стас", "last_name": "Громов", "middle_name": null, "is_in_search": null, "is_anonymous": false, "resumes_url": null, "is_employer": false, "personal_manager": null, "email": "s.gromov@hh.ru", "manager": null, ...}
```
И нам не пришлось изучать, какие параметры нужно передавать, как это делать, как их шифровать, в каком порядке передавать, и много других нюансов как самого протокола OAuth, так и ее конкретной имплементации у HeadHunter.
ps. Полный код запускаемого примера можно увидеть здесь:
<https://github.com/scribejava/scribejava/blob/master/scribejava-apis/src/test/java/com/github/scribejava/apis/examples/HHExample.java>
Библиотека релизится в maven central, так что подключить ее к проекту будет очень просто:
```
com.github.scribejava
scribejava-apis
2.3.0
```
Если же у вас очень жесткие требования по размеру конечного приложения, то можно взять только core часть, без сборника различных API:
```
com.github.scribejava
scribejava-core
2.3.0
```
### 3.scribe-java -> SubScribe -> ScribeJava или как сделать форк и вернуть долг opensource сообществу
Мы получили данные о пользователе, которые можно использовать как для регистрации нового пользователя, так и для процесса аутентификации старого. Это может понадобиться не только новым сайтам, которым лень заморачиваться с регистрацией, но и старым, уже матерым, таким как hh.ru. Именно с этими мыслями мы и вошли в 2013-й год.
Нужно отметить, что, несмотря на существование относительно неплохих спецификаций OAuth протокола, как это обычно водится, каждый сервер изобретал и изобретает свои модификации. Где-то вольно интерпретируя стандарты, где-то пользуясь свободой, предоставляемой спецификациями, а где-то идя против них ради каких-то своих идей.
На hh.ru мы хотели добавить входы сразу через несколько различных соцсетей, а писать код, работающий с каждой из них, естественно, хотелось по минимуму. Наверняка кто-то уже все написал! Как минимум, список адресов, на которые нужно посылать запросы (а по факту и еще кучка мелких нюансов). Кроме того, хотелось бы по минимуму поддерживать написанный код, и, в случае необходимости, когда, например, соцсеть решит поменять урл, на который нужно идти за токеном, просто обновить версию библиотеки.
Мы изучили существовавшие на тот момент варианты, и так вышло, что самой простой в использовании и одновременно с самой большой базой АПИ, с которыми библиотека работала бы из коробки, оказалась scribe-java от <https://github.com/fernandezpablo85/>. На тот момент она имела несколько, но не все АПИ, которые мы хотели. Ну не страшно, можно дописать недостающие и отдать их в общее пользование.
С этого мы и начали. Но написав первый наш PullRequest на гитхабе, мы узнали, что автор “устал” уже от таких Пулл Реквестов и ответил нам заготовленной статьей на вики о том, что новые API он добавлять не будет ;-( По мнению автора, scribe-java должна была быть маленькой простой библиотекой (возможно без OAuth2 вовсе, оставив только первую версию протокола), а нам хотелось от нее иметь все же истинно “библиотечные” свойства, сборник всех адресов различных АПИ. Ну и это не страшно, если чем-то какая-то библиотека не устраивает, всегда можно сделать форк! Так и появился на свет проект SubScribe. С заголовком из пяти пунктов, которые обозначали основные причины создания нашего форка:
> Main reasons of fork here:
>
> 1.https://github.com/fernandezpablo85/scribe-java/wiki/Scribe-scope-revised
>
> 2.We really think, OAuth2.0 should be here;
>
> 3.We really think, async http should be here for a high-load projects;
>
> 4.We really think, all APIs should be here. With all their specific stuff. It's easier to change/fix/add API here, in this lib, one time, instead of N programmers will do the same things on their sides;
>
> 5. Scribe should be multi-maven-module project. Core and APIs should be deployed as separated artifacts.
>
>
© <https://github.com/hhru/subscribe/blob/a8450ec2ed35ecaa64ef03afc1bd077ce14d8d61/README.md>
Помимо описанного раннее, из причин создания форка можно выделить еще несколько. Будучи одним из самых нагруженных сайтов рунета и джоб-сайтов Европы, нам очень хотелось иметь возможность асинхронной работы. И это никак не входило в планы простой оригинальной библиотеки. Также мы решили исключить “страх” автора, что библиотека станет громоздкой из-за обилия специфичных каким-то отдельным конкретным АПИ фич. Мы разделили проект на два модуля. После некоторых телодвижений, 3-его марта 2014-го года первая версия SubScribe (сразу 2.0) появилась в центральном репозитории Мавена <http://central.maven.org/maven2/ru/hh/oauth/subscribe/subscribe/2.0/>. Где проект и просуществовал до версии 3.4, выпущенной 30-го июня 2015-го года. За это время, набрав немного уже своей собственной популярности и новых фич, новых АПИ, он не забывает бекпортить все вкусности из родителя scribe-java.
Так бы все и оставалось, если бы в начале осени 2015 Pablo Fernandez (<https://github.com/fernandezpablo85>), видимо, окончательно устав от своего детища, не наткнулся бы на наш форк. Пабло сказал, что впечатлен им и видит многое, что хотел бы сделать сам, но не дошли руки, и предложил проработать детали передачи проекта полностью нам. Немного помявшись для приличия, мы приняли предложение, и так появился ScribeJava — по сути переименованный обратно форк SubScribe. С этого момента у библиотеки появилась отдельная организация на github.com — <https://github.com/scribejava>.
На данный момент ScribeJava представляет собой open source проект под крылом hh.ru. Входит в перечень клиентских библиотек на java на главной странице официального сайт протокола OAuth2: <http://oauth.net/2/>. Имеет 280 наблюдателей, 3 106 звездочек и 1 220 форков на github.com.
### 4. Добавим асинхронности и обновим токен на примере работы с Google
Если у вас сильно нагруженный сайт и вы хотите сэкономить потоков и/или просто использовать ning http client, то мы можем попросить ScribeJava использовать асинхронный вариант работы. Для этого нужно, чтобы в вашем classpath присутствовал ning http client
```
com.ning
async-http-client
1.9.32
```
В этот раз будем использовать Асинхронный билдер сервиса ServiceBuilderAsync.
```
OAuth20Service service = new ServiceBuilderAsync()
.apiKey(clientId)
.apiSecret(clientSecret)
.scope("profile") // replace with desired scope
.state("secret" + new Random().nextInt(999_999))
.callback("https://hhid.ru/oauth2/code")
.asyncHttpClientConfig(clientConfig)
.build(GoogleApi20.instance());
```
Единственное отличие здесь — вызов метода asyncHttpClientConfig(clientConfig), в который мы должны отдать конфиг для асинхронного ning http клиента. Для примера, пусть он будет таким:
```
AsyncHttpClientConfig clientConfig = new AsyncHttpClientConfig.Builder()
.setMaxConnections(5)
.setRequestTimeout(10_000)
.setAllowPoolingConnections(false)
.setPooledConnectionIdleTimeout(1_000)
.setReadTimeout(1_000)
.build();
```
Так же Google требует передачи переменной state. Она необходима для защиты от CRSF атаки, но это за пределами интереса нашей статьи. Дальнейшая работа ничем не отличается от примера работы с api.hh.ru, рассмотренного в начале. Отсылаем пользователя по адресу:
```
String authorizationUrl = service.getAuthorizationUrl();
```
А к каждому методу с HTTP походом внутри добавляем постфикс ‘Async’. Т.е. вместо метода getAccessToken будем вызывать метод getAccessTokenAsync.
```
Future accessTokenFuture = service.getAccessTokenAsync("code", null);
```
В ответ мы получим Future (асинхронность ведь). Или же можем опционально передать вторым аргументом Callback, как нам удобнее.
Готово! Просто, не правда ли? Теперь можно отсылать асинхронные запросы (OAuthRequestAsync) в гугл от лица пользователя:
```
OAuth2AccessToken accessToken = accessTokenFuture.get();
OAuthRequestAsync request = new OAuthRequestAsync(Verb.GET, "https://www.googleapis.com/plus/v1/people/me", service);
service.signRequest(accessToken, request);
Response response = request.sendAsync(null).get();
System.out.println(response.getCode());
System.out.println(response.getBody());
```
У полученного OAuthRequestAsync мы вызвали метод sendAsync, который по аналогии опционально ожидает Callback и возвращает нам Future. При этом у нас остается возможность слать синхронные запросы паралельно с асинхронными. Если же мы хотим как-то профорсить асинхронность (или синхронность) запросов, можно попросить ScribeJava сделать это через статический “конфигуратор”:
```
ScribeJavaConfig.setForceTypeOfHttpRequests(ForceTypeOfHttpRequest.FORCE_ASYNC_ONLY_HTTP_REQUESTS);
```
В этом случае, при попытке использовать синхронный вариант ScribeJava, мы будем получать Exception. Возможны и другие варианты, например, не выкидывать Exception, но логировать о каждом таком случае. Или наоборот требовать исключительно синхронной работы.
Рассмотрим здесь еще один полезный момент OAuth — refresh\_token. Дело в том, что получаемый нами access\_token имеет ограниченый срок жизни. И когда он протухает, нам необходимо получить новый токен. Здесь есть два варианта: либо дождаться пользователя и еще раз провести его через весь механизм, либо использовать refresh\_token (его поддерживают не все, но Google, на примере которого мы его попробуем, поддерживает). Итак, для получения свежего access\_token все, что нам нужно, это всего лишь:
```
OAuth2AccessToken refreshedAccessToken accessToken = service.refreshAccessToken(accessToken.getRefreshToken());
```
или для асинхронного варианта:
```
Future refreshedAccessTokenFuture = service.refreshAccessTokenAsync(accessToken.getRefreshToken(), null);
```
Стоит отметить, что в случае с Google refresh\_token, который нужно передать в метод refreshAccessToken, не придет, если его специально не попросить. Для этого нужно при формировании адреса, на который пойдет пользователь добавить пару параметров:
```
//передать access_type=offline чтобы получить refresh_token
//https://developers.google.com/identity/protocols/OAuth2WebServer#preparing-to-start-the-oauth-20-flow
Map additionalParams = new HashMap<>();
additionalParams.put("access\_type", "offline");
//Google отдаст refresh\_token только на первый offline запрос, если нужно еще раз, нужно явно это попросить параметром prompt
additionalParams.put("prompt", "consent");
String authorizationUrl = service.getAuthorizationUrl(additionalParams);
```
ps. Этот и другие примеры в запускаемом виде (со статическим методом main) тут: <https://github.com/scribejava/scribejava/tree/master/scribejava-apis/src/test/java/com/github/scribejava/apis/examples>
### 5. Полезные ссылки
1.ScribeJava на github.com <https://github.com/scribejava/scribejava>
2.документация api.hh.ru <https://github.com/hhru/api>
3.документация Google <https://developers.google.com/identity/protocols/OAuth2WebServer>
4.RFC OAuth2 <http://tools.ietf.org/html/rfc6749>
5.javadoc online <http://www.javadoc.io/doc/com.github.scribejava/scribejava-core>
### Post Scriptum
Комментарии очень приветствуются. Особенно в виде Пулл Реквестов на github.com | https://habr.com/ru/post/278957/ | null | ru | null |
# Пишем свою ОС: Выпуск 1
Данный цикл статей посвящён низкоуровневому программированию, то есть архитектуре компьютера, устройству операционных систем, программированию на языке ассемблера и смежным областям. Пока что написанием занимаются два хабраюзера — [iley](https://habr.com/ru/users/iley/) и [pehat](https://habr.com/ru/users/pehat/). Для многих старшеклассников, студентов, да и профессиональных программистов эти темы оказываются весьма сложными при обучении. Существует много литературы и курсов, посвящённых низкоуровневому программированию, но по ним сложно составить полную и всеохватывающую картину. Сложно, прочитав одну-две книги по ассемблеру и операционным системам, хотя бы в общих чертах представить, как же на самом деле работает эта сложная система из железа, кремния и множества программ — компьютер.
Каждый решает проблему обучения по-своему. Кто-то читает много литературы, кто-то старается поскорее перейти к практике и разбираться по ходу дела, кто-то пытается объяснять друзьям всё, что сам изучает. А мы решили совместить эти подходы. Итак, в этом курсе статей мы будем шаг за шагом демонстрировать, как пишется простая операционная система. Статьи будут носить обзорный характер, то есть в них не будет исчерпывающих теоретических сведений, однако мы будем всегда стараться предоставить ссылки на хорошие теоретические материалы и ответить на все возникающие вопросы. Чёткого плана у нас нет, так что многие важные решения будут приниматься по ходу дела, с учётом ваших отзывов.
Возможно, мы умышленно будем заводить процесс разработки в тупик, чтобы позволить вам и себе полностью осознать все последствия неверно принятого решения, а также отточить на нем некоторые технические навыки. Так что не стоит воспринимать наши решения как единственно верные и слепо нам верить. Еще раз подчеркнём, что мы ожидаем от читателей активности в обсуждении статей, которая должна сильно влиять на общий процесс разработки и написания последующих статей. В идеале хотелось бы, чтобы со временем некоторые из читателей присоединились к разработке системы.
Мы будем предполагать, что читатель уже знаком с основами языков ассемблер и Си, а также элементарными понятиями архитектуры ЭВМ. То есть, мы не будем объяснять, что такое регистр или, скажем, оперативная память. Если вам не будет хватать знаний, вы всегда можете обратиться к дополнительной литературе. Краткий список литературы и ссылки на сайты с хорошими статьями есть в конце статьи. Также желательно уметь пользоваться Linux, так как все инструкции по компиляции будут приводиться именно для этой системы.
А теперь — ближе к делу. В оставшейся части статьи мы с вами напишем классическую программу «Hello World». Наш хеллоуворлд получится немного специфическим. Он будет запускаться не из какой-либо операционной системы, а напрямую, так сказать «на голом железе». Перед тем, как приступить непосредственно к написанию кода, давайте разберёмся, как же конкретно мы пытаемся это сделать. А для этого надо рассмотреть процесс загрузки компьютера.
Итак, берем свой любимый компьютер и нажимаем самую большую кнопочку на системном блоке. Видим веселую заставку, системный блок радостно пищит спикером и через какое-то время загружается операционная система. Как вы понимаете, операционная система хранится на жёстком диске, и вот тут возникает вопрос: а каким же волшебным образом операционная система загрузилась в ОЗУ и начала выполняться?
Знайте же: за это отвечает система, которая есть на любом компьютере, и имя ей — нет, не Windows, типун вам на язык — называется она BIOS. Расшифровывается ее название как Basic Input-Output System, то есть базовая система ввода-вывода. Находится BIOS на маленькой микросхемке на материнской плате и запускается сразу после нажатия большой кнопки ВКЛ. У BIOS три главных задачи:1. Обнаружить все подключенные устройства (процессор, клавиатуру, монитор, оперативную память, видеокарту, голову, руки, крылья, ноги и хвосты…) и проверить их на работоспособность. Отвечает за это программа POST (Power On Self Test – самотестирование при нажатии ВКЛ). Если жизненно важное железо не обнаружено, то никакой софт помочь не сможет, и на этом месте системный динамик пропищит что-нибудь зловещее и до ОС дело вообще не дойдет. Не будем о печальном, предположим, что у нас есть полностью рабочий компьютер, возрадуемся и перейдем к рассмотрению второй функции BIOS:
2. Предоставление операционной системе базового набора функций для работы с железом. Например, через функции BIOS можно вывести текст на экране или считать данные с клавиатуры. Потому она и называется базовой системой ввода-вывода. Обычно операционная система получает доступ к этим функциям посредством прерываний.
3. Запуск загрузчика операционной системы. При этом, как правило, считывается загрузочный сектор — первый сектор носителя информации (дискета, жесткий диск, компакт-диск, флэшка). Порядок опроса носителей можно задать в BIOS SETUP. В загрузочном секторе содержится программа, иногда называемая первичным загрузчиком. Грубо говоря, задача загрузчика — начать запуск операционной системы. Процесс загрузки операционной системы может быть весьма специфичен и сильно зависит от её особенностей. Поэтому первичный загрузчик пишется непосредственно разработчиками ОС и при установке записывается в загрузочный сектор. В момент запуска загрузчика процессор находится в реальном режиме.
Печальная новость: размер начального загрузчика должен быть всего 512 байт. Почему так мало? Для этого нам надо ознакомиться с устройством дискеты. Вот познавательная картинка:
На картинке изображена поверхность дискового накопителя. У дискеты 2 поверхности. На каждой поверхности есть кольцеобразные дорожки (треки). Каждый трек делится на маленькие дугообразные кусочки, называемые секторами. Так вот, исторически сложилось, что сектор дискеты имеет размер 512 байт. Самый первый сектор на диске, загрузочный сектор, читается BIOS'ом в нулевой сегмент памяти по смещению 0x7С00, и дальше по этому адресу передается управление. Начальный загрузчик обычно загружает в память не саму ОС, а другую программу-загрузчик, хранящуюся на диске, но по каким-то причинам (скорее всего, эта причина — размер) не влезающую в один сектор. А поскольку пока что роль нашей ОС выполняет банальный хеллоуворлд, наша главная цель — заставить компьютер поверить в существование нашей ОС, пусть даже и на одном секторе, и запустить её.
Как устроен загрузочный сектор? На PC единственное требование к загрузочному сектору — это содержание в двух его последних байтах значений 0x55 и 0xAA — сигнатуры загрузочного сектора. Итак, уже более-менее понятно, что нам нужно делать. Давайте же писать код! Приведённый код написан для ассемблера [yasm](http://www.tortall.net/projects/yasm/).
```
section .text
use16
org 0x7C00 ; наша программа загружается по адресу 0x7C00
start:
mov ax, cs
mov ds, ax ; выбираем сегмент данных
mov si, message
cld ; направление для строковых команд
mov ah, 0x0E ; номер функции BIOS
mov bh, 0x00 ; страница видеопамяти
puts_loop:
lodsb ; загружаем очередной символ в al
test al, al ; нулевой символ означает конец строки
jz puts_loop_exit
int 0x10 ; вызываем функцию BIOS
jmp puts_loop
puts_loop_exit:
jmp $ ; вечный цикл
message:
db 'Hello World!', 0
finish:
times 0x1FE-finish+start db 0
db 0x55, 0xAA ; сигнатура загрузочного сектора
```
Эта короткая программа требует ряда важных пояснений. Строка `org 0x7C00` нужна для того, чтобы ассемблер (имеется в виду программа, а не язык) правильно рассчитал адреса для меток и переменных (`puts_loop, puts_loop_exit, message`). Вот мы ему и сообщаем, что программа будет загружена в память по адресу 0x7C00.
В строках
```
mov ax, cs
mov ds, ax
```
происходит установка сегмента данных (`ds`) равным сегменту кода (`cs`), поскольку в нашей программе и данные, и код хранятся в одном сегменте.
Далее в цикле посимвольно выводится сообщение «Hello World!». Для этого используется функция `0x0E` прерывания `0x10`. Она имеет следующие параметры:
`AH = 0x0E` (номер функции)
`BH =` номер видеостраницы (пока не заморачиваемся, указываем 0)
`AL =` ASCII-код символа
В строке «`jmp $`» программа зависает. И правильно, незачем ей выполнять лишний код. Однако чтобы компьютер опять заработал, придется перезагрузиться.
В строке «`times 0x1FE-finish+start db 0`» производится заполнение остатка кода программы (за исключением последних двух байт) нулями. Делается это для того, чтобы после компиляции в последних двух байтах программы оказалась сигнатура загрузочного сектора.
С кодом программы вроде разобрались, давайте теперь попробуем скомпилировать это счастье. Для компиляции нам понадобится, собственно говоря, ассемблер — выше упомянутый [yasm](http://www.tortall.net/projects/yasm/). Он есть в большинстве репозиториев Linux. Программу можно откомпилировать следующим образом:
```
$ yasm -f bin -o hello.bin hello.asm
```
Полученный файл hello.bin нужно записать в зарузочный сектор дискеты. Делается это примерно так (разумеется, вместо fd нужно подставить имя своего дисковода).
```
$ dd if=hello.bin of=/dev/fd
```
Поскольку далеко не у всех остались дисководы и дискеты, можно воспользоваться виртуальной машиной, например, [qemu](http://wiki.qemu.org/Main_Page) или [VirtualBox](http://virtualbox.org). Для этого придётся сделать образ дискеты с нашим загрузчиком и вставить его в «виртуальный дисковод».
Создаём образ диска и заполняем его нулями:
```
$ dd if=/dev/zero of=disk.img bs=1024 count=1440
```
Записываем в самое начало образа нашу программу:
```
$ dd if=hello.bin of=disk.img conv=notrunc
```
Запускаем полученный образ в qemu:
```
$ qemu -fda disk.img -boot a
```
После запуска вы должны увидеть окошко qemu с радостной строчкой «Hello World!». На этом первая статья заканчивается. Будем рады увидеть ваши отзывы и пожелания.
**Литература**1. По языку ассемблера:
* Зубков С. В. «Assembler для DOS, Windows и Unix»
* [Введение в машинный код](http://wasm.ru/article.php?article=1022001)
* [Программирование на ассемблере под DOS](http://wasm.ru/article.php?article=1022003)
2. По языку Си:
* Керниган Б., Ритчи Д. «Язык программирования C»
* Шилдт Г. «Полный справочник по C»
3. По устройству операционных систем:
* Таненбаум Э. «Современные операционные системы»
* Таненбаум Э. «Операционные системы: Разработка и реализация»
* Олифер В., Олифер Н. «Сетевые операционные системы»
* <http://osdev.org>
4. По архитектуре ЭВМ:
* Таненбаум Э. «Архитектура компьютера»
* Гук М. «Аппаратные средства IBM PC. Энциклопедия»
* Петцольд Ч. «Код. Тайный язык информатики»
5. Справочная информация
* [Dan Rollins’s TechHelp](http://webpages.charter.net/danrollins/techhelp/index.htm)
* [Intel Software Developer Manual](http://www.intel.com/products/processor/manuals/) | https://habr.com/ru/post/101810/ | null | ru | null |
# Как удалить татуировку с помощью глубокого обучения
Глубокое обучение — интересная тема и моя любимая область исследований. Мне очень нравится играть с новыми исследовательскими разработками специалистов по глубокому обучению. Я только что наткнулся на удивительный репозиторий GitHub одного из моих товарищей по группе компьютерного зрения. Мне он так понравился, что я решил поделиться им. Основа репозитория — генеративно-состязательная сеть (GAN), которая способна удалять татуировки с тела. В преддверии старта нового потока курса по [Machine Learning и Deep Learning](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=200421), расскажу вам шаг за шагом, как применять упомянутый репозиторий на примере фотографии в Pexels.
---
### Запуск Google Colab
Google Colab бесплатно предоставляет мощные возможности графического процессора, чтобы выполнять или обучать наши модели глубокого обучения за меньшее время. Введите в браузере следующий URL-адрес и нажмите клавишу Enter:
```
https://colab.research.google.com/
```
После запуска войдите в свою учётную запись Google. Если вы уже вошли, платформа просто выберет основную учётную запись для входа. Не беспокойтесь! Ваши данные здесь в безопасности. После входа перейдите к файлу и откройте новую записную книжку.
### Клонирование репозитория GitHub
Теперь в только что созданной записной книжке мы должны выполнить такую команду:
```
!git clone https://github.com/vijishmadhavan/SkinDeep.git SkinDeep
```
Эта команда клонирует код GitHub в вашу среду Colab.Теперь, на следующем шаге, мы должны использовать клонированный репозиторий. Для этого в соседней ячейке записной книжки выполните эту команду:
```
cd SkinDeep
```
### Установка библиотек
Чтобы установить все необходимые библиотеки, в очередной ячейке выполните:
```
!pip install -r colab_requirements.txt
```
### Определение архитектуры модели
Теперь настало время инициализировать архитектуру модели. Архитектура доступна в том же [репозитории GitHub](https://github.com/vijishmadhavan/SkinDeep), который мы клонировали. Чтобы инициализировать модель, в соседней ячейке выполните следующий код:
```
import fastai
from fastai.vision import *
from fastai.utils.mem import *
from fastai.vision import open_image, load_learner, image, torch
import numpy as np
import urllib.request
import PIL.Image
from io import BytesIO
import torchvision.transforms as T
from PIL import Image
import requests
from io import BytesIO
import fastai
from fastai.vision import *
from fastai.utils.mem import *
from fastai.vision import open_image, load_learner, image, torch
import numpy as np
import urllib.request
import PIL.Image
from io import BytesIO
import torchvision.transforms as T
class FeatureLoss(nn.Module):
def __init__(self, m_feat, layer_ids, layer_wgts):
super().__init__()
self.m_feat = m_feat
self.loss_features = [self.m_feat[i] for i in layer_ids]
self.hooks = hook_outputs(self.loss_features, detach=False)
self.wgts = layer_wgts
self.metric_names = ['pixel',] + [f'feat_{i}' for i in range(len(layer_ids))
] + [f'gram_{i}' for i in range(len(layer_ids))]
def make_features(self, x, clone=False):
self.m_feat(x)
return [(o.clone() if clone else o) for o in self.hooks.stored]
def forward(self, input, target):
out_feat = self.make_features(target, clone=True)
in_feat = self.make_features(input)
self.feat_losses = [base_loss(input,target)]
self.feat_losses += [base_loss(f_in, f_out)*w
for f_in, f_out, w in zip(in_feat, out_feat, self.wgts)]
self.feat_losses += [base_loss(gram_matrix(f_in), gram_matrix(f_out))*w**2 * 5e3
for f_in, f_out, w in zip(in_feat, out_feat, self.wgts)]
self.metrics = dict(zip(self.metric_names, self.feat_losses))
return sum(self.feat_losses)
def __del__(self): self.hooks.remove()
```
### Загрузка файла модели
После инициализации модели [загрузите предварительно обученную модель GAN для удаления татуировок](https://github.com/vijishmadhavan/SkinDeep). В очередной ячейке выполните эти команды:
```
MODEL_URL = "https://www.dropbox.com/s/vxgw0s7ktpla4dk/SkinDeep2.pkl?dl=1"
urllib.request.urlretrieve(MODEL_URL, "SkinDeep2.pkl")
path = Path(".")
learn=load_learner(path, 'SkinDeep2.pkl')
```
### Входное изображение
Наконец, можно определить своё входное изображение для тестирования. В приведённом ниже сегменте кода подставьте URL-адрес изображения.
```
url = 'https://images.pexels.com/photos/5045947/pexels-photo-5045947.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260' #@param {type:"string"}
response = requests.get(url)
img = PIL.Image.open(BytesIO(response.content)).convert("RGB")
img_t = T.ToTensor()(img)
img_fast = Image(img_t)
show_image(img_fast, figsize=(8,8), interpolation='nearest');
```
### Тестирование модели и получение результатов
Начинается самое интересное. Запустим модель, чтобы получить результат. В соседней ячейке выполните следующие строки кода:
```
p,img_hr,b = learn.predict(img_fast)
Image(img_hr).show(figsize=(8,8))
```
### Заключение
Вот и всё. Мы обсудили пошаговое реальное применение модели SkinDeep для удаления татуировок с кожи. Подобные забавы — лишь малая демонстрация потенциала глубокого обучение. Оно способно способно генерировать новые функции без вмешательства человека, из ограниченного набора функций, расположенных в наборе учебных данных. Для специалистов это означает, что они могут использовать более сложные наборы функций по сравнению с традиционным ПО для машинного обучения. Если вас заинтересовала эта сфера — ждем вас на расширенном курсе [Machine Learning и Deep Learning](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=200421), в котором мы совместили изучение DL с классическим курсом по ML, чтобы студент начал с основ и постепенно перешел к более сложным вещам.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=200421), как прокачаться и в других специальностях или освоить их с нуля:
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=200421)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=200421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=200421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=200421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=200421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=200421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=200421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=200421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=200421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=200421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=200421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=200421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=200421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=200421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=200421)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=200421)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=200421)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=200421)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=200421)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=200421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=200421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=200421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=200421) | https://habr.com/ru/post/553208/ | null | ru | null |
# Введение в графовые базы данных SQL Server 2017
***В преддверии старта курса [«MS SQL Server Developer»](https://otus.pw/ZzuM/) подготовили для вас еще один полезный перевод.***
---
Графовые базы данных — это важная технология для специалистов по базам данных. Я стараюсь следить за инновациями и новыми технологиями в этой области и, после работы с реляционными и NoSQL базами данных, я вижу, что роль графовых баз данных становится все больше. В работе со сложными иерархическими данными малоэффективны не только традиционные базы данных, но и NoSQL. Часто, с увеличением количества уровней связей и размера базы, наблюдается снижение производительности. А с усложнением взаимосвязей увеличивается и количество JOIN.
Конечно, в реляционной модели есть решения для работы с иерархиями (например, с помощью рекурсивных CTE), но это все равно остается обходными путями. При этом, функционал графовых баз данных SQL Server позволяет с легкостью обрабатывать несколько уровней иерархии. Упрощаются как модель данных, так и запросы, а следовательно, увеличивается их эффективность. Значительно сокращается объем кода.
Графовые базы данных — это выразительный язык для представления сложных систем. Эта технология уже довольно широко используется в ИТ-индустрии в таких областях, как социальные сети, антифрод-системы, анализ ИТ-сетей, социальные рекомендации, рекомендации по продуктам и контенту.
Функционал графовых баз данных в SQL Server подходит для сценариев, в которых данные сильно связаны между собой и имеют четко определенные связи.
### Графовая модель данных
Граф — это множество вершин (узлов, node) и ребер (взаимосвязей, edge). Вершины представляют сущности, а ребра — связи, в атрибутах которых может содержаться информация.
Графовая база данных моделирует сущности в виде графа в том виде, как это определено в теории графов. Структуры данных — это вершины и ребра. Атрибуты — это свойства вершин и ребер. Связь — это соединение вершин.
В отличие от других моделей данных, в графовых базах данных в приоритете взаимосвязи между сущностями. Поэтому не требуется вычислять связи с помощью внешних ключей или какими-то другими способами. Можно создавать сложные модели данных, используя только абстракции вершин и ребер.
В современном мире моделирование взаимосвязей требует все более сложных методик. Для моделирования связей SQL Server 2017 предлагает возможности графовых баз данных. Вершины и ребра графа представляются в виде новых типов таблиц: NODE и EDGE. Для запросов к графу используется новая функция T-SQL под названием MATCH(). Так как этот функционал встроен в SQL Server 2017, то его можно использовать в ваших существующих базах данных без необходимости какой-либо их конвертации.
### Польза графовой модели
В настоящее время бизнес и пользователи требуют приложений, которые работают все с большим и большим объемом данных, ожидая при этом высокой производительности и надежности. Представление данных в виде графа предлагает удобные средства для обработки сложных связей. Этот подход позволяет решить многие проблемы и помогает получить результаты в рамках заданного контекста.
Судя по всему, в будущем многие приложения смогут выиграть от использования графовых баз данных.
### Моделирование данных: от реляционной модели к графовой
**Пример**
Давайте рассмотрим пример организационной структуры с иерархией сотрудников: сотрудник подчиняется менеджеру, менеджер — старшему менеджеру и так далее. В зависимости от конкретной компании в этой иерархии может быть любое количество уровней. Но с увеличением количества уровней вычисление связей в реляционной базе данных становится все сложнее и сложнее. В ней довольно сложно представить иерархию сотрудников, иерархию в маркетинге или связи в социальных сетях. Давайте посмотрим, как с помощью SQL Graph можно решить проблему с обработкой различных уровней иерархии.
Для этого примера сделаем простую модель данных. Создадим таблицу сотрудников **EMP** с идентификатором **EMPNO** и колонкой **MGR**, указывающей на идентификатор руководителя (менеджера) сотрудника. Вся информация об иерархии хранится в этой таблице и может быть запрошена с помощью колонок **EMPNO** и **MGR**.
На следующей диаграмме изображена так же самая модель оргструктуры с четырьмя уровнями вложенности в более привычном виде. Сотрудники — это вершины графа из таблицы **EMP**. Сущность «сотрудник» связана сама с собою связью «подчиняется» (ReportsTo). В терминах графа, связь — это ребро (EDGE), которое связывает узлы (NODE) сотрудников.
Давайте создадим обычную таблицу **EMP** и добавим туда значения в соответствии с вышеприведенной диаграммой.
```
CREATE TABLE EMP
(EMPNO INT NOT NULL,
ENAME VARCHAR(20),
JOB VARCHAR(10),
MGR INT,
JOINDATE DATETIME,
SALARY DECIMAL(7, 2),
COMMISIION DECIMAL(7, 2),
DNO INT)
INSERT INTO EMP VALUES
(7369, 'SMITH', 'CLERK', 7902, '02-MAR-1970', 8000, NULL, 2),
(7499, 'ALLEN', 'SALESMAN', 7698, '20-MAR-1971', 1600, 3000, 3),
(7521, 'WARD', 'SALESMAN', 7698, '07-FEB-1983', 1250, 5000, 3),
(7566, 'JONES', 'MANAGER', 7839, '02-JUN-1961', 2975, 50000, 2),
(7654, 'MARTIN', 'SALESMAN', 7698, '28-FEB-1971', 1250, 14000, 3),
(7698, 'BLAKE', 'MANAGER', 7839, '01-JAN-1988', 2850, 12000, 3),
(7782, 'CLARK', 'MANAGER', 7839, '09-APR-1971', 2450, 13000, 1),
(7788, 'SCOTT', 'ANALYST', 7566, '09-DEC-1982', 3000, 1200, 2),
(7839, 'KING', 'PRESIDENT', NULL, '17-JUL-1971', 5000, 1456, 1),
(7844, 'TURNER', 'SALESMAN', 7698, '08-AUG-1971', 1500, 0, 3),
(7876, 'ADAMS', 'CLERK', 7788, '12-MAR-1973', 1100, 0, 2),
(7900, 'JAMES', 'CLERK', 7698, '03-NOV-1971', 950, 0, 3),
(7902, 'FORD', 'ANALYST', 7566, '04-MAR-1961', 3000, 0, 2),
(7934, 'MILLER', 'CLERK', 7782, '21-JAN-1972', 1300, 0, 1)
```
На приведенном ниже рисунке показаны сотрудники:
* сотрудник с **EMPNO** 7369 подчиняется 7902;
* сотрудник с **EMPNO** 7902 подчиняется 7566
* сотрудник с **EMPNO** 7566 подчиняется 7839
Теперь давайте посмотрим на представление тех же данных в виде графа. Вершина EMPLOYEE имеет несколько атрибутов и связана сама с собой связью «подчиняется» (EmplReportsTo). EmplReportsTo — это название связи.
*В таблице ребер (EDGE) также могут присутствовать атрибуты.*
**Создадим таблицу узлов EmpNode**
Синтаксис создания узла довольно прост: к выражению **CREATE TABLE** в конец добавляется **«AS NODE»**.
```
CREATE TABLE dbo.EmpNode(
ID Int Identity(1,1),
EMPNO NUMERIC(4) NOT NULL,
ENAME VARCHAR(10),
MGR NUMERIC(4),
DNO INT
) AS NODE;
```
Теперь преобразуем данные из обычной таблицы в графовую. Следующий **INSERT** вставляет данные из реляционной таблицы **EMP**.
```
INSERT INTO EmpNode(EMPNO,ENAME,MGR,DNO) select empno,ename,MGR,dno from emp
```
В таблице узлов в специальной колонке **`$node_id_*`** хранится идентификатор узла в виде JSON. В остальных столбцах этой таблицы находятся атрибуты узла.
**Создаем ребра (EDGE)**
Создание таблицы ребер очень похоже на создание таблицы узлов, за исключением того, что используется ключевое слово **«AS EDGE»**.
```
CREATE TABLE empReportsTo(Deptno int) AS EDGE
```
Теперь определим связи между сотрудниками, используя столбцы **EMPNO** и **MGR**. По диаграмме оргструктуры хорошо видно как написать **INSERT**.
```
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 1),
(SELECT $node_id FROM EmpNode WHERE id = 13),20);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 2),
(SELECT $node_id FROM EmpNode WHERE id = 6),10);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 3),
(SELECT $node_id FROM EmpNode WHERE id = 6),10)
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 4),
(SELECT $node_id FROM EmpNode WHERE id = 9),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 5),
(SELECT $node_id FROM EmpNode WHERE id = 6),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 6),
(SELECT $node_id FROM EmpNode WHERE id = 9),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 7),
(SELECT $node_id FROM EmpNode WHERE id = 9),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 8),
(SELECT $node_id FROM EmpNode WHERE id = 4),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 9),
(SELECT $node_id FROM EmpNode WHERE id = 9),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 10),
(SELECT $node_id FROM EmpNode WHERE id = 6),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 11),
(SELECT $node_id FROM EmpNode WHERE id = 8),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 12),
(SELECT $node_id FROM EmpNode WHERE id = 6),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 13),
(SELECT $node_id FROM EmpNode WHERE id = 4),30);
INSERT INTO empReportsTo VALUES ((SELECT $node_id FROM EmpNode WHERE ID = 14),
(SELECT $node_id FROM EmpNode WHERE id = 7),30);
```
Таблица ребер по умолчанию состоит из трех столбцов. Первый, **`$edge_id`** — идентификатор ребра в виде JSON. Два других (**`$from_id`** и **`$to_id`**) представляют связь между узлами. Кроме того, ребра могут иметь дополнительные свойства. В нашем случае это **Deptno**.
### Системные представления
В системном представлении `sys.tables` появилось две новые колонки:
1. is\_edge
2. is\_node
```
SELECT t.is_edge,t.is_node,*
FROM sys.tables t
WHERE name like 'emp%'
```
### SSMS
Объекты, связанные с графами, располагаются в папке Graph Tables. Иконка таблицы узлов помечена точкой, а таблицы ребер — двумя связанными кругами (что немного похоже на очки).
### Выражение MATCH
Выражение **MATCH** взято из CQL (Cypher Query Language). Это эффективный способ запроса к свойствам графа. CQL начинается с выражения **MATCH**.
**Синтаксис**
```
MATCH ()
::=
{ {
{ <-( )- }
| { -( )-> }
}
}
[ { AND } { ( ) } ]
[ ,...n ]
::=
node\_table\_name | node\_alias
::=
edge\_table\_name | edge\_alias
```
**Примеры**
Давайте посмотрим на несколько примеров.
Приведенный ниже запрос отображает сотрудников, которым подчиняется Smith и его менеджер.
```
SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR
FROM
empnode e, empnode e1, empReportsTo m
WHERE
MATCH(e-(m)->e1)
and e.ENAME='SMITH'
```
Следующий запрос предназначен для поиска сотрудников и менеджеров второго уровня для Smith. Если убрать предложение **WHERE**, то в результате будут отображаться все сотрудники.
```
SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR
FROM
empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2
WHERE
MATCH(e-(m)->e1-(m1)->e2)
and e.ENAME='SMITH'
```
И, наконец, запрос для сотрудников и менеджеров третьего уровня.
```
SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR,E3.EMPNO,e3.ENAME,E3.MGR
FROM
empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2, empReportsTo M2, empnode e3
WHERE
MATCH(e-(m)->e1-(m1)->e2-(m2)->e3)
and e.ENAME='SMITH'
```
Теперь давайте изменим направление, чтобы получить начальников Smith'а.
```
SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR,E3.EMPNO,e3.ENAME,E3.MGR
FROM
empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2, empReportsTo M2, empnode e3
WHERE
MATCH(e<-(m)-e1<-(m1)-e2<-(m2)-e3)
```
### Заключение
SQL Server 2017 зарекомендовал себя как полноценное корпоративное решение для различных ИТ-задач бизнеса. Первая версия SQL Graph очень многообещающая. Даже несмотря на некоторые ограничения, уже сейчас есть достаточно функционала для изучения возможностей графов.
Функционал SQL Graph полностью интегрирован в SQL Engine. Однако, как уже было сказано, в SQL Server 2017 есть следующие ограничения:
Нет поддержки полиморфизма.
* Поддерживаются только однонаправленные связи.
* У ребер нельзя обновлять столбцы $from\_id и $to\_id через UPDATE.
* Не поддерживаются транзитивные замыкания (transitive closure), но их можно получить с помощью CTE.
* Ограничена поддержка объектов In-Memory OLTP.
* Не поддерживаются темпоральные таблицы (System-Versioned Temporal Table), временные локальные и глобальные таблицы.
* Табличные типы и табличные переменные не могут быть объявлены как NODE или EDGE.
* Не поддерживаются запросы между базами данных (cross-database queries).
* Нет прямого способа или какого-то мастера (wizard) для преобразования обычных таблиц в графовые.
* Для отображения графов нет GUI, но можно использовать Power BI.
[](https://otus.pw/ZzuM/)
> ### Читать ещё:
>
>
>
> * [Как SQL Server использует bitmap-фильтры](https://habr.com/ru/company/otus/blog/516996/)
> | https://habr.com/ru/post/518586/ | null | ru | null |
# Сбор логов межсетевого экрана Checkpoint (OPSEC LEA)
OPSEC LEA (Log Export API) – интерфейс, позволяющий получать логи с сервера управления (Checkpoint SmartCenter).
В основе OPSEC LEA лежит клиент-серверная архитектура. В качестве сервера выступает Checkpoint SmartCenter, который слушает входящие соединения на порт 18184 ТСР (по-умолчанию). Клиент OPSEC LEA подключается к Серверу на вышеуказанный порт и получает логи.
Fw1-loggrabber – программное обеспечение, поддерживающее OPSEC LEA, и предназначенное для получения логов с серверов управления (Checkpoint SmartCenter – далее SC). Fw1-loggrabber может выводить полученные логи на экран, перенаправлять в файл или в syslog.
Существуют версии данного ПО как под Linux, так и под Windows (под windows не поддерживается вывод в syslog).
Дано:
* Сервер управления Checkpoint. Версия ПО Checkpoint – R77.30 (sc.local);
* Сервер с CentOS 6.6 (loggraber.local);
* Syslog сервер (syslog.local).
#### **Задача:**
получить логи c SC и передать их по протоколу syslog на внешний syslog сервер.
#### **Решение:**
Для решения данной задачи мы будем использовать технологию связи fw1-loggrabber и SC под названием «sslca», которая требует аутентификации. Также возможно использовать и другие механизмы, в том числе без аутентификации, которые описаны в MAN’е fw1-loggrabber. Мы будем использовать sslca во-первых потому, что он обеспечивает более безопасное соединение (за счет наличия аутентификации), а также сама компания Checkpoint обещает продолжить его поддержку в будущих продуктах.
Схема стенда приведена на рисунке ниже.
**Рисунок 1** – Схема стенда FW1-loggrabber
Для решения задачи необходимо будет выполнить:
1. Установку fw1-loggrabber на сервер loggrabber.local;
2. Создание объекта OPSEC LEA на стороне Checkpoint SC;
3. Настройка сервера управления Checkpoint;
4. Настройку fw1-loggrabber.
##### **1. Установка fw1-loggrabber**
Для установки нужно скачать само ПО loggrabber (https://sourceforge.net/projects/fw1-loggrabber/), распаковать архив и запустить файл INSTALL.sh из-под учетной записи root в распакованной папке:
```
# gzip –d fw1-loggrabber-1.11.1-linux.tar.gz
# tar xvf fw1-loggrabber-1.11.1-linux.tar
# cd fw1-loggrabber-1.11.1-linux
# ./INSTALL.sh
```
Инсталляционный скрипт скопирует файлы loggrabber в /usr/local/fw1-loggrabber. На этом установка закончена. Переходим к настройке.
##### **2. Создание объекта OPSEC LEA**
Подключившись к консоли управления сервера sc.local с помощью графического клиента SmartConsole создаем объект Syslogclient (см. Рисунок 2).
В поле «host» указываем объект, представляющий собой хост loggraber.local, в таблице «Client Entities» выбираем «LEA». Нажимаем кнопку «Communicate» для задания SIC для установки соединения. Парольную фразу, используемую при создании SIC необходимо запомнить, она понадобится позже. Копируем и сохраняем в текстовый файл DN объекта — CN=Syslogclient,O=cpmgmt.hemltd.ru.ukwt9b, т.к. он понадобится на следующем этапе.
**Рисунок 2** – Настройка OPSEC объекта в Checkpoint
Записываем также DN сервера управления Checkpoint (sc.local), который можно найти нажав на кнопку «Test SIC status» в меню «General» объекта, соответствующего серверу управления Checkpoint в интерфейсе графической консоли (см. Рисунок 3). В данном примере это: cn=cp\_mgmt,o=cpmgmt.hemltd.ru.ukwt9b
**Рисунок 3** – DN сервера управления Checkpoint (sc.local)
##### **3. Настройка сервера управления Checkpoint**
Подключаемся к серверу управления Checkpoint (sc.local) по ssh, переходим в режим expert и добавляем (или модифицируем) в файл $FWDIR/conf/fwopsec.conf следующие строки:
```
lea_server port 0
lea server auth_port 18184
lea server auth_type sslca
```
После чего перезапускаем сервисы Checkpoint:
```
# cpstop
# cpstart
```
Через графическую консоль управления Checkpoint создаем правила межсетевого экранирования, разрешающие трафик по портам tcp 18184 и tcp 18210 (по порту tcp 18210 происходит получение сертификата с сервера Checkpoint сервером loggrabber.local) в направлении от сервера loggrabber.local к sc.local.
Инсталлируем политику.
##### **4. Настройка FW1-loggrabber**
На сервере loggrabber.local устанавливаем утилиту opsec\_pull из пакета opsec-tools или из OPSEC SDK. Эта утилита нужна для установления соединения SIC между fw1-loggrabber и сервера управления Checkpoint.
Получаем сертификат с сервера управления Checkpoint коммандой:
```
# opsec_pull_cert -h 192.168.0.1 -n Syslogclient -p <парольная фраза, использованная при создании SIC на шаге 2>
```
Полученный файл помещаем в папку fw1-loggraber: /usr/local/fw1-loggrabber
Модифицируем файл /usr/local/fw1-loggrabber/etc/lea.conf следующим образом:
```
lea_server auth_type sslca
lea_server ip 192.168.0.1
lea server port 0
lea_server auth_port 18184
opsec_sic_name "CN=Syslogclient,O=cpmgmt.hemltd.ru.ukwt9b"
opsec_sslca_file /usr/local/fw1-loggrabber/opsec.p12
lea_server opsec_entity_sic_name "cn=cp_mgmt,o=cpmgmt.hemltd.ru.ukwt9b"
```
В качестве lea\_server ip указываем IP адрес сервера sc.local. В качестве opsec\_sic\_name указываем DN объекта OPSEC LEA, созданного на этапе 2. В качестве lea\_server opsec\_entity\_sic\_name указываем DN сервера Checkpoint, полученный на шаге 2. opsec\_sslca\_file должен указывать полный путь до файла сертификата, полученного с сервера Checkpoint (описано в начале этого этапа).
Изменяем файл /usr/local/fw1-loggrabber/etc/fw1-loggrabber.conf следующим образом:
```
DEBUG_LEVEL="0" # выключен debug, для отладки можно поставить 3
FW1_LOGFILE="fw.log" # имя файла лога на стороне сервера Checkpoint
FW1_OUTPUT="logs" # параметр говорит о том, что loggrabber будет получать логи с сервера Checkpoint. Если указать files, то при запуске loggrabber выведет список доступных файлов логов
FW1_TYPE="ng" # для старых версий Checkpoint (Checkpoint FW-1 4.1) указать в данном поле 2000
FW1_MODE="normal" # audit – логи аудита, normal – логи безопасности
ONLINE_MODE="yes" # работа в режиме реального времени. No – тогда loggrabber считывает весь лог и останавливается
RESOLVE_MODE="no" # отключено разрешение DNS имен
SHOW_FIELDNAMES="yes" # включать имена полей в лог
RECORD_SEPARATOR="|" # разделитель полей
DATEFORMAT="std" # формат временной метки
LOGGING_CONFIGURATION=syslog # loggrabber передает логи в syslog, можно в file
OUTPUT_FILE_PREFIX="fw1-loggrabber" # префикс лог файла (в случае записи лога в файл)
OUTPUT_FILE_ROTATESIZE=104857600 # максимальный размер файла
SYSLOG_FACILITY="LOCAL1" # syslog facility
```
Запускаем fw1-loggrabber:
```
/usr/local/fw1-loggrabber/bin/fw1-loggrabber
```
В конфигурационный файл rsyslog добавляем:
```
LOCAL1.* @192.168.0.3
```
И перезапускаем rsyslog:
```
/etc/init.d/rsyslog restart
```
Таким образом, логи, получаемые fw1-loggrabber на сервере loggrabber.local (192.168.0.2) с сервера Checkpoint sc.local (192.168.0.1), перенаправляются в LOCAL1 фасилити rsyslog’а, который отправляет их по сети на сервер syslog.local (192.168.0.3), как показано на рисунке 1. | https://habr.com/ru/post/281164/ | null | ru | null |
# Аутентификация устройств на Linux по аппаратному ключу в системах верхнего уровня
Industrial IoT — это мониторинг, диспетчеризация и автоматизация инженерных систем промышленных объектов, зданий, бизнес-объектов. Датчики разных параметров, счетчики и контроллеры собирают данные с этих объектов, например, температуру и влажность воздуха в серверной, показания счетчиков воды в многоквартирных домах, уровень углекислого газа в помещениях. Контроллеры обрабатывают эту информацию и отправляют все в «облако».
Компания Wiren Board производит контроллеры с Linux для industrial IoT. Устройства собирают данные с нефтедобывающих скважин и банковских отделений, следят за микроклиматом в серверных и супермаркетах. Контроллеры интегрируются с системами верхнего уровня партнеров компании. Системы аутентифицируют устройства — понимают, что разговаривают со своим датчиком, а не с чужим, а потом авторизуют. На этом этапе возникает проблема — контроллеров тысячи, клиентов сотни, а единой системы интеграции нет. Простые традиционные способы, например, пары логин/пароль, уязвимы к атакам и неудобны в развёртывании.
Поэтому в компании разработали аутентификацию в системах верхнего уровня по аппаратным ключам — на основе стандартной асимметричной криптографии с использованием аппаратного защищённого элемента для хранения ключей. Теперь единая система интеграции не нужна —аутентификация и авторизация защищены, и работают «из коробки». Как это удалось сделать расскажет **Евгений Богер**: как выбирали «крипточип», как прикручивали его к железу и к Linux, как заставили с ним дружить распространённые библиотеки и ПО. Особый упор на развёртывание: внедрение инициализации устройств на производстве, внедрение поддержки разного софта верхнего уровня, в том числе в чужого и закрытого.
**О спикере:** **Евгений Богер** ([evgeny\_boger](https://habr.com/ru/users/evgeny_boger/)) — технический директор и сооснователь Wiren Board. Занимается встраиваемыми системами и, в особенности, встраиваемыми Linux.
Проблемы
--------
Начну с того, что мы делаем и откуда у нас эта проблема возникла. Мы в Wiren Board разрабатываем и производим оборудование в России. Раньше это называли M2M, а сейчас — industrial IoT. Это автоматизация инженерных систем зданий, мониторинг и диспетчеризация. Кратко вся работа выглядит так: датчики разных параметров, исполнительные устройства, счетчики и контроллеры (edge-computing или IoT-gateway) собирают разные данные с объектов, обрабатывают их, исполняют локальную логику, а потом собираются в одной большой системе диспетчеризации, мониторинга или управления.
У нас нет цельной экосистемы, в отличии от некоторых конкурентов. Мы производим оборудование, которое интегрируется с несколькими системами верхнего уровня наших партнеров. Компаний-партнеров много и они разделяют между собой ответственность. Без хороших технических средств интеграция не будет работать — просто договориться не получается.
Для решения этих проблем есть два простых решения. Первый — **выдать логин/пароль клиенту**, как делают все, а второй — **генерировать и зашивать «секрет» на производстве**. Оба варианта нам не подошли — расскажу почему.
Простые решения
---------------
**Первое решение — выдача логина и пароля клиенту**. Так делают все и мы до недавнего времени.
Для аутентификации устройства, которое отправляет данные в какую-то систему, можно сделать секретный ключ — условно логин/пароль («секрет»). Он будет общий на контроллерах и на системе верхнего уровня, которая собирает данные с нескольких контроллеров.
Пару логин/пароль (общий «секрет») нужно как-то выдать клиенту — компании или человеку. Кто-то должен сгенерировать секретную пару, отправить по e-mail, аутентифицировать клиента по номеру счета. Это стандартная процедура — низкие технологии.
**Проблема**. Она в том, что у нас много таких систем. Клиент наш, а данные он может отправлять в систему нашего партнера. Это сложное взаимодействие между всеми причастными сторонами.
Кроме проблемы множества систем, есть еще другие.
* **Плохая выдача и доставка до клиента**.
* **Логины и пароли хранят на сервере**. Если будем хранить еще и хэши, это нас немного обезопасит от утечек. Но даже при этом возникает неприятное чувство, когда на сервере хранятся секретные ключи для всех контроллеров клиентов. Некоторые из них могут заниматься критическими задачами: наружным освещением, мониторингом нефтяных вышек.
* **Синхронизация между сервисами**.
* **Восстановление при потере**. Непонятно, что делать при потерях, когда клиент стер память контроллера — в какую память писать? Придется повторять все заново.
* **Защита от копирования реквизитов**. Есть платные системы мониторинга, которые предоставляют клиенту сервис и берут с него оплату по подписке. Не хочется, чтобы конечный клиент смог как-то обходить систему через нас — заплатить один раз, а использовать два.
**Второе решение — генерировать и зашивать «секрет» на производстве**. Это улучшение предыдущего решения.
Схема такая: мы, как производитель контроллеров, заранее генерируем логины и пароли для всех, зашиваем в свою систему и заносим в оборудование. Логины и пароли из оборудования нельзя ни прочитать, ни поменять. Это лучше предыдущего варианта, потому что не требует взаимодействия между людьми.
**Проблемы**. Остались все проблемы, кроме первой, но главная из них — **синхронизация между сервисами и интранет**. Сервисов много и непонятно, как их синхронизовать — из-за этого мы не смогли внедрить второе решение. У нас есть клиенты, которые используют оборудование в своих закрытых сетях. Мы выпустили новый контроллер, продали клиенту, а его система закрытая. Она настроена, один раз работает, а донести «секреты» дальше сложно. Доносить партиями? В организациях все сложно, хотя технически просто.
Оба решения нам не подошли. Поэтому мы решили пойти по другому пути. Но перед этим решили обозначить общие задачи и цели.
Задачи и цели
-------------
Сначала общие задачи.
**Аутентификация**. Это способ понять, кто разговаривает с системой верхнего уровня, кто именно подключается к системе диспетчеризации.
> Аутентификация — это не предоставление или разграничение прав доступа, а способ понимания, кто с нами говорит.
**Задача отправки данных**. Наши контроллеры — это компьютеры с Linux, разработанные под специальную задачу. Нам нужно, чтобы они отправляли данные в системы верхнего уровня, подключались по VPN. При этом мы хотим, чтобы отправка работала «из коробки» — без настроек и взаимодействия наших клиентов и конечных пользователей системы с нами и с клиентами.
**Другие задачи**. Это надежность соединения, шифрование канала данных, но отдельный вопрос — **авторизация**. Задача авторизации связана с внешними сервисами и делится на три части.
* **Бесплатный сервис производителя**. Предоставлять доступы по серийному номеру устройства.
* **Белые списки серийных номеров** для сервиса наших партнеров — привязывать покупки и доступы к аккаунту клиента.
* **Лицензии**. Разрешать или запрещать доступ на основе опций, которые указаны в сертификате.
Цели — это то, что мы хотим достичь, когда решим задачи.
**Выдача и доставка до клиента**. Без участия людей — информация зашивается роботами на производстве.
**Восстановление при потере**. Мы хотим, чтобы вообще не было потерь секретных реквизитов.
**Доставка от производства до сервисов**. Хотим обойтись без неё, чтобы не требовалось ничего доставлять в сервисы. При запуске нового оборудования мы не хотим обновлять базы всех сервисов, которые должны аутентифицировать эти устройства.
**Хранение на сервере**. Желательно вообще ничего там не хранить.
**Синхронизация между сервисами и интранет**. Также желательно ничего не синхронизовать — ведь ничего хранить не будем.
**Защита от копирования реквизитов**. Хотим, чтобы что-то секретное, за что берутся деньги, нельзя было скопировать и получить бесплатно.
Цифровая подпись спешит на помощь
---------------------------------
> Электронная цифровая подпись (ЭЦП) — это технология, вокруг которой у нас все работает.
Это как обычная подпись, только цифровая. ЭЦП легко проверить, но сложно подделать. Знакомые всем прописные истины криптографии, которым десятки лет.
Электронная подпись — это что-то, что можно посчитать по сообщению, если знать секретный приватный ключ (private key). Если знать публичный ключ (public key), легко проверить, что электронная подпись для сообщения правильная. По названию понятно — публичный принято сообщать всем, а секретный только у того, кто подписывает.
> Все подписи и ключи — это просто числа.
В нашем случае это 32 байта данных, которая работает на математической «магии». Математика гарантирует, что подпись просто проверить, но сложно подделать.
Мы используем подпись ECDSA-256+SHA-256:
* `e = HASH(m)` — криптографическая хеш-функция необратимо преобразовывает сообщение m в число e;
* `private key (dA)` — случайное число;
* `public key (QA)` — генерируется из private key, но не наоборот;
* `signature (r,s) = sign(private key, e)` — подпись;
* `verify(public key, signature, e)` — проверка подписи.
### Аутентификация по ЭЦП. Первая попытка
Что можно сделать для нашей задачи, используя этот хитрый механизм, который в одну сторону работает просто, а в другую сложно?
**Выдача и доставка до клиента**. Генерируем случайный приватный ключ для каждого устройства на производстве. Никому не говорим, потому что даже сами его не знаем, и записываем в устройство.
**Доставка от производства до сервисов**. Дальше используем только публичный ключ этого устройства для аутентификации на сервисах. На сервисах храним только список публичных ключей вместо паролей.
Стандартный алгоритм проверки работоспособности:
* сервис отправляет контроллеру случайное сообщение `m`;
* контроллер: `sign(private key, m)`;
* контроллер отправляет сервису подпись;
* сервис: `verify(public key, signature, m)`.
Единственное, что мы решили таким способом — это то, что **больше не храним на своих сервисах общие «секреты»** в открытом или закэшированном виде. Это не то, что нам хочется.
### Аутентификация по ЭЦП. Вторая попытка
Мы не хотим что-то хранить на сервисах. Чтобы этого добиться, мы можем заставить наши устройства отправлять свои публичные ключи сервису.
На прошлом этапе мы решили две задачи. Первая — **проверили, что выдали сервису ключ**. У нас есть публичный ключ, значит приватный тоже делали мы. Вторая — убедились, что **устройство владеет приватным ключом**, который лежит где-то на флешке. Если устройство могло что-то подписать, значит у него есть приватный ключ.
Теперь устройство отправит сервису еще и публичный ключ. Как проверить, что никто его не перехватил, не подделал, и что все работает?
**Проверка публичного ключа**. Создаем себе еще один публичный ключ. Он будет нашим ключом, как производителя. Это корневой ключ «root private key + public key». Этим корневым секретным ключом на производстве подпишем публичный ключ устройства (device public key) и будем хранить эту подпись на устройстве. Устройство должно отправить свой публичный ключ и подпись своего публичного ключа сервису. Теперь сервис может проверить публичный ключ устройства. Если он подписан корневым ключом (root private key), значит мы выдали этот ключ.
> Создать и хранить подпись на устройстве может только производитель — мы, а проверить — все.
Публичный ключ мы публикуем на сайте в разделе «Контакты». Кто угодно может его взять, и проверить публичный ключ устройства, который отправило устройство на сервис. Дальше можно проверить, что само устройство обладает собственным приватным ключом.
Общий алгоритм выглядит так.
* `(once) random root private key`;
* `factory: random device private key`;
* `factory: sign(root private key, device public key) = signature_1`;
* `device->service: отправляет device public key + signature_1`;
* `service: verify(root public key, signature_1, device public key)?`
### Результат второй попытки
Мы решили проблему с **доставкой** до клиента — информация зашивается на производстве, и **восстанавливать ничего не надо**.
Важно, что мы решили проблему с **доставкой «секретов» до сервисов верхнего уровня**, потому что все, что нужно хранить на сервисе — это публичный ключ производителя. Весь ключ занимает 33 байта. С их помощью и математической магии можно дальше провести handshake-соединение и проверить, что устройство обладает соответствующим приватным ключом.
**На сервере** мы храним только ключ производителя (root public key).
**Синхронизация между сервисами и интранета** у нас нет, о чем мы уже говорили. Также у нас нет **защиты от копирования реквизитов**.
Единственное, о чем мы забыли, так это об **аутентификации**. Устройство отправило приватный ключ, а мы проверили, что это мы его сделали и выдали, и проверили, что устройство им владеет. Но мы не знаем, что это за устройство, а мы их тысячи производим.
Поэтому мы применили трюк, который называется «Сертификат».
Аутентификация и сертификаты
----------------------------
На этом шаге во всю математическую магию с подписями и их проверками мы добавляем **дополнительную информацию — сертификат**. Для этого подпишем на фабрике не только публичный ключ (device public key), а ключ с дополнительной информацией.
Дополнительная информация в нашем случае.
* Дата производства и производитель.
* Модель и аппаратная конфигурация.
* Серийный номер, по которому можно аутентифицировать устройство.
* Опции: аппаратные и программные. Разные комплектации физически могут ничем не отличаться друг от друга, но сертификат будет содержать данные о том, за что заплатил клиент.
* Имя клиента и номер счета.
Всю эту информацию вместе с публичным ключом мы будем подписывать своим ключом производителя — root public key. После этого информация попадет на сервисы и они смогут удостовериться, что она правильная. Поскольку это сервисы наши и наших партнеров, нам они доверяют.
### Статус по целям
Информация также зашивается на производстве, а **доставка** до сервисов не нужна. **На сервере** храним только ключ производителя.
**Восстановление при потере**. Всю информацию из сертификатов зашиваем во флеш-память устройства. Теоретически ее можно случайно или намеренно удалить, но в этой информации в сертификате нет ничего секретного. Даже сама подпись не секретна — там есть публичный ключ и подпись нашим ключом. Единственный секрет в сертификате — объемы продаж устройств с разными опциями.
Сертификат можно хранить на фабрике и высылать клиенту, если он его потерял. Клиенты редко специально стирают служебную область памяти. Обычно это делаем мы во время процедуры восстановления устройства: пришло устройство от клиента, оно полностью пропускается через инициализацию, все стирается, загружается заново, а сертификат копируется из заводской базы.
У нас нет **восстановления** при потере, **защиты** от копирования и **синхронизации между сервисами**.
**На этапе аутентификации** мы получаем и проверяем сертификат. Нам понятно, что это за устройство — мы знаем производителя, модель и серийный номер, что ему можно, а что нельзя.
### Авторизация
Сертификат позволяет хранить информацию для авторизации.
**Бесплатный сервис производителя**. Зная серийный номер устройства, можно давать доступ всем. В своих сервисах мы даем доступ всем нашим базовым клиентам.
**Белые списки серийных номеров**. Для сервиса наших партнеров можно завести таблицу с белым списком серийных номеров: «Клиент Василий купил у нас два контроллера с такими-то серийниками, которые привязаны к его аккаунту»
**Лицензии**. Можно заранее что-то продать, а потом разрешать или запрещать доступ **на основе опций**, которые указаны в сертификате — контроллер с лицензией на систему X.
Никакой общей базы между сервисами, производителем или производителем систем нет. Все работает исключительно на информации от контроллера которая подписана нами, как производителем, когда он аутентифицирует в системе.
Промежуточный сертификат
------------------------
Еще одна техническая задача, которую мы решали по дороге. В схеме, про которую я сейчас рассказал, есть корневой сертификат производителя — root private key. Он физически нужен каждый раз, когда вы создаете устройство. Но если устройств много, то к этому ключу нужен постоянный доступ для ограниченного круга лиц. Это плохо, потому что если его потерять, то придётся обновлять публичные ключи на всех сервисах, а к злоумышленникам он попасть не должен. Это большие организационные проблемы. Но есть решение.
> Вводим промежуточные ключи на партию устройств, которые не так страшно потерять.
Мы сделали так же, только цепочка длиннее.
Сертификатом производителя подписываем промежуточный ключ. Физически это «флешка», которая на день выдается бригадиру на производстве. Аппаратными средствами ограничено число устройств, которые может подписать ключ. В середине схемы мы добавили промежуточный сертификат, в остальном ничего не менялось.
Защищённое хранилище ключей
---------------------------
Во всем этом нам не хватает **защиты приватного ключа устройства** — это все еще файл, который лежит на флешке. Злоумышленник может его скопировать, но скорее всего его потеряют или случайно откроют доступ.
В идеальном случае приватный ключ устройства хорошо бы защитить от копирования — положить его в черный ящик.
Черный ящик выполняет 4 операции:
* внутри себя генерирует ключ по запросу, но не отдает;
* отдает публичный ключ;
* подписывает сообщение;
* проверяет подпись.
*Для проверки подписи нужен только публичный ключ, поэтому достаточно трех операций.*
В моем понимании это должно быть аппаратное решение, желательно, отдельное от процессора. Есть несколько вариантов, лучший из которых — **специальный криптопроцессор внутри SoC** или в виде отдельного чипа.
Первый вариант черного ящика, который мы рассматривали — это **модуль CAAM** в процессорах NXP i.mx 6, 7, 8, которые мы используем. Проблема в том, что он реализован программными способами в Boot ROM процессора.
В нем могут быть баги, которые можно найти и даже эксплуатировать через другую функциональность процессора. Пару лет назад в этом модуле нашли дыру, которая позволяла обходить проверку подписи при загрузке прошивки. Это не та функциональность, которая нужна нам, но осадок остался. Другая проблема — процессоры с этим модулем тяжело ввозить в Россию, бумажки требуют заполнять.
Поэтому мы взяли отдельный чип. Признаюсь честно, я рассчитывал на то, что если мы не сможем привезти его в Россию, то что-нибудь придумаем — чип маленький, стоит 1 доллар. Но все получилось удачно — нашли чип **Microchip ATECC**, у которого все бумажки уже есть.
Microchip ATECC608A
-------------------
Это отдельная маленькая микросхема, которая стоит копейки. Чип подключается по I2C — две «ножки» процессора, которые вы можете поделить еще и с другой периферией. У чипа стандартная распиновка. Мы использовали чип в первых версиях оборудования и просто паяли его поверх другой микросхемы с таким же протоколом и распиновкой, потому что она стандартная.
Чип умеет то, что нам нужно от такой микросхемы: считать подписи, хранить ключи и многое другое.
Характеристики:
* 16 слотов для ключей;
* умеет считать подписи ECSDSA, хеши, MAC, и шифровать AES, умеет DH;
* имеет генератор случайных чисел и криптографические счётчики;
* корпуса: SOIC-8, DFN6;
* протоколы: I2C, single wire;
* ~0.7$@1000pcs.
### Как работать с микросхемой
К нему есть приличная **документация**, но под NDA. Если вы напишете сразу в gamma.spb.ru, то вам дадут её через 2 недели. Если в другую компанию — через 3 месяца. Мы написали в две компании, и когда уже все сделали, нам ответил другой дилер Microchip.
**Аппнотов мало** и они хуже среднего. Есть **софт** [на GitHub](https://github.com/MicrochipTech/cryptoauthlib/) — библиотека с HAL. Это забавно — документация под NDA, а софт, который по ней написан, на GitHub. Софт не поддерживает Linux, а поддерживает Raspberry Pi и МК от Atmel — это немного не то. Разработчики считают, что на всем оборудовании есть только одна I2C шина, например, ножки называются как на Raspberry Pi.
Есть [интеграция](https://github.com/MicrochipTech/cryptoauth-openssl-engine) с **OpenSSL** — плохо работает, но есть. **Нет примеров под Linux** и нет работы с **персонализацией**.
### Персонализация чипа
> Персонализация — это самая большая головная боль с чипом.
Проблема в том, что чип умеет очень много всего. У него есть 16 слотов, в которых хранится 16 ключей: пользовательские данные, или публичные ключи, или временные хранилища для других слотов — много вариантов.
К слотам надо как-то ограничивать доступ, и там тоже много конфигурационных вариантов: ограничить по паролю, по аутентификации в другом слоте, по времени обращения на фабрики.
*В таблице тип ключа, доступ на чтение и запись, отношения между слотами — SlotConfig, KeyConfig.*
В битовой маске (по 16 бит) каждого ключа, который мы используем, везде разные числа.
Самое грустное, что конфигурационная зона одноразовая, которая устанавливает функции слотов. Мы испортили 50 чипов, прежде чем все сделали правильно. Чип работает только **после блокирования конфигурации**. Отдельно есть **блокировка отдельных слотов**
Документации нет ни в примерах, ни в софте. Есть документация на отдельные биты, но там все сложно. Во всех примерах от Microchip написано: «Такой блок загрузите, и у вас как-то будет работать как в примере отправки данных в Amazon».
На это ушло много времени, но в процессе сделали классную утилиту.
### Утилита atecc-util
Это консольная утилита, которая умеет выполнять большинство функций чипа и позволяет работать чуть проще. Она есть [на GitHub](https://github.com/contactless/atecc-util) под MIT-лицензией.
Утилита использует CryptoAuthLib. Она умеет дружественнее работать с конфиг-зоной, умеет работать с SHA, MAC, ECDSA, DH. Интерфейс дружественный к batch, потому что мы создавали утилиту для использования в скриптах, в первую очередь. То, что ее может вызвать человек — побочная фича. Утилитой можно составить список — план команд: «Сначала персонализируй эту зону, потом запиши такой ключ».
Пример вызова утилиты достаточно человекочитаемый.
```
atecc - b 10 - c 'serial' - c 'read-config /tmp/config.dump'
```
Утилита собрана под Linux, под AMD64 — есть в Debian-пакете.
### Другие инструменты персонализации
У нас есть Excel-табличка, чтобы считать биты. Если вы покажете нам скан NDA c Microchip, мы вам ее отдадим.
Мы все покрыли тестами, поскольку много вариантов, когда можно забыть один бит, и ваш приватный ключ прочитает какая-нибудь служебная команда. Тесты проверяют реальное устройство. Они обращаются к микросхеме и проверяют правильность конфигурации на устройстве: можно ли этот слот можно прочитать, можно ли сделать такую подпись?
Параллельно с битами мы создали список гарантий, которым должно удовлетворять это устройство, и проверяли, как все работает. Используем **фреймворк bats** — очень интересная штука. Выглядит это так.
*Список тестов для примера. Верхние пройдены, а нижние нет.*
### Настройки в устройствах
**Для себя мы используем всего два слота** для задачи, о которой я сейчас рассказываю. В обоих мы храним приватный ключ устройства. Разница в том, что с первым связан **постоянный сертификат**, который выписан в 1970 году на 200 лет.
Это сделано из-за того, что в IoT время не всегда синхронизованное. Инфраструктура сертификатов предполагает проверку срока валидности сертификата. Если синхронизация на устройствах сломана, то какой-нибудь жизненно важный сервис может отказать, например, VPN.
Поэтому **один слот бесконечный — постоянный**. Он генерируется однократно и не меняется на протяжении жизни устройства. Для этого ключа генерируется сертификат на 200 лет — для закрытых сетей.
Другой слот обновляется. Максимальный срок жизни сертификатов — год. Это сделано на всякий случай, если что-то будет скомпрометировано. Приватный обновляемый ключ устройства генерируется по мере истечения срока валидности сертификата устройства. Используется для аутентификации в открытых сетях, обновляется раз в месяц или реже, вместе с сертификатом.
**Для пользователей мы сгенерировали разные комбинации**, включая несколько слотов для приватных ECDSA ключей. Пользователи могут сгенерировать свой ключ в отдельном слоте, если не доверяют нашему приватному ключу. Для этого нужно доверять только Microchip. Пользователи могут считать подписи, сделать шифрование — мы отдали все, что умеет микросхема.
Пока, к сожалению, никто не использовал, но мы надеемся на это.
### Инфраструктура: промежуточные ключи
Я уже говорил, что в какой-то момент мы внедрили промежуточные сертификаты, чтобы не светить корневым сертификатом, который нельзя терять. Он никогда не появляется на фабрике.
Физически промежуточные сертификаты — это чип ATECC508A. От 608 отличается незначительно, но в 508 есть функциональность, которая пригодилась для ключей, а в 608 её уже нет.
Чип подключается через USB-I2C переходник. Это USBISP с прошивкой tiny-usb-i2c — программатор, который можно перепрошить в USB-I2C бридж. Промежуточные сертификаты подписывают своим приватным ключом сертификаты устройств.
Для нас оказались полезны две возможности микросхемы.
**Аппаратная защита паролем слота**. Микросхему можно запрограммировать, чтобы она считала подпись только при выполнении двух условий:
* когда устройство воткнули в компьютер;
* введен пароль.
Бригадиру на производство мы выдаем промежуточный ключ и пароль на какое-то количество контроллеров. Соответственно, надо украсть и ключ, и пароль, чтобы получить доступ. Эту возможность мы получили бесплатно, но она повышает безопасность системы.
**Аппаратное ограничение на количество использований**. Криптографический счетчик внутри может только увеличиваться. Когда он достигает заранее заданного один раз предела, микросхема больше ничего не подписывает.
OpenSSL на клиенте
------------------
Рассмотрим как все работает на клиенте. На контроллере у нас OpenSSL. Мы не стали ничего изобретать — это обычный TLS, обычный PKI. Нам дополнительно понадобилась клиентская библиотека. В подавляющем большинстве софта Linux она используется для защищенного соединения.
Мы взяли код от Microchip, его немножко [дописали](https://github.com/contactless/cryptoauth-openssl-engine), поддержали свежий OpenSSL
1.1. В итоге он умеет работать с аппаратным ключом — аппаратно поддерживает пароли для приватных ключей.
Выглядит это примерно так.
```
openssl req -new -engine ateccx08 -keyform engine -key ATECCx08:00:04:C0:00 -subj
"/CN=wirenboard-AP6V5MDG" -out device AP6V5MDG.csr
```
Это вызов обычного OpenSSL и указание использовать соответствующий модуль engine. Здесь задается ключ: адрес, модель, а последние два байта — это номер слота, который используется. Все передается так, будто это файл ключа, но это не файл — надо зайти в устройство.
SSL на сервере
--------------
На сервере работает любой SSL, в том числе OpenSSL. Никаких доработок и нестандартных сборок на серверной части уже не нужно. Все, что нужно на сервере, это **уметь проверять цепочку certificate bundle** (device cert + intermediate cert), и **хранить наш публичный ключ**, который мы опубликовали на сайте — Wiren Board ROOT CA.
Стандартный TLS говорит о том, что обе стороны должны аутентифицировать друг друга. В теории клиент — наш контроллер — аутентифицирует и сервер. Это достается бесплатно — в том самом handshake.
Для этого у сервера тоже должна быть ключевая пара: приватный и публичный ключ. Её можно сделать самоподписанной, и тогда на все клиенты можно раздать публичный ключ. Можно использовать letsencrypt или сертификат в SSL, как на сайтах, чтобы домен был в браузере зеленым.
В трех сервисах мы это сейчас сделали, первый из них — MQTT.
MQTT: mosquitto на клиенте
--------------------------
Это стандартная и популярная шина для передачи данных от IBM. У нас она используется для связи контроллеров с нашим облаком и с некоторыми партнерскими системами.
Mosquitto — это распространенная реализация брокера и клиентских библиотек, в том числе, под Linux. Нам пришлось его пропатчить, чтобы использовать OpenSSL engine (передать одну опцию) и парсить опцию «keyfile», чтобы указывать там аппаратный ключ. [Патчи](https://github.com/contactless/contrib/commit/8d5def9fc89ffd0de3884f8b977993782b9f8237) на клиент маленькие, по 20 строк.
Дальше клиент передает страшный bundle.
После этого используется аппаратный приватный ключ и проверяется сертификат сервера в другую сторону.
```
mosquitto_sub -h mqtt.wirenboard.com -p 8884 -cert /etc/ssl/device/device_bundle.crt.pem --key 'engine:ateccx08:ATECCx08:00:04:C0:00' --capath /etc/ssl/certs/ -t /# -v
```
Здесь сначала идет консольная утилита. Дальше указан сертификат устройства — он начинается с `-cert`. Сертификат идет bundle-файлом — метаинформация. Приватный ключ идет после сертификата `--key`. За ключом нужно идти в аппаратное хранилище.
Последняя часть, которая начинается с `--capath`, это проверка нашего сервера. Мы его проверяем по общемировому списку SSL-ключей, потому что у нас letsencrypt.
Так выглядит **настройка бриджа**.
```
root@wirenboard-AXXVJI62:~# cat /etc/mosquitto/conf.d/bridge-hw.conf
connection wb_devices_cloud.wirenboard-AXXVJI62
address contactless.ru:8884
bridge_capath /etc/ssl/certs/
bridge_certfile /etc/ssl/device/device_bundle.crt.pem
bridge_keyfile engine:ateccx08:ATECCx08:00:04:C0:00
notifications true
notification_topic /client/wirenboard-AXXVJI62/bridge_status
topic/# both 1 ""/dient/wirenboard-AXXVJI62
```
Mosquito-бридж также настраивается и передаются данные.
**На сервере стандартный Mosquitto** — ничего патчить не надо.
```
per _listener_settings true
listener 8884 0.0.0.0
cafile/etc/mosquitto/certs/WirenBoard_Root_CA.crt
certfile /etc/letsencrypt/live/contactless.ru/fullchain.pem keyfile/etc/letsencrypt/live/contactless.ru/privkey.pem
require.certificate true
use_identity_as_username true
password_file /etc/mosquitto/passwd.conf
allow_anonymous false
acl_file /etc/mosquitto/ad.conf
:~$ cat /etc/mosquitto/acl.conf
pattern write /client/%u/#
pattern read /client/%u/#
```
Вся настройка — несколько шагов.
* Зашиваем Root CA и letsencrypt-сертификаты от домена — прописать в настройках. Дальше указываем команду проверять сертификаты.
* Дальше классная опция Mosquitto. Она позволяет без всяких допиливаний использовать метаинформацию сертификата в качестве `username` для дальнейших листов доступа к MQTT.
* После того, как клиент отправил свой сертификат, например, с серийником (CN) wirenboard-AXXVJI62, у нас написано, к каким подтопикам разрешать доступ клиенту.
* `per_listener_settings:` на отдельном порту, чтобы не мешать аутентификации по логину/паролю (>1.5.5).
Это вся настройка MQTT-брокера нашего Wiren Board IoT Cloud Platform.
OpenVPN
-------
OpenVPN нам нужен, чтобы ходить к клиентам на контроллер, когда они все себе сломали. Для этого нужно, чтобы он поднимался по одному клику из настроечного интерфейса и нам давался доступ к клиентскому устройству.
Для OpenVPN **на клиенте** тоже нужен [патч](https://github.com/contactless/contrib/commit/800c7386da4bffd475686cadfd83e03d4fc1088d), но он простой. Дальше в опции запуска добавляется то же, что и выше: bundle, проверка сервера, engine.
```
openvpn --capath /etc/ssl/certs/ --cert /etc/ssl/device/device_bundle.crt.pem --key engine:ateccx08:ATECCx08:00:04:C0:00
```
**На сервере** мы также используем letsencrypt.
```
ca /etc/openvpn/WirenBoard_Root_CA.crt cert
/etc/letsencrypt/live/vpn1.wirenboard.com/fullchain.pem key
/etc/letsencrypt/live/vpn1.wirenboard.com/privkey.pem
```
Развернуть другой сервер легко — не надо передавать никакие файлы на контроллеры. Это все подписано по стандартной эко-системе публичных ключей.
Nginx
-----
Наша заключительная фича. Nginx сделан для партнеров, у которых сложный сервис, или если не хочется прикручивать проверку клиентских сертификатов, SSL. Часто у них уже стоит nginx перед сложным сервисом на web-сервере, как reverse-proxy. Если нет — ставится одной строчкой в конфиге nginx.
nginx проверяет клиентский сертификат, отдает HTTP-запрос, а дальше своему бэкенду или сложному сервису. Если всё ОК, то выставляет хедеры перед передачей запроса ниже: Common Name, разрешено ли клиенту использовать этот сервис, заплатил ли он за него при покупке контроллера. Если не ОК, то ошибка 400.
```
ssl_client_certificate WirenBoard_Root_CA.crt;
ssl_verify_client on;
```
**nginx на клиенте**. У нас есть агенты — приложения, которые отправляют данные по HTTP. На Linux-контроллерах мы используем nginx на клиенте, чтобы агенты тоже ничего не знали о SSL, наших аппаратных ключах, работу с OpenSSL.
Дальше можно обычным wget без ключей, bash или вашим любимым языком, завернуть любой HTTP-запрос в TLS с аппаратным ключом. Все настраивается в 10 строчек.
```
server {
listen 8080;
location / {
proxy_pass https://example.com;
proxy_ssl_name example.com;
proxy_ssl_server_name on;
proxy_ssl_certificate/etc/ssl/device/device_bundle.crt.pem;
proxy_ssl_certificate_key
engine:ateccx08;ATECCx08:00:04:C0:00;
}
}
```
Где посмотреть
--------------
Криптомодуль есть во всех контроллерах **Wiren Board 6**, которые выпускаем уже полтора года. В инфраструктуре уже был задел, но развернули и настроили все только недавно.
У нас это работает для удаленного доступа к web-интерфейсу контроллера на cloud.wirenboard.com для OpenVPN для контроллера. Также мы подняли среду Grafana с InfluxDB, в которой все работает по MQTT. Можете посмотреть в системе saymon.info — это система мониторинга (MQTT) наших партнеров.
Если вы производитель систем верхнего уровня, делаете что-то для себя, или хотите поднять удаленный доступ, Grafana, MQTT-брокер, как у нас, то пишите, звоните. Поделимся инструкциями — поможем.
Всю работу, о которой я рассказал, выполняли два человека: [Олег Сериков](https://github.com/xenols) — настройка OpenSSL на клиентах и серверах, и [Никита Маслов](https://github.com/webconn) — всё остальное. Спасибо им!
> Это была статья на основе одного из лучших докладов конференции [InoThings Conf 2019](https://inothings.ru/2019). Подписывайтесь на [YouTube-канал](https://www.youtube.com/c/IoTChannel) с остальными лучшими докладами с конференции 2019 года. Также вступайте в [канал](https://t.me/InoThingsChannel) и [чат](https://t.me/InoThingsTalks) в Telegram. В чате участники задают вопросы, делятся наработками, опытом и обсуждают свежие материалы по IoT. | https://habr.com/ru/post/476304/ | null | ru | null |
# Пишем Java-френдли Kotlin-код
Со стороны может показаться, что Kotlin упростил Android-разработку, вообще не принеся при этом новых сложностей: язык ведь Java-совместимый, так что даже большой Java-проект можно постепенно переводить на него, не забивая ничем голову, так? Но если заглядывать глубже, в каждой шкатулке найдётся двойное дно, а в трюмо — потайная дверца. Языки программирования — слишком сложные проекты, чтобы их совмещение обходилось без хитрых нюансов.
Разумеется, это не означает «всё плохо и использовать Kotlin вместе с Java не надо», а означает, что стоит знать о нюансах и учитывать их. На нашей конференции **Mobius** Сергей Рябов [рассказал](https://mobiusconf.com/2017/msk/talks/jslrnocqzieusmswmg0w0/), как писать на Kotlin такой код, к которому будет комфортно обращаться из Java. И доклад так понравился зрителям, что мы не только решили разместить видеозапись, но и сделали для Хабра текстовую версию:
Я пишу на Kotlin уже более трёх лет, сейчас только на нём, но поначалу притаскивал Kotlin в существующие Java-проекты. Поэтому вопрос «как связать вместе Java и Kotlin» на моём пути возникал довольно часто.
Зачастую при добавлении в проект Kotlin можно увидеть, как вот это…
```
compile 'rxbinding:x.y.x'
compile 'rxbinding-appcompat-v7:x.y.x'
compile 'rxbinding-design:x.y.x'
compile 'autodispose:x.y.z'
compile 'autodispose-android:x.y.z'
compile 'autodispose-android-archcomponents:x.y.z'
```
… превращается в это:
```
compile 'rxbinding:x.y.x'
compile 'rxbinding-kotlin:x.y.x'
compile 'rxbinding-appcompat-v7:x.y.x'
compile 'rxbinding-appcompat-v7-kotlin:x.y.x'
compile 'rxbinding-design:x.y.x'
compile 'rxbinding-design-kotlin:x.y.x'
compile 'autodispose:x.y.z'
compile 'autodispose-kotlin:x.y.z'
compile 'autodispose-android:x.y.z'
compile 'autodispose-android-kotlin:x.y.z'
compile 'autodispose-android-archcomponents:x.y.z'
compile 'autodispose-android-archcomponents-kotlin:x.y.z'
```
Специфика последней пары лет: самые популярные библиотеки обзаводятся «обёртками» для того, чтобы можно было использовать их из Kotlin более идиоматично.
Если вы писали на Kotlin, то знаете, что есть классные extension-функции, inline-функции, лямбда-выражения, которые доступны из Java 6. И это круто, это притягивает нас к Kotlin, но возникает вопрос. Одна из самых больших, самых разрекламированных фич языка — interoperability с Java. Если принять во внимание все перечисленные фичи, то почему бы тогда просто не писать библиотеки на Kotlin? Они все будут отлично работать из коробки с Java, и не нужно будет поддерживать все эти обёртки, все будут счастливы и довольны.
Но, конечно, на практике не всё так радужно, как в рекламных проспектах, всегда есть «приписочка мелким шрифтом», есть острые грани на стыке Kotlin и Java, и сегодня мы об этом немного поговорим.
Острые грани
------------
Начнём с различий. Например, в курсе ли вы, что в Kotlin нет ключевых слов volatile, synchronized, strictfp, transient? Они заменены одноимёнными аннотациями, находящимися в пакете kotlin.jvm. Так вот, о содержимом этого пакета и пойдёт большая часть разговора.
Есть [Timber](https://github.com/JakeWharton/timber) — такая библиотечка-абстракция над логгерами от небезызвестного Жеки Вартанова. Она позволяет вам в вашем приложении везде использовать её, а всё, куда вы хотите отправить логи (в logcat, или на ваш сервер для анализа, или в crash reporting, и так далее), оборачивается в плагинчики.
Давайте для примера представим, что мы хотим написать аналогичную библиотеку, только для аналитики. Тоже абстрагироваться.
```
object Analytics {
fun send(event: Event) {}
fun addPlugins(plugs: List) {}
fun getPlugins(): List {}
}
interface Plugin {
fun init()
fun send(event: Event)
fun close()
}
data class Event(
val name: String,
val context: Map = emptyMap()
)
```
Берём тот же самый паттерн построения, у нас одна точка входа — это Analytics. Мы можем посылать туда ивенты, добавлять плагины и смотреть, что у нас там уже добавлено.
Plugin — интерфейс плагина, который абстрагирует какое-то конкретное аналитическое API.
И, собственно, класс Event, содержащий ключ и наши атрибуты, которые мы отправляем. Здесь доклад не про то, стоит ли использовать синглтоны, поэтому давайте не будем разводить холивар, а будем смотреть, как это все дело причесать.
Теперь немножко погрузимся. Вот пример использования нашей библиотеки в Kotlin:
```
private fun useAnalytics() {
Analytics.send(Event("only_name_event"))
val props = mapOf(
USER_ID to 1235,
"my_custom_attr" to true
)
Analytics.send(Event("custom_event", props))
val hasPlugins = Analytics.hasPlugins
Analytics.addPlugin(EMPTY_PLUGIN) // dry-run
Analytics.addPlugins(listOf(LoggerPlugin("ALog"), SegmentPlugin)))
val plugins = Analytics.getPlugins()
// ...
}
```
В принципе, выглядит так, как и ожидается. Одна точка входа, методы вызываются а-ля статики. Event без параметров, event с атрибутами. Проверяем, есть ли у нас плагины, запихиваем туда пустой плагин для того, чтобы просто какой-то «dry run»-прогон сделать. Либо добавляем несколько других плагинов, выводим их, ну и так далее. В общем, стандартные юзкейсы, надеюсь, всё пока понятно.
А теперь посмотрим, что происходит в Java, когда мы делаем то же самое:
```
private static void useAnalytics() {
Analytics.INSTANCE.send(new Event("only_name_event", Collections.emptyMap()));
final Map props = new HashMap<>();
props.put(USER\_ID, 1235);
props.put("my\_custom\_attr", true);
Analytics.INSTANCE.send(new Event("custom\_event", props));
boolean hasPlugins = Analytics.INSTANCE.getHasPlugins();
Analytics.INSTANCE.addPlugin(Analytics.INSTANCE.getEMPTY\_PLUGIN()); // dry-run
final List pluginsToSet = Arrays.asList(new LoggerPlugin("ALog"), new SegmentPlugin());
// ...
}
```
В глаза сразу бросается сыр-бор с INSTANCE, который протянут наверх, наличие явных значений для дефолтного параметра с атрибутами, какие-то геттеры со стрёмными названиями. Так как мы, в общем-то, и собрались здесь, чтобы превратить это во что-то похожее на предыдущий файл с Kotlin, то давайте пройдёмся по каждому моменту, который нам не нравится, и попробуем его как-то адаптировать.
Начнём с Event. Удаляем из второй строчки параметр Colletions.emptyMap(), и вылезает ошибка компилятора. С чем же это связано?
```
data class Event(
val name: String,
val context: Map = emptyMap()
)
```
Наш конструктор имеет дефолтный параметр, в который мы передаём значение. Мы приходим из Java в Kotlin, логично предположить, что наличие дефолтного параметра генерирует два конструктора: один полный с двумя параметрами, и один частичный, у которого можно задать только name. Очевидно, компилятор так не считает. Давайте посмотрим, почему он считает, что мы не правы.
Наш основной инструмент для анализа всех перипетий того, как Kotlin превращается в JVM-байткод — Kotlin Bytecode Viewer. В Android Studio и IntelliJ IDEA он находится в меню Tools — Kotlin — Show Kotlin Bytecode. Можно просто нажать Cmd+Shift+A и вписать в строку поиска Kotlin Bytecode.
Здесь, как ни удивительно, мы видим байткод того, во что превращается наш Kotlin-класс. Я не ожидаю от вас отличного знания байткода, и, самое главное, разработчики IDE тоже не ожидают. Поэтому они сделали кнопочку Decompile.
После её нажатия мы видим такой примерно неплохой Java-код:
```
public final class Event {
@NotNull
private final String name;
@NotNull
private final Map context;
@NotNull
public final String getName() { return this.name; }
@NotNull
public final Map getContext() { return this.context; }
public Event(@NotNull String name, @NotNull Map context) {
Intrinsics.checkParameterIsNotNull(name, "name");
Intrinsics.checkParameterIsNotNull(context, "context");
super();
this.name = name;
this.context = context;
}
// $FF: Synthetic method
public Event(String var1, Map var2, int var3, DefaultConstructorMarker var4) {
if ((var3 & 2) != 0) {
var2 = MapsKt.emptyMap();
}
// ...
}
```
Видим наши поля, геттеры, ожидаемый конструктор с двумя параметрами name и context, всё происходит нормально. А ниже мы видим второй конструктор, и вот он с неожиданной сигнатурой: не с одним параметром, а почему-то с четырьмя.
Тут можно смутиться, а можно залезть немного глубже и покопаться. Начав разбираться, мы поймём, что DefaultConstructorMarker — это приватный класс из стандартной библиотеки Kotlin, добавленный сюда, чтобы не было коллизий с нами написанными конструкторами, т. к. мы не можем задать руками параметр типа DefaultConstructorMarker. А интересное всего int var3 — битовая маска того, какие дефолтные значения мы должны использовать. В данном случае, если битовая маска совпадает с двойкой, мы знаем, что var2 не задан, наши атрибуты не заданы, и мы используем дефолтное значение.
Как мы можем исправить ситуацию? Для этого есть чудо-аннотация @JvmOverloads из того пакета, о котором я уже говорил. Мы должны навесить её на конструктор.
```
data class Event @JvmOverloads constructor(
val name: String,
val context: Map = emptyMap()
)
```
И что она сделает? Обратимся к тому же инструменту. Теперь там видим и наш полный конструктор, и конструктор с DefaultConstructorMarker, и, о чудо, конструктор с одним параметром, который доступен теперь из Java:
```
@JvmOverloads
public Event(@NotNull String name) {
this.name, (Map)null, 2, (DefaultConstructorMarker)null);
}
```
И, как видите, он делегирует всю работу с дефолтными параметрами в тот наш конструктор с битовыми масками. Таким образом, мы не плодим информации о том, что за дефолтное значение нам нужно засунуть туда, мы просто делегируем всё в один конструктор. Славно. Проверяем, что у нас получилось со стороны Java: компилятор рад и не возмущается.
Давайте посмотрим, что нам не нравится дальше. Нам не нравится этот INSTANCE, который в IDEA мозолит фиолетовым цветом. Не люблю фиолетовый цвет :)
Давайте проверим, за счёт чего так получается. Снова глянем в байткод.
Выделим, например, функцию init и убедимся, что init действительно сгенерирован не статическим.
То есть, как ни крути, нам нужно работать с инстансом этого класса и вызывать у него эти методы. Но мы можем зафорсить генерацию всех этих методов как статическую. Для этого есть своя чудесная анннотация @JvmStatic. Давайте добавим её к функциям init и send и проверим, что теперь думает компилятор на этот счёт.
Мы видим, что к public final init() добавилось ключевое слово static, и мы избавили себя от работы с INSTANCE. Убедимся в этом в Java-коде.
Компилятор теперь подсказывает нам, что мы вызываем статический метод из контекста INSTANCE. Это можно поправить: нажать Alt+Enter, выбрать «Cleanup Code», и вуаля, INSTANCE исчезает, всё выглядит примерно так же, как было в Kotlin:
```
Analytics.send(new Event("only_name_event"));
```
Теперь у нас есть схема работы со статическими методами. Добавим эту аннотацию везде, где нам это важно:
И комментарий: если методы у нас — очевидно методы instance, то, например, с пропертями не всё так очевидно. Сами поля (например, plugins) генерируются как статические. А вот геттеры и сеттеры работают как методы инстанса. Поэтому для пропертей вам тоже нужно добавлять эту аннотацию, чтобы зафорсить сеттеры и геттеры, как статические. Например, видим переменную isInited, добавляем ей аннотацию @JvmStatic, и теперь мы видим в Kotlin Bytecode Viewer, что метод isInited() стал статическим, всё отлично.
Теперь пойдем в Java-код, «за-clean-up-им» его, и всё выглядит примерно как в Kotlin, за исключением точек с запятой и слова new — ну, от них вы не избавитесь.
```
public static void useAnalytics() {
Analytics.send(new Event("only_name_event"));
final Map props = new HashMap<>();
props.put(USER\_ID, 1235);
props.put("my\_custom\_attr", true);
Analytics.send(new Event("custom\_event", props));
boolean hasPlugins = Analytics.getHasPlugins();
Analytics.addPlugin(Analytics.INSTANCE.getEMPTY\_PLUGIN()); // dry-run
// ...
}
```
Следующий шаг: мы видим этот стрёмно названный геттер getHasPlugins с двумя префиксами сразу. Я, конечно, не большой знаток английского языка, но мне кажется, здесь что-то другое подразумевалось. Почему так происходит?
Как знают плотно общавшиеся с Kotlin, для пропертей названия геттеров и сеттеров генерируются по правилам JavaBeans. Это значит, что геттеры в общем случае будут с префиксами get, сеттеры с префиксами set. Но есть одно исключение: если у вас булево поле и в его названии есть префикс is, то и геттер будет с префиксом is. Это можно увидеть на примере вышеупомянутного поля isInited.
К сожалению, далеко не всегда булевы поля должны называться через is. isPlugins не совсем удовлетворяло бы тому, что мы хотим семантически показать именем. Как же нам быть?
А быть нам несложно, для этого есть своя аннотация (как вы уже поняли, я сегодня буду часто это повторять). Аннотация @JvmName позволяет задать любое имя, которое мы хотим (естественно, поддерживаемое Java). Добавим её:
```
@JvmStatic val hasPlugins
@JvmName("hasPlugin") get() = plugins.isNotEmpty()
```
Проверим, что у нас получилось в Java: метода getHasPlugins больше нет, а вот hasPlugins вполне себе есть. Это решило нашу проблему, опять-таки, одной аннотацией. Сейчас всё аннотациями порешаем!
Как видите, здесь мы навесили аннотацию прямо на геттер. С чем это связано? С тем, что под пропертёй лежит много всего, и непонятно, к чему применяется @JvmName. Если перенести аннотацию на сам val hasPlugins, то компилятор не поймёт, к чему её применять.
Однако в Kotlin есть и возможность специфицировать место применения аннотации прямо в ней. Можно указать целью геттер, файл целиком, параметр, делегат, поле, проперти, receiver extension-функции, сеттер и параметр сеттера. В нашем случае интересен геттер. И если сделать вот так, будет тот же самый эффект, как когда мы навешивали аннотацию на get:
```
@get:JvmName("hasPlugins") @JvmStatic val hasPlugins
get() = plugins.isNotEmpty()
```
Соответственно, если у вас нет кастомного геттера, то вы можете навесить прямо на вашу проперти, и все будет ОK.
Следующий момент, который немного нас смущает — это «Analytics.INSTANCE.getEMPTY\_PLUGIN()». Тут дело уже даже не в английском, а просто: ПОЧЕМУ? Ответ примерно такой же, но сперва небольшое введение.
Для того, чтобы сделать из поля константу, у вас есть два пути. Если константу вы определяете как примитивный тип либо как String, и ещё она внутри объекта, то вы можете использовать ключевое слово const, и тогда не будет сгенерировано геттеров-сеттеров и прочего. Это будет обычная константа — private final static — и она будет заинлайнена, то есть абсолютно обычная Java-штука.
Но если вы хотите сделать константу из объекта, который отличен от строки, то у вас не выйдет использовать для этого слово const. Вот у нас есть val EMPTY\_PLUGIN = EmptyPlugin(), по нему, очевидно сгенерировался тот страшный геттер. Мы можем аннотацией @JvmName переименовать, убрать этот префикс get, но всё равно это останется методом — со скобками. Значит, старые решения не подойдут, ищем новые.
И тут для этого аннотация @JvmField, которая говорит: «Не хочу здесь геттеров, не хочу сеттеров, сделай мне поле». Поставим её перед val EMPTY\_PLUGIN и проверим, что всё действительно так.
Kotlin Bytecode Viewer показывает выделенным тот кусок, на котором вы сейчас стоите в файле. Мы сейчас стоим на EMPTY\_PLUGIN, и вы видите, что здесь какая-то инициализация написана в конструкторе. Дело в том, что геттера-то больше нет и доступ к нему только на запись идёт. А если нажать decompile, видим, что появилось «public static final EmptyPlugin EMPTY\_PLUGIN», это именно то, чего мы и добивались. Славно. Проверяем, что всех всё радует, в частности, компилятор. Самый главный, кого нужно ублажить — это компилятор.
Generics
--------
Давайте немного оторвёмся от кода и посмотрим на дженерики. Это довольно острая тема. Или скользкая, кому что больше не нравится. В Java есть свои сложности, но Kotlin отличается. В первую очередь нас волнует вариантность. Что это такое?
Вариантность — это способ переноса информации о иерархии типов с базовых типов на производные, например, на контейнеры или на дженерики. Вот у нас есть классы Animal и Dog с вполне очевидной связью: Dog — это подтип, Animal — надтип, стрелка идёт от подтипа.
А какая связь будет у их производных? Давайте рассмотрим несколько кейсов.
Первый — это Iterator. Определять, что есть надтип, а что есть подтип, мы будем, руководствуясь правилом подстановки Барбары Лисков. Сформулировать его можно так:«подтип должен требовать не больше, а предоставлять не меньше».
В нашей ситуации единственное, что делает Iterator — отдаёт нам типизированные объекты, например, Animal. Если мы где-то принимаем Iterator, мы вполне можем засунуть туда Iterator, и из метода next() получим Animal, потому что собака — это тоже Animal. Мы предоставляем не меньше, а больше, потому что собака — это подтип.
Повторюсь: из этого типа мы только читаем, поэтому здесь сохраняется зависимость между типом и подтипом. И такие типы называются ковариантными.
Другой кейс: Action. Action — это функция, которая не возвращает ничего, принимает один параметр, и мы только пишем в Action, то есть он принимает у нас собаку или животное.
Таким образом, здесь мы уже не предоставляем, а требуем, и требовать мы должны не больше. Это значит, что зависимость у нас меняется. «Не больше» у нас Animal (Animal меньше, чем собака). И такие типы называются контравариантными.
Есть еще третий кейс — например, ArrayList, из которого мы и читаем, и пишем. Поэтому в данном случае мы нарушаем одно из правил, на запись требуем больше (собаку, а не животное). Такие типы никак не связаны отношением, и они называются инвариантными.
Так вот, в Java, когда её проектировали ещё до версии 1.5 (где появились дженерики), по умолчанию сделали массивы ковариантными. Это значит, что вы можете присвоить массиву объектов массив строк, потом передать его куда-то в метод, где нужен массив объектов, и попробовать туда запихнуть объект, хотя это массив строк. Всё свалится у вас.
Научившись на горьком опыте, что так делать нельзя, при проектировании дженериков они решили «коллекции мы сделаем инвариантными, ничего не будем с ними делать».
И в итоге получается, что в такой, казалось бы, очевидной штуке всё должно быть ок, а на самом деле не ок:
```
// Java
List dogs = new ArrayList<>();
List animals = dogs;
```
Но нам же нужно как-то определять, что всё-таки мы можем: если мы только читаем из этого листа, почему бы не сделать возможной передачу сюда листа собак? Поэтому есть возможность с помощью wildcard охарактеризовать то, какая же вариантность будет у этого типа:
```
List dogs = new ArrayList<>();
List extends Animal animals = dogs;
```
Как вы видите, вариантность эта указывается на месте использования, там, где мы присваиваем собак. Поэтому это называется use-site variance.
Какие негативные стороны у этого есть? Негативная сторона в том, что вы должны везде, где используете ваш API, указывать эти страшные wildcard, и это всё очень плодится в коде. А вот в Kotlin почему-то такая штука работает из коробки, и не нужно ничего указывать:
```
val dogs: List = ArrayList()
val animals: List = dogs
```
С чем это связано? С тем, что листы на самом деле разные. List в Java подразумевает запись, а в Kotlin он read-only, не подразумевает. Поэтому, в принципе, мы можем сразу сказать, что отсюда только читаем, поэтому мы можем быть ковариантными. И это задаётся именно в объявлении типа ключевым словом out, заменяющим wildcard:
```
interface List : Collection
```
Это называется declaration-site variance. Таким образом, мы в одном месте всё указали, и там, где используем, мы больше не затрагиваем эту тему. И это ништяк.
Снова к коду
------------
Поехали обратно в наши пучины. Вот у нас есть метод addPlugins, он принимает List:
```
@JvmStatic fun addPlugins (plugs: List) {
plugs.forEach { addPlugin(it) }
}
А мы передаём ему, как видно, List, ну, просто закастили всё это дело:
final List pluginsToSet =
Arrays.asList(new LoggerPlugin("Alog"), new SegmentPlugin());
```
Благодаря тому, что List в Kotlin ковариантный, мы можем без проблем передать сюда лист наследников плагина. Всё сработает, компилятор не возражает. Но из-за того, что у нас есть declaration-site variance, где мы всё указали, мы не можем тогда на этапе использования контролировать связь с Java. А что же будет, если мы реально хотим туда лист Plugin, не хотим туда никаких наследников? Никаких модификаторов для этого нет, но есть что? Правильно, есть аннотация. А аннотация называется @JvmSuppressWildcards, то есть по умолчанию мы считаем, что здесь тип с wildcard, тип ковариантный.
```
@JvmStatic fun addPlugins(plugs: List<@JvmSuppressWildcards Plugin>) {
plugs.forEach { addPlugin(it) }
}
```
Говоря SuppressWildcards, мы suppress'им все эти вопросики, и наша сигнатура фактически меняется. Даже более того, я покажу, как всё выглядит в байткоде:
Удалю пока из кода аннотацию. Вот наш метод. Вы наверняка знаете, что существует type erasure. И у вас в байткоде нет никакой информации о том, что же там за вопросики-то были, ну и вообще дженерики. Но компилятор за этим следит и подписывает в комментариях к байткоду: а это у нас с вопросиком тип.
Теперь мы снова вставим аннотацию и видим, что это у нас тип без вопросиков.
Теперь наш предыдущий код перестанет компилироваться именно по причине того, что мы отрубили Wildcards. Вы можете в этом убедиться сами.
Мы разобрали ковариантные типы. Теперь обратная ситуация.
Мы считаем, что List у нас с вопросом. Очевидно предположить, что когда этот лист возвращается из getPlugins, он тоже будет с вопросом. А что это значит? Это значит, что мы не сможем в него записать, потому что тип ковариантный, а не контравариантный. Давайте взглянем, что происходит в Java.
```
final List plugins = Analytics.getPlugins();
displayPlugins(plugins);
Analytics.getPlugins().add(new EmptyPlugin());
```
Никто не возмущается, что в последней строчке мы что-то записываем, а это значит, что кто-то здесь не прав. Если заглянем в байткод, то убедимся в верности своих подозрений. Мы никаких аннотаций не навешивали, а тип почему-то без вопроса.
Сюрприз основан вот на чём. Kotlin постулирует себя, как язык прагматичный, поэтому, когда всё это проектировали, собирали статистику, как вообще используются wildcards в Java. Оказалось, что на вход чаще всего вариантность разрешают, то есть делают типы ковариантными. Ну полезно везде, где мы хотим List, иметь возможность засунуть туда лист любого наследника от Plugin. А вот там, где мы возвращаем, наоборот, мы хотим иметь чистые типы: как есть лист Plugin, так он и будет возвращён.
И здесь мы воочию видим пример этого. Это кажется немного контринтуитивно, зато порождает в вашем коде меньше чудных аннотаций, потому что это наиболее частый usecase, и если вы не пользуетесь какими-то приколами, всё будет работать из коробки.
Но в этом случае мы видим, что такая ситуация не для нас, потому что мы не хотим, чтобы туда можно было что-то записать. И также мы не хотим, чтобы это можно было сделать из Java. В Kotlin здесь List — это read only-тип, и мы туда ничего не можем записать, а пришёл клиент нашей библиотеки из Java и напихал туда всё подряд — кому это понравится? Поэтому мы собираемся зафорсить, чтобы этот метод возвращал List с wildcard. И мы можем это сделать понятно, как. Добавив аннотацию @JvmWildcard мы говорим: сгенерируй нам тип с вопросом, всё достаточно просто. Теперь посмотрим, что происходит в Java в этом месте. Java говорит «что ты делаешь?»:
Мы можем здесь даже привести к правильному типу List extends Plugin, но она всё равно говорит «что ты делаешь?» И, в принципе, эта ситуация нас пока что устраивает. Но найдётся script kiddie, который скажет «я же видел исходники, это же опенсорс, я знаю, что там ArrayList, и я вас похачу». И всё сработает, потому что там действительно ArrayList и он знает, что туда можно записывать.
```
((ArrayList) Analytics.getPlugins()).add(new EmptyPlugin());
```
Поэтому, конечно, клёво аннотации навешивать, но всё равно нужно использовать defensive-копирование, которое давным-давно известно. Сорян, без него никуда, если вы хотите, чтобы script kiddies вас не похачили.
```
@JvmStatic fun getPlugins(): List<@JvmWildcard Plugin> =
plugin.toImmutableList()
```
Добавлю только, что аннотацию @JvmSuppressWildcard можно навешивать как на параметр, тогда только он будет об этом знать, так и на функцию, так и на весь класс, тогда расширяется его зона действия.
Вроде бы всё хорошо, с нашей аналитикой мы разобрались. А теперь другая сторона, с которой мы можем подойти: плагин.
Мы хотим реализовать плагин на стороне Java. Как хорошие пацаны, мы репортим его исключение:
```
@Override public void send(@NotNull Event event)
throws IOException
```
Здесь же всё видно:
```
interface Plugin {
fun init()
/** @throws IOException if sending failed */
fun send(event: Event)
// ...
}
```
В Kotlin же нет checked exception. И мы говорим в документации: сюда можно кидать. Ну мы и кидаем, кидаем, кидаем. А Java не нравится почему-то. Говорит: «а нет Throws почему-то в вашей сигнатуре, месье»:
А как тут добавить-то, тут же Kotlin? Ну, вы знаете ответ…
Есть аннотация @Throws, которая именно это и делает. Она меняет throws-часть в сигнатуре метода. Мы говорим, что можем кинуть сюда IOExсeption:
```
open class EmptyPlugin : Plugin {
@Throws(IOException::class)
override fun send(event: Event) {}
// ...
}
```
И ещё добавим это дело заодно в интерфейс:
```
interface Plugin {
fun init()
/** @throws IOException if sending failed */
@Throws(IOException::class)
fun send(event: Event)
// ...
}
```
И теперь что? Теперь наш плагин, написанный на Java, где у нас есть информация об exception, всем доволен. Всё работает, компилируется. В принципе, с аннотациями на этом более-менее всё, но есть ещё два нюанса того, как использовать @JvmName. Один интересный.
Мы все эти аннотации добавляли для того, чтобы в Java было красиво. А вот здесь…
```
package util
fun List.printReversedSum() {
println(this.foldRight(0) { it, acc -> it + acc })
}
@JvmName("printReversedConcatenation")
fun List.printReversedSum() {
println(this.foldRight(StringBuilder()) { it, acc -> acc.append(it) })
}
```
Предположим, на Java нам здесь всё равно, уберём аннотацию. Опачки, теперь IDE показывает ошибку в обеих функциях. Как вы считаете, с чем это связано? Да, без аннотации они генерируются с одинаковыми именами, но здесь же написано, что один на List, другой на List. Верно, type erasure. Мы даже можем проверить это дело:
Вы уже в курсе, как я понял, что все top-level функции генерируются в статическом контекcте. И вот без этой аннотации мы постараемся сгенерировать printReversedSum от List, а ниже ещё один тоже от List. Потому что Kotlin-компилятор знает о дженериках, а Java-байткод не знает. Поэтому это единственный случай, когда аннотации из пакета kotlin.jvm нужны не для того, чтобы в Java было хорошо и удобно, а для того, чтобы ваш Kotlin собрался. Задаём новое имя — раз работаем со строками, то используем concatenation — и всё работает хорошо, теперь всё компилируется.
И второй юзкейс. Он связан вот с чем. У нас есть extension-функция reverse.
```
inline fun String.reverse() =
StringBuilder(this).reverse().toString()
inline fun reversedClassName() = T::class.java.simpleName.reverse()
inline fun Iterable.forEachReversed(action: (T) -> Unit) {
for (element in this.reversed()) action(element)
}
```
Этот reverse компилируется в статический метод класса, который называется ReverserKt.
```
private static void useUtils() {
System.out.println(ReverserKt.reverse("Test"));
SumsKt.printReversedSum(asList(1, 2, 3, 4, 5));
SumsKt.printReversedConcatenation(asList("1", "2", "3", "4", "5"));
}
```
Это, я думаю, не новость для вас. Нюанс в том, что чуваки, использующие нашу библиотеку в Java, могут заподозрить что-то неладное. Мы просочили детали имплементации нашей библиотеки на сторону юзера и хотим замести свои следы. Как мы можем это делать? Как уже понятно, аннотацией @JvmName, о которой я сейчас рассказываю, но есть один нюанс.
Для начала зададим ей такое имя, которое хотим, не палимся, и важно сказать, что мы применяем эту аннотацию на файле, переименовать нам надо именно файл.
```
@file:Suppress("NOTHING_TO_INLINE")
@file:JvmName("ReverserUtils")
```
Теперь компилятору в Java не нравится ReverserKt, но это ожидаемо, заменяем на ReverserUtils и все довольны. И такой «юзкейс 2.1» — частый случай, когда вы хотите методы нескольких ваших top-level файлов собрать под одним классом, под одним фасадом. Например, про вы не хотите, чтобы методы вышеприведённого sums.kt вызывались из SumsKt, а хотите, чтобы это всё тоже было про reversing и дёргалось из ReverserUtils. Тогда добавляем и туда эту чудную аннотацию @JvmName, пишем «ReverserUtils», в принципе, всё ок, можно даже попробовать это дело скомпилировать, но нет.
Хотя заранее среда не предупреждает, но при попытке компиляции нам скажут, что «вы хотите сгенерировать два класса в одном пакете с один именем, ата-та». Что нужно сделать? Добавить последнюю в этом пакете аннотацию @JvmMultifileClass, говорящую, что содержимое нескольких файлов будет превращаться в один класс, то есть для этого всего будет один фасад.
Добавляем в обоих случаях "@file:JvmMultifileClass", и можно заменять SumsKt на ReverserUtils, все довольны — поверьте мне. С аннотациями закончили!
Мы поговорили с вами об этом пакете, обо всех аннотациях. В принципе, уже из их названий понятно, для чего используется каждая. Есть хитрые кейсы, когда нужно, например, @JvmName использовать даже просто в Kotlin.
Kotlin-специфичное
------------------
Но, скорее всего это не всё, что вы хотели бы узнать. Ещё важно отметить, как работать с Kotlin-специфичными вещами.
Например, inline-функции. Они в Kotlin инлайнятся и, казалось бы, а будут ли они вообще доступны из Java в байткоде? Оказывается, будут, всё будет хорошо, и методы реально доступны для Java. Хотя если вы пишете, например, Kotlin-only проект, это не совсем хорошо сказывается на вашем dex count limit. Потому что в Kotlin они не нужны, а реально в байткоде будут.
Дальше надо отметить Reified type parameters. Такие параметры специфичны для Kotlin, они доступны только для инлайн-функций и позволяют воротить такие хаки, которые в Java с рефлексией недоступны. Так как это Kotlin-only штука, она доступна только для Kotlin, и в Java вы не сможете использовать функции с reified, к сожалению.
java.lang.Class. Если мы хотим немного порефлексировать, а библиотека наша и для Java, то и её надо поддержать. Давайте посмотрим пример. Есть у нас такой «свой Retrofit», быстро написанный на коленке (я вообще не понимаю, чего парни так долго писали):
```
class Retrofit private constructor(
val baseUrl: String,
val client: Client
) {
fun create(service: Class): T {...}
fun create(service: KClass): T {
return create(service.java)
}
}
```
Есть метод, который работает с классом Java, есть метод, который работает с котлиновским KClass, вам не нужно делать две разные реализации, вы можете использовать extension-проперти, которые из KClass достают Class, из Class достают KClass (он называется Kotlin, в принципе очевидно).
Это всё будет работать, но это немного неидиоматично. В Kotlin-коде вы не передаёте KClass, вы пишете с использованием Reified-типов, поэтому лучше метод переделать на вот такой:
```
inline fun create(): T {
return create(T::class.java.java)
```
Всё шикардос. Теперь пойдём в Kotlin и посмотрим, как эта штука используется. Там *val api = retrofit.create(Api::class)* превратилось в *val api = retrofit.create()*, никаких явных ::class не вылезает. Это типичное использование Reified-функции, и всё будет супер-пупер.
Unit. Если ваша функция возвращает Unit, то она прекрасно компилируется в функцию, которая возвращает void в Java, и обратно. Вы можете работать с этим взаимозаменяемо. Но всё это заканчивается в том месте, где у вас лямбды начинают возвращать юниты. Если кто-то работал со Scala, то в Scala есть вагон и маленькая тележка интерфейсов, которые возвращают какие-то значения, и такой же вагон с тележкой интерфейсов, которые не возвращают ничего, то есть с void.
А в Kotlin этого нет. В Kotlin есть только 22 интерфейса, которые принимают разный набор параметров и что-то возвращают. Таким образом, лямбда, которая возвращает Unit, будет возвращать не void, а Unit. И это накладывает свои ограничения. Как выглядит лямбда, которая возвращает Unit? Вот, посмотрим на неё в этом фрагменте кода. Познакомимся.
```
inline fun Iterable.forEachReversed(action: (T) -> Unit) {
for (element in this.reversed()) action(element)
}
```
Использование её из Kotlin: все хорошо, мы используем даже method reference, если можем, и читается отлично, глаза не мозолит.
```
private fun useMisc() {
listOf(1, 2, 3, 4).forEachReversed(::println)
println(reversedClassName())
}
```
Что происходит в Java? В Java происходит вот такая байда:
```
private static void useMisc() {
final List list = asList(1, 2, 3, 4);
ReverserUtils.forEachReversed(list, integer -> {
System.out.println(integer);
return Unit.INSTANCE;
});
```
Из-за того, что мы должны возвращать что-то здесь. Это как Void с большой буквы, мы не можем просто взять и забить на него. Мы не можем использовать здесь метод референсы, которые возвращают void, к сожалению. И это, наверное, пока первая штука, которая реально мозолит глаза после всех наших манипуляций с аннотациями. К сожалению, вам придется возвращать инстанс Unit отсюда. Можно null, всё равно он никому не нужен. В смысле, возвращаемое значение никому не нужно.
Поехали дальше: Typealiases — это тоже довольно специфичная штука, это просто алиасы или синонимы, они доступны только из Kotlin, и в Java, к сожалению, вы будете использовать то, что под этими алиасами. Либо это портянка трижды вложенных дженериков, либо какие-то вложенные классы. Java-программисты привыкли с этим жить.
А теперь интересное: visibility. А точнее, internal visibility. Вы наверняка знаете, что в Kotlin нет package private, если вы пишете без каких-либо модификаторов, это будет public. Зато есть internal. Internal — это такая хитрая штука, что мы сейчас на неё даже посмотрим. В Retrofit у нас есть internal-метод validate.
```
internal fun validate(): Retrofit {
println("!!!!!! internal fun validate() was called !!!!!!")
return this
}
```
Он не может быть вызван из Kotlin, и это понятно. Что происходит с Java? Можем ли мы вызвать validate? Возможно, для вас не секрет, что internal превращается в public. Если вы не верите мне, поверьте Kotlin bytecode viewer.
Это действительно public, но с такой страшной сигнатурой, которая намекает человеку, что это, наверное, не совсем так было задумано, что в публичное API пролезает вот такая портянка. Если у кого-то форматирование на 80 символов сделано, то такой метод может даже не влезть в одну строчку.
В Java у нас сейчас так:
```
final Api api = retrofit
.validate$production_sources_for_module_library_main()
.create(Api.class);
api.sendMessage("Hello from Java");
}
```
Давайте попробуем скомпилировать это дело. Так, по крайней мере, это не скомпилируется, уже неплохо. На этом можно было бы остановиться, но let me explain this to you. Что, если я сделаю вот так?
```
final Api api = retrofit
.validate$library()
.create(Api.class);
api.sendMessage("Hello from Java");
}
```
Тогда компилируется. И возникает вопрос «Почему так?» Что я могу сказать… MAGIC!
Поэтому очень важно, если вы засовываете что-то критическое в internal, это плохо, потому что это просочится в ваше публичное API. И если script kiddie будет вооружён Kotlin Bytecode Viewer, то будет плохо. Не используйте ничего очень важного в методах с internal visibility.
Если вам хочется еще немного радости, то рекомендую две вещи. Чтобы было комфортней работать с байткодом и читать его, рекомендую доклад от Жени Вартанова, есть [бесплатное видео](https://skillsmatter.com/skillscasts/10012-keynote-sinking-your-teeth-into-bytecode), несмотря на то, что это с мероприятия SkillsMatter. Очень круто.
И довольно старая [серия](https://medium.com/@BladeCoder/exploring-kotlins-hidden-costs-part-1-fbb9935d9b62) из трёх статей от Кристофа Бейлса про то, во что превращаются разные Kotlin-фичи. Там всё классно написано, что-то неактуально сейчас, но в целом весьма доходчиво. Всё тоже с Kotlin bytecode viewer и всё такое.
Спасибо!
> Если доклад понравился, обратите внимание: 8-9 декабря в Москве состоится новый **Mobius**, и там тоже будет много интересного. Уже известная информация о программе — [на сайте](https://mobiusconf.com), и билеты можно приобрести там же.
>
> | https://habr.com/ru/post/417951/ | null | ru | null |
# Независимо перегружаемые свойства
Стандартный механизм перегрузки свойств через методы \_\_get и \_\_set весьма не удобен для практического использования, однако с помощью него можно создать удобный dsl для работы со свойствами. Сразу же пример использования (тут и далее используется паттерн [адаптивной типизации](http://habrahabr.ru/blogs/php/95157/), с которым рекомендуется предваритильно ознакомиться):
> `class Title extends ProtoObject {
> protected $\_text= '';
> function set\_text( $val ){
> return $this->aTitleString( $val );
> }
> function get\_text( $val ){
> if( empty( $val ) ) return '[untitled]';
> return $val;
> }
>
> function aTitleString( $val ){
> aString( &$val );
> if( strlen( $val ) > 255 ) $val= substr( $val, 0, 252 ) . '...';
> return $val;
> }
> }
>
> $title= new Title;
> $title->text= 123;
> var\_dump( $title->text ); // string(3) "123"
> var\_dump( $title->text( '' )->text() ); // string(10) "[untitled]"
> echo $title;
> // Title Object
> // (
> // [\_text:protected] =>
> // )` | https://habr.com/ru/post/95233/ | null | ru | null |
# Особенности withCredentials
Многие знакомы с таким флагом XmlHttpRequest как withCredentials, знают для чего он нужен, какие заголовки нужно использовать с ним в паре, чтобы браузер нормально обрабатывал ответы сервера. И я вроде тоже знал, а что не знал — нагугливал, и всё работало как надо. Но однажды столкнулся с неожиданным поведением, о чём и хочу поведать.
Как указано в спецификации [www.w3.org/TR/cors/#omit-credentials-flag](http://www.w3.org/TR/cors/#omit-credentials-flag), withCredentials позволяет нам использовать в запросе к серверу [user-credentials](http://www.w3.org/TR/cors/#user-credentials), т.е. куки, аутентификационные данные и клиентские SSL-сертификаты.
Я делаю запрос для получения куки:
```
$.ajax
({
type: 'POST',
url: authUrl,
dataType: 'json'
});
```
Сервер возвращает корректный ответ с:
```
Set-Cookie:MYCOOKIE=7B6E846F8972DF580001CDCBF49316E; Path=/; HttpOnly
```
Далее я обращаюсь по тому же адресу с полученной кукой:
```
$.ajax
({
type: 'GET',
url: authUrl,
dataType: 'json',
cache: false,
xhrFields: {
withCredentials: true
}
});
```
Здесь и происходит неожиданное для меня: хоть я и указал «withCredentials: true», полученная из первого запроса кука не отправляется во втором запросе.
Выясняется, что кука из первого запроса не сохраняется браузером, и отправлять со вторым запросом нечего.
Предположил, что причина в HttpOnly, но проверить с кукой без этого флага не получилось, потому что перед этим попробовал добавить «withCredentials: true» в первый запрос, и происходит чудо — кука сохраняется браузером, и во втором запросе она успешно отправляется.
Таким образом, получается, что указание «withCredentials: true» необходимо не только для отправки «user-credentials» в **запросе** к серверу, но и для использования их из ответов от сервера. Вроде бы логично, но использование слова «request» во всех спецификациях и описаниях сбивает с толку, надеюсь не только меня)
PS. Как то я упустил эту [спецификацию](http://www.w3.org/TR/XMLHttpRequest/#the-withcredentials-attribute), где прямо написано, что при отсутствии этого атрибута «cookies are to be ignored in response», двойка мне за навыки поиска. Но надеюсь, теперь многие смогут избежать возможного недопонимания. | https://habr.com/ru/post/263417/ | null | ru | null |
# JavaScript: захват медиапотока из DOM элементов
Привет, друзья!
Продолжаю исследовать возможности по работе с медиа, предоставляемые современными браузерами, и в этой статье хочу рассказать вам о возможности захвата и записи медиаданных в процессе воспроизведения аудио и видеофайлов.
Мы разработаем простое приложение для сведения аудио и видео со следующим функционалом:
* пользователь выбирает одно видео и несколько аудио, хранящихся в его файловой системе;
* когда пользователь нажимает на кнопку для начала записи, запускается воспроизведение выбранных файлов, захватываются их медиапотоки;
* захваченные потоки объединяются в один и передаются для записи;
* в процессе записи пользователь может менять источник аудиоданных;
* пользователь может приостанавливать (например, для изменения источника аудиоданных) и продолжать запись;
* по окончанию записи генерируется видеофайл в формате [`WebM`](https://ru.wikipedia.org/wiki/WebM) — превью сведенного контента и ссылка для его скачивания.
В качестве фреймворка для фронтенда я буду использовать [`React`](https://ru.reactjs.org/), однако все функции по работе с медиа будут автономными (сигнатура этих функций будет framework agnostic), так что вы можете использовать любой другой фреймворк или ограничиться чистым `JavaScript`.
**Песочница:**
[Репозиторий](https://github.com/harryheman/Blog-Posts/tree/master/capture-stream).
О том, как разработать приложение для создания аудиозаметок, можно прочитать в [этой статье](https://habr.com/ru/company/timeweb/blog/581086/), а о том, как разработать приложение для захвата и записи экрана — в [этой](https://habr.com/ru/company/timeweb/blog/591417/).
Если вам это интересно, прошу под кат.
Если вы внимательно изучили функционал нашего будущего приложения, то могли заметить, что пользователь может выбрать только одно видео и имеет возможность менять только источник аудиоданных. Это связано с тем, что на сегодняшний день в процессе записи медиаданных возможна замена только аудиоисточника (без создания нового экземпляра `MediaRecorder`).
В процессе разработки приложения мы будем опираться на следующие спецификации (черновики и рекомендацию):
* [Media Capture from DOM Elements](https://www.w3.org/TR/mediacapture-fromelement/) — захват медиапотока из DOM элементов;
* [MediaStream Recording](https://www.w3.org/TR/mediastream-recording/) — запись медиаданных;
* [Media Capture and Streams. MediaStream API](https://w3c.github.io/mediacapture-main/#stream-api) — интерфейс для объединения медиапотоков;
* [Web Audio API. MediaStreamAudioDestinationNode и MediaStreamAudioSourceNode](https://www.w3.org/TR/webaudio/#MediaStreamAudioDestinationNode) — интерфейсы для создания динамического источника аудиоданных;
* [File API. The Blob Interface and Binary Data и A URL for Blob and MediaSource reference](https://w3c.github.io/FileAPI/#blob-section) — создание объекта `Blob` и ссылки на него.
Ссылки на соответствующие разделы `MDN` будут приводиться по мере необходимости.
Создаем шаблон `React-приложения` с помощью [`create-react-app`](https://create-react-app.dev/):
```
yarn create react-app capture-stream
# or
npx create-react-app capture-stream
```
Пока генерируется шаблон, поговорим об интерфейсах и методах, которые мы будем применять.
* Для захвата медиапотока в процессе воспроизведения аудио или видео, а также в процессе рендеринга `canvas`, используется метод [`captureStream`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/captureStream). К сожалению, на сегодняшний день данный метод не поддерживается Safari, а в Firefox он поддерживается с префиксом (`mozCaptureStream`):
```
const audio$ = document.querySelector('audio')
audio$.play()
const stream = audio$.captureStream()
```
* Для объединения потоков используется интерфейс [`MediaStream`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream):
```
const audioStream = audio$.captureStream()
const videoStream = video$.captureStream()
const audioTracks = audioStream.getAudioTracks()
const videoTracks = videoStream.getVideoTracks()
const mediaStream = new MediaStream([...audioTracks, ...videoTracks])
```
* Для записи медиа данных используется интерфейс [`MediaRecorder`](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder):
```
const mediaChunks = []
const mediaRecorder = new MediaRecorder(mediaRecorder, {
mimeType: 'video/webm',
// другие настройки
})
// обработка полученных данных
mediaRecorder.ondataavailable = (e) => {
// части данных в виде `Blob`
mediaChunks.push(e.data)
}
// метод `start` принимает опциональный параметр `timeslice` - время в мс,
// по истечении которого возникает событие `dataavailable`
mediaRecorder.start(250)
// другие методы
mediaRecorder.stop()
mediaRecorder.pause()
mediaRecorder.resume()
// свойства
// неактивен
mediaRecorder.inactive
// идет запись
mediaRecorder.recording
// запись приостановлена
mediaRecorder.paused
```
* Для создания сведенного видеофайла мы будем использовать интерфейс [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) в сочетании с методом [`createObjectURL`](https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL):
```
const blob = new Blob(mediaChunks, {
type: 'video/webm',
// другие настройки
})
// формируем путь к файлу, хранящемуся в памяти,
// для передачи элементам `video` и `a`
const url = URL.createObjectURL(blob)
```
* Наконец, для создания динамического источника аудиоданных используется сочетание интерфейсов [`AudioContext`](https://developer.mozilla.org/en-US/docs/Web/API/AudioContext), [`MediaStreamAudioDestinationNode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioDestinationNode) и [`MediaStreamAudioSourceNode`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode):
```
// создаем аудио контекст
const audioContext = new AudioContext()
// создаем передатчик аудио
const mediaStreamAudioDestinationNode = new MediaStreamAudioDestinationNode(
audioContext
)
// создаем источник аудио с помощью аудиопотока, захваченного из элемента `audio`
// контекст передатчика и источника должен быть одинаковым
const mediaStreamAudioSourceNode = new MediaStreamAudioSourceNode(audioContext, {
mediaStream: audioStream
})
// подключаем источник к передатчику
mediaStreamAudioSourceNode.connect(mediaStreamAudioDestinationNode)
// далее вместо `audioStream.getAudioTracks()` в `new MediaStream()` передается
mediaStreamAudioDestinationNode.stream.getAudioTracks()
```
Шаблон готов. Приступим к разработке приложения.
Структура директории `src` будет следующей:
```
- assets - 2 аудиофайла и 1 видеофайл (можете использовать свои)
- components - компоненты
- AudioSelector.js - для выбора аудио
- VideoSelector.js - для выбора видео
- Recorder.js - для записи
- Result.js - для результата записи
- hook - хуки
- usePrevious.js - для сохранения значения предыдущего состояния
- utils - утилиты
- verifySupport.js - для проверки поддержки используемых технологий
- recording.js - для записи и формирования ее результата
- createStore.js - для создания хранилища состояния
- App.js
- App.scss
- index.js
- ...
```
Как видите, для стилизации приложения я пользовался [`Sass`](https://sass-lang.com/):
```
yarn add -D sass
# or
npm i -D sass
```
Начнем с основного компонента приложения (`App.js`).
Импортируем компоненты, утилиту для создания хранилища состояния и стили:
```
import { VideoSelector, AudioSelector, Recorder, Result } from 'components'
import { createStore } from 'utils/createStore'
import './App.scss'
```
Создаем хранилище и импортируем хуки:
```
const store = {
state: {
// выбранное пользователем аудио
audio: '',
// ... видео
video: '',
// результат записи
result: ''
},
setters: {
// соответствующие методы
setAudio: (_, audio) => ({ audio }),
setVideo: (_, video) => ({ video }),
setResult: (_, result) => ({ result })
}
}
export const [Provider, useStore, useSetters] = createStore(store)
```
С вашего позволения, я не буду останавливаться на утилите (почитать о ней можно [здесь](https://habr.com/ru/company/timeweb/blog/597109/)). Справедливости ради следует отметить, что в последнее время для создания хранилища состояния я все чаще прибегаю к помощи [`zustand`](https://github.com/pmndrs/zustand).
Создаем и экспортируем компонент:
```
function App() {
return (
)
}
export default App
```
Компонент для выбора видео (`components/VideoSelector.js`):
```
import { useState, useEffect, useRef } from 'react'
import { useSetters } from 'App'
export const VideoSelector = () => {
// состояние для пути к выбранному видео
const [fileUrl, setFileUrl] = useState()
// иммутабельная переменная для ссылки на элемент `video`
const videoRef = useRef()
// метод для сохранения ссылки на элемент `video`
const { setVideo } = useSetters()
// сохраняем ссылку на элемент `video` при наличии
// пути к выбранному файлу и самого элемента
useEffect(() => {
if (fileUrl && videoRef.current) {
setVideo(videoRef.current)
}
}, [fileUrl, setVideo])
// метод для выбора файла
const selectFile = (e) => {
if (e.target.files.length) {
const url = URL.createObjectURL(e.target.files[0])
setFileUrl(url)
}
}
// инпут для выбора файла
const Input = () => (
Choose video file
)
// превью выбранного файла
const File = () => (
)
// условный рендеринг
return {fileUrl ? : }
}
```
Компонент для выбора аудио (`components/AudioSelector.js`). Сигнатура данной функции немного сложнее предыдущей, поскольку пользователь может выбрать несколько файлов, но, в целом, все тоже самое:
```
import { useState, useEffect, useRef } from 'react'
import { useSetters } from 'App'
export const AudioSelector = () => {
const [fileUrls, setFileUrls] = useState()
const inputRef = useRef()
const { setAudio } = useSetters()
useEffect(() => {
// выбираем первый файл по списку после загрузки
if (inputRef.current) {
inputRef.current.click()
}
}, [fileUrls])
const selectFiles = (e) => {
if (e.target.files.length) {
const urls = [...e.target.files].map((f) => URL.createObjectURL(f))
setFileUrls(urls)
}
}
// метод для выбора элемента `audio`
const selectAudio = (e) => {
setAudio(e.target.nextElementSibling)
}
const Input = () => (
Choose audio files
)
const Files = () => (
Select audio
------------
{fileUrls?.map((u, i) => (
))}
)
return (
{fileUrls ? : }
)
}
```
Кратко рассмотрим утилиту для определения поддержки используемых технологий (`utils/verifySupport.js`):
```
// утилита возвращает массив неподдерживаемых "фич"
export default function verifySupport() {
const unsupportedFeatures = []
if (
!('captureStream' in HTMLAudioElement.prototype) &&
!('mozCaptureStream' in HTMLAudioElement.prototype)
) {
unsupportedFeatures.push('captureStream()')
}
;[
'MediaStream',
'MediaRecorder',
'Blob',
'AudioContext',
'MediaStreamAudioSourceNode',
'MediaStreamAudioDestinationNode'
].forEach((f) => {
if (!(f in window)) {
unsupportedFeatures.push(f)
}
})
return unsupportedFeatures
}
```
Переходим к самой интересной части.
Начнем с методов для записи и формирования ее результата (`utils/recording.js`).
Импортируем утилиту для определения поддержки и создаем глобальные (в пределах модуля) переменные:
```
import verifySupport from './verifySupport'
let mediaChunks = []
let mediaRecorder
let audioContext
let mediaStreamAudioDestinationNode
let mediaStreamAudioSourceNode
```
Функция для начала записи:
```
// функция принимает элементы `audio` и `video`, а также `timeslice`
export const startRecording = ({ audio, video, timeslice = 250 }) => {
// проверяем поддержку
const unsupportedFeatures = verifySupport()
if (unsupportedFeatures.length)
return console.error(`${unsupportedFeatures.join(', ')} not supported`)
// захватываем потоки
const videoStream =
(video.captureStream && video.captureStream()) || video.mozCaptureStream()
const audioStream =
(audio.captureStream && audio.captureStream()) || audio.mozCaptureStream()
// см. выше
audioContext = new AudioContext()
mediaStreamAudioDestinationNode = new MediaStreamAudioDestinationNode(
audioContext
)
mediaStreamAudioSourceNode = new MediaStreamAudioSourceNode(audioContext, {
mediaStream: audioStream
})
mediaStreamAudioSourceNode.connect(mediaStreamAudioDestinationNode)
// объединяем потоки
const mediaStream = new MediaStream([
...videoStream.getVideoTracks(),
...mediaStreamAudioDestinationNode.stream.getAudioTracks()
])
// создаем экземпляр "записывателя" медиа,
// передавая ему объединенный поток и указывая тип данных
mediaRecorder = new MediaRecorder(mediaStream, { mimeType: 'video/webm' })
// обрабатываем запись данных
mediaRecorder.ondataavailable = (e) => {
mediaChunks.push(e.data)
}
// сообщаем о начале записи
console.log('*** Start recording')
// запускаем запись
mediaRecorder.start(timeslice)
}
```
Функция для остановки записи:
```
export const stopRecording = () => {
// если запись не запускалась, ничего не делаем
if (!mediaRecorder) return
// останавливаем запись
console.log('*** Stop recording')
mediaRecorder.stop()
// формируем результат - видео в формате `WebM`
const result = new Blob(mediaChunks, { type: 'video/webm' })
// очистка
mediaRecorder = null
mediaChunks = []
// возвращаем результат
return result
}
```
Функция замены источника аудиоданных:
```
// функция принимает элемент `audio`
export const replaceAudioInStream = (audio) => {
// захватываем поток
const audioStream = audio.captureStream()
// создаем новый источник аудио данных
const newMediaStreamAudioSourceNode = new MediaStreamAudioSourceNode(
audioContext,
{ mediaStream: audioStream }
)
// подключаем новый источник к старому передатчику
newMediaStreamAudioSourceNode.connect(mediaStreamAudioDestinationNode)
// отключаем старый источник
mediaStreamAudioSourceNode.disconnect()
// рокировка
mediaStreamAudioSourceNode = newMediaStreamAudioSourceNode
}
```
Наконец, функции для приостановки и продолжения записи:
```
export const pauseRecording = () => {
if (!mediaRecorder) return
console.log('*** Pause recording')
mediaRecorder.pause()
}
export const resumeRecording = () => {
if (!mediaRecorder) return
console.log('*** Resume recording')
mediaRecorder.resume()
}
```
Компонент для записи (`components/Recorder.js`).
Импортируем хуки и утилиты:
```
import { useState } from 'react'
import { useSetters, useStore } from 'App'
import { usePrevious } from 'hooks/usePrevious'
import {
startRecording,
stopRecording,
pauseRecording,
resumeRecording,
replaceAudioInStream
} from 'utils/recording'
export const Recorder = () => {
// TODO
}
```
Извлекаем сеттер и части состояния из хранилища, сохраняем ссылку на элемент `audio` и определяем локальное состояние для индикатора паузы и начала записи:
```
const { setResult } = useSetters()
const { audio, video } = useStore()
const previousAudio = usePrevious(audio)
const [paused, setPaused] = useState(false)
const [recordingStarted, setRecordingStarted] = useState(false)
```
Определяем метод для управления воспроизведением аудио и видео:
```
// функция принимает тип операции
const toggleAudioVideo = (action) => {
switch (action) {
// воспроизведение
case 'play': {
if (audio.paused) {
audio.play()
}
if (video.paused) {
video.play()
}
break
}
// пауза
case 'pause': {
if (!audio.paused) {
audio.pause()
}
if (!video.paused) {
video.pause()
}
break
}
// остановка
// HTMLAudioElement.prototype и HTMLVideoElement.prototype
// не предоставляют метода `stop`
case 'stop': {
// ставим воспроизведение на паузу
toggleAudioVideo('pause')
// обнуляем текущее время воспроизведения
audio.currentTime = 0
video.currentTime = 0
break
}
default:
return
}
}
```
Определяем метод для начала записи:
```
const start = () => {
// проверяем наличием элементов `audio` и `video` и то,
// что запись еще не запускалась
if (video && audio && !recordingStarted.current) {
// запускаем воспроизведение
toggleAudioVideo('play')
// передаем элементы утилите
startRecording({ audio, video })
// обновляем состояние
setRecordingStarted(true)
}
}
```
Определяем метод для приостановки/продолжения воспроизведения:
```
const pauseResume = () => {
if (!paused) {
toggleAudioVideo('pause')
pauseRecording()
} else {
toggleAudioVideo('play')
// если при продолжении воспроизведения элемент `audio`
// отличается от элемента, сохраненного в `previousAudio`,
// значит, необходимо заменить источник аудио данных
if (previousAudio !== audio) {
console.log('*** New audio')
replaceAudioInStream(audio)
}
resumeRecording()
}
setPaused(!paused)
}
```
Наконец, определяем метод для остановки записи:
```
const stop = () => {
toggleAudioVideo('stop')
const result = stopRecording()
setResult(result)
setRecordingStarted(false)
}
```
Ну и, конечно, разметка:
```
if (!audio || !video) return null
return (
{!recordingStarted ? (
Start recording
) : (
<>
{paused ? 'Resume' : 'Pause'}
Stop
)}
)
```
Последний компонент — результат записи (`components/Result.js`):
```
import { useStore } from 'App'
export function Result() {
const { result } = useStore()
if (!result) return null
const url = URL.createObjectURL(result)
return (
[Download]({url})
)
}
```
Думаю, тут все понятно.
Проверяем работоспособность нашего приложения.
Запускаем сервер для разработки с помощью `yarn start` или `npm start`:
Выбираем видео и аудиофайлы:
Нажимаем на кнопку `Start recording`:
Начинается воспроизведение и запись данных.
Нажимаем `Pause`, выбираем другой аудио файл и нажимаем `Resume`:
Нажимаем `Stop`:
Генерируется сведенный контент, появляется превью и ссылка для скачивания файла.
Все работает, как ожидается.
Пожалуй, это все, чем я хотел поделиться с вами в этой статье.
Благодарю за внимание и 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/646831/ | null | ru | null |
# Теория лоадеров
За последние 5 лет я написал множество лоадеров. Это так называемые программки, которые парсят инфу на сайтах-источниках и сохраняют ее себе в базу. Зачастую они представляют из себя последовательность регулярных выражений, с помощью которых находятся значения в нужных клеточках. Лоадеры могут авторизоваться, могут коннектиться через прокси, а иногда даже распознавать защитные картинки. Суть не в этом.
Теоретическая проблема в том, что невозможно написать абсолютно автоматический лоадер. Мы можем затырить любую инфу, но база превращается в свалку, если лоадер теряет классификацию сайта-источника. А когда начинаем сохранять классификацию, возникает проблема.
Рассмотрим пример. Пусть есть автосайт, на который грузятся объявления о продаже авто с сотни других ресурсов. Лоадер парсит объяву, выдает массив:
`{марка:"ford", модель:"focus", модификация:"1.6 Ti-VCT 5d", описание: итд...}.`
Автоматический лоадер часто работает так: смотрит в таблице марок по названию, если есть ford — берет id марки, если нет — добавляет «ford» в марки, и берет его id. То же делает с моделью и модификацией. Потом добавляет объявление с полученными id-шниками. Такая система плоха тем, что обязательно найдется объява, в которой на месте марки будет «ФОРД» или не «ВАЗ», а «VAZ», или «автоВаз», или не «Санкт-Петербург», а «С-Петербург»,«СПб»,«Cп-б». Умный гугл поймет, что это синонимы, а наш глупенький лоадер, сверяющий названия посимвольно, нет. В результате получается бардак в таблицах с классификациями.
Пытаясь минимизировать ручной труд монгола/модератора, я придумал такой алгоритм.
Прежде всего, лоадер состоит из двух частей.
**Первая — loader\_pages.**
Скрипт просматривает страницы со списками объявлений типа вот таких <http://cars.auto.ru/cars/used/ford/focus/> и тупо собирает ссылки на отдельные объявы. + находит ссылки на переходы по страницам и идет по ним рекурсией. Нашел ссылку на объяву — добавил ее в базу или, если она уже добавлена, обновил «дату последнего нахождения» на текущую. Это нужно для того, чтобы (лоадер работает ежечасно) удалять объекты, у которых дата нахождения ссылки достаточно старая (это значит, что ссылка уже не найдена, а значит объект с источника был удален).
**Вторая — loader\_offer.**
Берет из базы еще не обработанные ссылки, грузит html, парсит. Получает массив типа
`{марка:"ford", модель:"focus", модификация:"1.6 Ti-VCT 5d", описание: итд...}`
Грузит табличку compares. В ней находятся сопоставления, которые будут вручную обрабатываться модератором. Табличка состоит из полей:
`{лоадер,тип,найденное значение,id в соответствующей таблице классификации}.`
В нашем случае,
`{лоадер:"auto.ru",тип:"марка",значение:"ford",сопоставление:"..."}.`
Если соответствующее сравнение уже проставлено, ура победа, берем id-шник. Если нет — добавляем в compares новое сравнение, а объект не добавляем.
Модератор просматривает не проставленные сравнения и сопоставляет им значения из соответствующих «хороших» наших таблиц с марками автомобилей, моделями, городами итд.
**Паренты.**
Все хорошо работает пока таблицы маленькие. К примеру, марки авто — их всего 100. Сопоставить раз плюнуть. Моделей в моей базе 7000, а модификаций — 20.000. Представляете, из 20 тысяч выбрать сопоставление модификации «1.6 Ti-VCT 5d», которая у меня называется «1.6 Ti-VCT»? Модератор умирает. Или нужен хороший поиск.
Но можно сделать проще. При загрузке объявы мы будем обрабатывать сравнения по-порядку, сначала марка, затем модель, после модификация. Берем сравнение для марки,
`{лоадер:"auto.ru",тип:"марка",значение:"ford",сопоставление:"..."},`
находим его или добавляем — не суть. Берем id-шник этого сравнения и записываем его в дополнительное поле parent для сравнения модели:
`{лоадер:"auto.ru",тип:"модель",значение:"focus",сопоставление:"...",parent:"id сравнения марки"}.`
То же самое делаем в модификации, в парент которой пишем id сравнения модели.
Модератор работает по-порядку. Сначала берет сравнения марок и все их проставляет. Потом берет сравнение модели. При этом мы видим, что у сравнения есть parent-сравнение марки, которое уже проставлено, поэтому в качестве вариантов для сопоставления нужно выводить не все возможные модели, а только те, у которых марка соответствует значению этого parent-сравнения. Ну то есть «Ford» проставили, а затем «Focus» выбираем не из 7000 моделей, а только из сотни моделей фордов.
Суть этого поста вовсе не в том, что я придумал что-то абсолютно новое. Просто нигде не встречал описания этих программ. А у меня мне нравится именно излишняя практичность, потому что в принципе ясно, что каждый объект — подмножество вершин некоторых деревьев, а парсер — это сопоставление элементов html-кода страницы этим вершинам. Можно бы было навести теорию, что-то вроде языка для описания парсеров итд… С другой стороны, средний код лоадера на php у меня занимает 2 страницы. И не ясно, стоит ли париться с теорией, потому как мне не придумать, как еще уменьшить и упростить этот код, даже применив какой-то абстрактный язык. | https://habr.com/ru/post/68182/ | null | ru | null |
# Как собрать образ Oracle DB для Testcontainers
Код должен тестироваться на той СУБД, с которой он будет работать. Testcontainers — это такая библиотека, которая позволяет использовать в юнит тестах практически любую СУБД с той же лёгкостью, что embedded базы данных типа HSQLDB или H2. Был бы только Docker образ
Именно сборке удобного для использования с Testcontainers докер образа посвящена эта статья. У меня при попытке его сделать возникли проблемы, и тут я делюсь своим решением.
Собирать буду образ для Oracle 11, потому он небольшого размера и мне версии 11 хватает. С другими версиями подход примерно тот же.
Для того, чтобы было понятно, как использовать образ, тут также будет код на Java, который демонстрирует применение образа для тестирования Spring Boot приложений. Способ подключения к testcontainers я привёл, наверное, не самый лучший. Но во-первых он демонстрирует как использовать настройки, заданные при создании образа. Во-вторых он простой. И в-третьих он почти не завязан на Spring, его можно воткнуть даже в джава код, в котором нет ничего, кроме public static void main.
Предполагается, что читатель обладает поверхностным знакомством с Docker и Testcontaners, а также хорошо знает Java. Для сборки нужно использовать linux, если собираете под Windows, нужно будет применить msys2 или что-то в этом духе.
Демонстрационный код залит на гитхаб вот сюда <https://github.com/poxu/testcontainers-spring-demo> Поправленные скрипты для сборки образа можно посмотреть в моём форке Оракловских инструкций <https://github.com/poxu/docker-images/tree/master/OracleDatabase/SingleInstance>
Сборка Docker образа
====================
Oracle не предоставляет образов для docker, но выложила на гитхаб подробную инструкцию, как их собрать.
К сожалению, использовать эти образы в testcontainers as-is невозможно, потому что контейнер, который запускается из этого образа, стартует от двух до 20 минут.
Для использования в юнит-тестах это неприемлемо, поэтому нужно вносить в скрипты свои правки, но вначале лучше попробовать собрать контейнер по той инструкции, которую предоставляет Оракл. Я тут сделаю краткий пересказ, более полная инструкция находится по этой ссылке <https://github.com/oracle/docker-images/tree/master/OracleDatabase/SingleInstance>
Сборка образа согласно инструкции от Оракла
-------------------------------------------
Во-первых, нужно клонировать репозиторий с инструкциями как собирать образ.
```
git clone https://github.com/oracle/docker-images.git
```
Потом добыть rpm пакет для уставноки экспресс версии Оракла 11.2.0.2 Это не очень сложно, нужно просто зарегистрироваться на сайте оракла, перейти на страницу скачивания СУБД Оракл, там выбрать версию 11.2.0.2 XE и скачать запакованный rpm файл oracle-xe-11.2.0-1.0.x86~64~.rpm.zip.
Положить файл в скачанный гит репозиторий в директорию docker-images/OracleDatabase/SingleInstance/dockerfiles/11.2.0.2/
Дальше перейти в директорию docker-images/OracleDatabase/SingleInstance/dockerfiles и выполнить команду
```
./buildDockerImage.sh -v 11.2.0.2 -x
```
Докер соберёт образ, под названием oracle/database:11.2.0.2-xe на основе которого надо сделать контейнер вот такой командой
```
docker run --rm --name vanilla_oracle_test_habr \
-p 1234:1521 \
-p 5678:5500 \
-e ORACLE_PWD=123 \
--shm-size="1g" \
oracle/database:11.2.0.2-xe
```
Контейнер стартует несколько минут, потому что после старта он создаёт новую БД, а это процесс не быстрый.
Через несколько минут в консоли появится баннер
> #########################
>
> DATABASE IS READY TO USE!
>
> #########################
После этого можно подключиться к БД, используя логин SYSTEM, пароль — 123, адрес для подключения — localhost и SID — XE.
Если всё сработало, то можно переходить к процессу создания образа под testcontainers. Если нет, то лучше сначала пройти по мануалу от оракла и разобраться что не так.
Как мы уже выяснили, контейнер долго стартует из-за того, что после старта создаётся БД. В каких-то случая это наверное может быть удобно, но сейчас от этого выходит сплошной вред. Нужно сделать так, чтобы контейнер был готов к работе сразу после запуска.
Доработка образа вручную
------------------------
Один из способов получить образ с готовой БД — это подождать пока контейнер стартует и создание БД будет завершено, а потом сохранить контейнер в новый образ.
Важно только не стартовать контейнер с аргументом --rm, а то докер прибьёт его сразу после остановки.
```
docker commit --message "container for unit tests" my/oracle-11.2.0.2-for-unit-tests
```
Это создаст из контейнера новый образ, который будет запускаться уже не несколько минут, а 20 — 30 секунд.
Модификация процесса сборки образа с целью получить готовый образ сразу после сборки
------------------------------------------------------------------------------------
Конечно, хорошо иметь инструкцию по сборке образа в виде кода, чтобы можно было запустить сборку одной командой и не было необходимости дожидаться старта контейнера и создавать образ на его основе руками.
В последней строке докерфайла указана команда, которая выполняется после старта
```
CMD exec $ORACLE_BASE/$RUN_FILE
```
\$ORACLE~BASE~/\$RUN~FILE~ указывает на файл docker-images/OracleDatabase/SingleInstance/dockerfiles/11.2.0.2/runOracle.sh
Если этот контейнер остановить и потом запустить снова, то в результате в первый раз скрипт сделает базу данных, а во второй раз просто её запустит. Можно предположить, что если выполнить скрипт на этапе сборки образа, то образ соберётся с уже созданной БД.
Но на пути реализации этого смелого плана возникает одна сложность.
Скрипт работает вечно, то есть пока в контейнер не придёт сигнал, что работу необходимо завершить. Это решается достаточно просто. Последняя строка файла runOracle.sh содержит команду wait. Мы знаем, что на этапе сборки ждать ничего не надо, надо закончить работу и поэтому поставим в скрипте условный оператор.
Он будет проверять, не передан ли файлу аргумент --running-while-building и если этот аргумент передан, то не ждать никаких сигналов, а просто прерывать работу. То есть сделать вот так:
```
if [ "$1" != "--running-while-building" ]
then
wait $childPID
fi
```
Ну а в докерфайл добавим ещё один вызов скрипта, только уже на этапе сборки. Получится вот так.
```
RUN $ORACLE_BASE/$RUN_FILE --running-while-building
CMD exec $ORACLE_BASE/$RUN_FILE
```
Изменения, нужные для использования в тестировании
--------------------------------------------------
### Устранить использование томов
Нужно найти строку
> VOLUME ["\$ORACLE~BASE~/oradata"]
И закомментировать её. Использовать тома надобности нет, потому что все изменения будут выбрасываться после каждого прогона тестов, а вот проблемы с использованием томов легко могут возникнуть при копировании образов.
### Удалить ненужные файлы
Нужно добавить строки
```
rm -rf $ORACLE_HOME/demo && \
rm -rf $ORACLE_HOME/jdbc && \
rm -rf $ORACLE_HOME/jlib && \
rm -rf $ORACLE_HOME/md && \
rm -rf $ORACLE_HOME/nls/demo && \
rm -rf $ORACLE_HOME/odbc && \
rm -rf $ORACLE_HOME/rdbms/jlib && \
rm -rf $ORACLE_HOME/rdbms/public && \
rm -rf $ORACLE_HOME/rdbms/demo && \
rm -rf $ORACLE_HOME/bin/rman && \
```
Сразу перед строкой
```
chmod ug+x $ORACLE_BASE/*.sh
```
Это удалит из образа все файлы, которые для использования в целях тестирования не нужны. Чем меньше образ, тем лучше.
### Убрать разбиение образа на слои
В целях уменьшения образа нужно собирать его с использованием аргумента **squash**. Он уберёт из образа разделение на слои, что ещё немного уменьшит его объём. Аргумент squash экспериментальный, поэтому возможность его использовать придётся включить отдельно. В разных операционных системах это делается по разному.
Для проброса аргументов в докер в docker-images/OracleDatabase/SingleInstance/dockerfiles/buildDockerImage.sh предусмотрен аргумент -o. То есть, чтобы пробросить аргумент --squash в докер нужно вызывать buildDockerImage.sh вот так
```
./buildDockerImage.sh -o '--squash'
```
### Поменять название образа
К текущему моменту образ существенно отличается от того, что предлагает сделать Оракл, поэтому его надо переименовать. Для этого уже надо править сам файл buildDockerImage.sh Название образа скрипт берёт из переменной IMAGE~NAME~, значение которой задаётся прямо в файле
Вот тут
```
# Oracle Database Image Name
IMAGE_NAME="oracle/database:$VERSION-$EDITION"
```
Я поменял на
```
# Oracle Database Image Name
IMAGE_NAME="my/oracle-for-habr:$VERSION-$EDITION"
```
### Задать пароль к БД
Этот пароль задаётся в переменной окружения ORACLE~PWD~ на этапе первого запуска контейнера. Но у нас настройка базы данных происходит во время сборки образа, поэтому переменную нужно определить ещё на этом этапе. Если возможность задавать пароль при каждой сборке через командную строку не нужна, то можно просто вписать в докерфайл:
```
ENV ORACLE_PWD=123
```
Если для чего-то нужно иметь возможность определять пароль заново при каждой сборке, то для проброса аргумента в докер опять можно использовать -o
```
./buildDockerImage.sh -v 11.2.0.2 -x -o '--squash --build-arg ORACLE_PWD=123'
```
Это передаст в докерфайл переменную окружения ORACLE~PWD~, но докерфайл не передаст её в скрипты, которые запускаются во время сборки. Для того, чтобы он это сделал, нужно добавить в докерфайл инструкцию ARG.
```
ARG ORACLE_PWD=default
```
Пароль, как наверное уже стало ясно — будет 123, а если не передавать ORACLE~PWD~ в buildDockerImage.sh то default.
Иногда Оракл считает, что пароль плохой и работать не хочет, так что возможно надо будет заменить 123 на что-то другое
Тестовое поднятие полученного образа
------------------------------------
Теперь можно попробовать запустить контейнер на основе образа
```
docker run --rm --name dockertest_habr \
-p 1234:1521 \
-p 5678:5500 \
--shm-size="1g" \
my/oracle-for-habr:11.2.0.2-xe
```
Тут важен аргумент --shm-size="1g", без которого контейнер стартует, но сам Оракл 11.2.0.2 работать не сможет. Это, на всякий случай, не означает, что контейнеру понадобится гигабайт оперативной памяти, он отжирает около 100 мегабайт.
Если контейнер нормально поднялся, можно попробовать подключиться к БД, которая там находится.
Адрес базы — скорее всего localhost
Порт — 1234
Пользователь — SYSTEM
Пароль — 123
Если нормально запустилось, то можно приступать к следующему этапу
Скрипт инициализации БД
-----------------------
Для того, чтобы программа могла работать с базой данных из образа, нужно, чтобы там после запуска была схема. Можно создать эту схему на этапе сборки, но я предпочитаю делать это когда контейнер стартует.
После запуска контейнер посмотрит в директорию *u01/app/oracle/scripts/startup* и выполнит все sql скрипты, которые там найдёт, чем и можно воспользоваться, положив туда файл который создаст схему. Что-то в этом духе.
```
CREATE USER TEST_USER IDENTIFIED BY passwordnoquotes;
ALTER USER TEST_USER QUOTA unlimited ON SYSTEM;
GRANT CREATE SESSION, CONNECT, RESOURCE, DBA TO TEST_USER;
GRANT ALL PRIVILEGES TO TEST_USER;
```
Всё это нужно добавить в файл init~db~.sql, а файл пробросить в контейнер с помощью -v
```
docker run --rm --name dockertest_habr \
-p 1234:1521 \
-p 5678:5500 \
-e ORACLE_PWD=123 \
-v ${PWD}/init_db.sql:/u01/app/oracle/scripts/startup/init_db.sql \
--shm-size="1g" \
my/oracle-for-habr:11.2.0.2-xe
```
\${PWD} Тут используется потому, что нужен абсолютный путь к файлу, при использовании Windows нужно указать его как-то по другому. Если после старта схема TEST~USER~ успешно создана, то можно переходить к прикручиванию свежесозданного контейнера к тестам.
Использование образа в коде на Javа
===================================
При тестировании с использованием встроенной базы данных, как правило возникает одна и та же проблема. Если конфигурацию нельзя взять из кеша, то Спринг собирает её заново. В том числе он пересоздаёт встроенную БД, что тесты конечно серьёзно замедляет. Я решил проблему брутфорсом, просто сделав часть, поднимающую контейнер, синглтоном. Настоящим таким, кондовым.
Для Oracle XE в Testcontainers есть специально заготовленный класс. Этот класс во-первых знает, что речь идёт о контейнере с СУБД и что что того, чтобы определить, что он поднят, надо пытаться подсоединиться к базе данных с помощью jdbc.
Объект этого класса дождётся поднятия контейнера сам, нужно только сообщить ему какой логи с паролем использовать.
```
import org.testcontainers.containers.BindMode;
import org.testcontainers.containers.OracleContainer;
public class StaticOracleContainer {
public static OracleContainer getContainer() {
return LazyOracleContainer.ORACLE_CONTAINER;
}
private static class LazyOracleContainer {
private static final OracleContainer ORACLE_CONTAINER = makeContainer();
private static OracleContainer makeContainer() {
// Также можно вписать название образа в testcontainers.properties
// Проперти oracle.container.image
final var dockerImageName = "my/oracle-for-habr";
final var container = new OracleContainer(dockerImageName)
// Имя пользователя и пароль, которые testcontainers
// будут использовать, чтобы проверить, что
// контейнер поднят
.withUsername("SYSTEM").withPassword("123")
// Порты, которые testcontainers надо
// замапить на внешние порты
.withExposedPorts(1521, 5500)
// Если в контейнере меньше гигабайта shared memory
// Оракл не включится
.withSharedMemorySize(2147483648L)
// То же самое, что задать при запуске контейнера опцию
// -v /path/to/init_db.sql:/u01/app/oracle/scripts/startup/init_db.sql
// Оракл выполнит файл init_db.sql при запуске
.withClasspathResourceMapping("init_db.sql"
, "/u01/app/oracle/scripts/startup/init_db.sql"
, BindMode.READ_ONLY);
container.start();
return container;
}
}
}
```
Также testcontainers при запуске мапит внутренние порты контейнера на случайно определённые не занятые внешние порты. Поэтому можно не опасаться, что контейнер не поднимется, потому что порт уже кем-то используется. Внешний порт можно получить из контейнера с помощью метода getOraclePort().
Также можно получить адрес контейнера с помощью метода getContainerIpAddress(), но этот метод есть у любого контейнера.
После первого вызова метода getContainer, контейнер заново создаваться не будет, а будет возвращаться существующий. Этот метод теперь можно использовать в голой джаве или в конфигурации Спринга для того, чтобы получить объект с контейнером, из которого можно вытащить порты и адрес для подключения.
Например, можно сделать инициализатор, который при поднятии контекста переопределит спринговые проперти, отвечающие за коннект к базе данных.
Класс для прикрепления Testcontainers к Spring
----------------------------------------------
После поднятия контейнера инициализатор переопределяет проперти, отвечающие за урл для подключения к базе данных, логин, пароль и всё такое.
Но, если в application.properties нет настройки evilcorp.testcontainers.enabled то контейнер подниматься не будет и всё будет работать так, как будто testcontainers никто не подключал.
```
package com.evilcorp.demo;
import org.junit.platform.commons.logging.Logger;
import org.junit.platform.commons.logging.LoggerFactory;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.testcontainers.containers.OracleContainer;
public class TestcontainersInitializer implements ApplicationContextInitializer {
static Logger log = LoggerFactory.getLogger(TestcontainersInitializer.class);
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
// Настройка, которая отключает Testcontainers
final String testcontainersEnabled = applicationContext.getEnvironment().getProperty("evilcorp.testcontainers.enabled");
if (!"true".equals(testcontainersEnabled)) {
return;
}
OracleContainer oracleContainer = StaticOracleContainer.getContainer();
oracleContainer.followOutput(s -> log.debug(() -> s.getUtf8String()));
// IP адрес контейнера может меняться в зависимости
// от того, где он запускается
// (linux, MacOs, Windows или Докер) ,
// поэтому надо использовать oracleContainer.getContainerIpAddress()
// чтобы узнать адрес
//
// Testcontainers замапит стандартные порты оракл
// на случайные порты, поэтому надо использовать oracleContainer.getOraclePort()
// для того, чтобы понять по какому порту подсоединяться к базе
final String jdbcUrl = "jdbc:oracle:thin:@//"
+ oracleContainer.getContainerIpAddress()
+ ":" + oracleContainer.getOraclePort() + "/XE";
// Имя пользователя и пароль из init\_db.sql
// Именно их должно использовать приложение
final String user = "TEST\_USER";
final String password = "passwordnoquotes";
TestPropertyValues.of(
"spring.jpa.properties.hibernate.default\_schema=" + user,
"spring.datasource.driver-class-name=oracle.jdbc.OracleDriver",
"spring.jpa.database-platform=org.hibernate.dialect.Oracle10gDialect",
"spring.datasource.username=" + user,
"spring.datasource.password=" + password,
"spring.datasource.url=" + jdbcUrl,
"spring.liquibase.url=" + jdbcUrl,
"spring.liquibase.user=" + user,
"spring.liquibase.password=" + password
).applyTo(applicationContext.getEnvironment(), TestPropertyValues.Type.MAP, "test");
}
}
```
Эту конфигурацию можно использовать в спринг бутовом тесте, чтобы подменить настройки БД на лету.
Тест с использованием Testcontainers
------------------------------------
Тест просто пишет в базу объект, а потом вычитывает его, ничего особенного.
```
package com.evilcorp.demo;
import com.evilcorp.demo.entity.User;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@SpringBootTest
@ContextConfiguration(initializers = {TestcontainersInitializer.class})
class TestcontainersSpringDemoApplicationTests {
@Autowired
UserRepository userRepository;
private User createdUser;
@BeforeEach
void setUp() {
createdUser = new User();
createdUser.setName("Fry");
userRepository.save(createdUser);
}
@Test
void userRepositoryLoaded() {
assertNotNull(userRepository);
}
@Test
void userAdded() {
final Optional loadedUser = userRepository.findById(createdUser.getUserId());
assertTrue(loadedUser.isPresent());
assertEquals("Fry", loadedUser.get().getName());
assertNotSame(createdUser, loadedUser.get());
}
}
```
И да, нужно добавить в pom.xml зависимости
```
org.testcontainers
testcontainers
1.12.3
test
org.testcontainers
oracle-xe
1.12.3
test
```
Вот примерно так можно сделать докер-образ СУБД Оракл и воспользоваться им в коде на Джаве. Осталось только выложить образ в корпоративный репозиторий артефактов и наладить запуск тестов внутри другого докер-контейнера. Но это уже совсем другая история. | https://habr.com/ru/post/480106/ | null | ru | null |
# Тестирование производительности Python 2.7 при обработке списков различными способами
В ходе одного из моих питоновских проектов, с большой примесью ООП и обработкой большого числа данных — у меня возник вопрос, а насколько эффективно обрабатывать списки в классе с использованием вызовов его методов, или может использовать вызов внешней функции? Для этого были написаны 24 теста которые показали очень интересные результаты, Кому интересна данная тема, прошу в подробности.
**Тестовый образец:**
создается список из 500 тыс. элементов и заполняется случайными значениями
```
lst = []
for i in range(1, 500000):
val = random() + i
lst.append(val)
```
**Обработка в 2 этапа:**
1) сначала получение нового списка путем возведение в квадрат каждого элемента списка (несколькими способами)
2) потом добавление к полученному списку некоторой константы, которая может быть: локальной, глобально, аттрибутом (для класса)
Например так
```
@howlong
def process_list_global_func_plus_local_value():
"""Функция. Обработка в цикле с вызовом глобальной функции и добавлением локальной переменной"""
local_plus_value = GLOBAL_VALUE
new_lst = []
for i in lst:
new_lst.append(global_func(i))
for v in new_lst:
v + local_plus_value
```
**Производительность**
Под производительностью понималось длительность выполнения каждого теста, помереная с помощью декоратора
```
import time
def howlong(f):
def tmp(*args, **kwargs):
t = time.time()
res = f(*args, **kwargs)
need_time = time.time()-t
tmp.__name__ = f.__name__
tmp.__doc__ = f.__doc__
#print u"%s time: %f" % ((f.__doc__), need_time)
print ".",
return need_time
return tmp
```
**Были получены следующие результаты по двум группам тестов:**
Функция. Обработка Генератором без вызова внешних функций и добавлением локальной переменной — 0.192 — 100%
Функция. Обработка Генератором без вызова внешних функций и добавлением глобальной переменной — 0.2 — 104%
Функция. Обработка в цикле без вызова внешних функций и добавлением локальной переменной — 0.238 — 123%
Функция. Обработка в цикле без вызова внешних функций и добавлением глобальной переменной — 0.245 — 127%
Функция. Обработка с использованием map и добавлением локальной переменной — 0.25 — 130%
Функция. Обработка с использованием map и добавлением глобальной переменной — 0.255 — 132%
Функция. Обработка Генератором с вызовом локальной функции и добавлением локальной переменной — 0.258 — 134%
Функция. Обработка Генератором с вызовом глобальной функции и добавлением глобальной перем. — 0.274 — 142%
Функция. Обработка в цикле с вызовом локальной функции и добавлением локальной переменной — 0.312 — 162%
Функция. Обработка в цикле с вызовом локальной функции и добавлением глобальной переменной — 0.32 — 166%
Функция. Обработка в цикле с вызовом глобальной функции и добавлением глобальной переменной — 0.327 — 170%
Функция. Обработка в цикле с вызовом глобальной функции и добавлением локальной переменной — 0.332 — 172%
Класс. Обработка Генератором без вызова внешних функций и добавлением локальной переменной — 0.191 — 100%
Класс. Обработка Генератором без вызова внешних функций и добавлением значения глобальной пер. — 0.20 — 104%
Класс. Обработка Генератором без вызова внешних функций и добавлением значения аттрибута — 0.213 — 111%
Класс. Обработка вызовом локальной функции и добавлением локальной переменной — 0.312 — 163%
Класс. Обработка вызовом глобальной функции и добавлением локальной переменной — 0.318 — 166%
Класс. Обработка вызовом локальной функции и добавлением глобальной переменной — 0.318 — 166%
Класс. Обработка вызовом глобальной функции и добавлением глобальной переменной — 0.328 — 171%
Класс. Обработка вызовом локальной функции и добавлением значения аттрибута — 0.333 — 174%
Класс. Обработка вызовом глобальной функции и добавлением значения аттрибута — 0.34 — 178%
Класс. Обработка вызовом метода класса и добавлением локальной переменной — 0.39 — 204%
Класс. Обработка вызовом метода класса и добавлением глобальной переменной — 0.398 — 208%
Класс. Обработка вызовом метода класса и добавление значения аттрибута — 0.411 — 215%
**Выводы:**
Наибольший интерес представляю процентные разницы.
***По обработке списка функцией***
1) Самая быстрая обработка списка — в генераторе без вызова внешних функций и с использованием локальных переменных, с использованием глобальных переменных будет на ~5% дольше
2) при обработке списка перебором в цикле for время работы будет на 23% с использование локальных переменных и на 27% дольше с использованием глобальных переменных, чем при обработке через генератор
3) при использовании в цикле for для обработки списка внешней локальной или глобальной функции скорость будет ниже более чем на 60%
4) при использовании map в качестве функции обработки элементов списка практически такой же как ри использовании вызова внешней функции в генераторе
5) самым долгим способом обработки списка является обработка в цикле с использование вызова внешней глобальной функции
***По обработке списка в классе***
1) в классах доступ к аттрибутам дольше чем к локальным переменным, примерно на 10%, и на 5% дольше чем к глобальным переменным
2) в классах доступ к методам дольше, чем к локальным функциям примерно на 22% и на 20% дольше чем к глобальным функциям
3) при обработке списка в классе с использованием генератора получается также быстро, как и с использованием функции с генератором
4) самым долгим способом (более чем в 2 раза дольше) оказалось использование вызова метода в цикле и добавлением значения аттрибута, что явилось для меня большим удивлением
**Код доступен в одном файле по адресу** <http://pastebin.com/rgdXNdXb>
Дальше планирую исследовать скорость доступа к элементам списков, туплов, различных видом словарей, а потом вопросы целесообразности кеширования функций и методов классов | https://habr.com/ru/post/181768/ | null | ru | null |
# Собираем кластер PostgreSQL для разработки и тестирования
Сегодня СУБД PostgreSQL является одной из самых известных и популярных систем управления баз данными в мире. Открытый исходный код, отсутствие платы за использование, контроль целостности, репликация – это далеко не все преимущества данной СУБД. В современных реалиях, когда тема импортозамещения особенно актуальна, PostgreSQL может оказаться подходящим вариантом.
Обычно PostgreSQL разворачивают в качестве кластера – системы, которая состоит из нескольких связанных между собой компьютеров (серверов) с целью обеспечения отказоустойчивости.
Как правило, при развертывании кластеров PostgreSQL используют сторонние инструменты такие как Patroni, stolon, repmgr.
В статье будет описана установка кластера PostgreSQL с помощью **Ansible** – инструмента, предназначенного для автоматизации настройки и развертывания программного обеспечения, а также инструмента **repmgr**, предназначенного для управления репликами и отказоустойчивостью в кластерах PostgreSQL.
В компаниях не всегда имеется возможность быстро выделить ресурсы для разворачивания ВМ, чтобы организовать рабочую среду для разработки или тестирования. Чтобы избежать излишней бюрократии, если такая имеет место быть, можно локально поднять систему и сразу приступить к работе с ней. Поэтому в статье в качестве примера приведен также алгоритм по установке и работе с утилитой **Vagrant**, которая позволяет быстро решить эту задачу.
Подготовка к установке
----------------------
В качестве примера будет использоваться виртуальная машина с установленной операционной системой **Ubuntu 20.04.3 LTS**. Узлы кластера будут представлены в виде 3 виртуальных машин под управлением ОС **Ubuntu 18.04 Bionic Beaver**, которые будут запущены на гипервизоре **VirtualBox**. Сами ВМ будут развернуты при помощи **Vagrant** –утилиты,предназначенной для создания и конфигурирования виртуальных окружений (под виртуальным окружением понимается более стандартное понятие – виртуальная машина). Ниже описаны хосты, которые будут использоваться в качестве кластера PostgreSQL:
**node1 192.168.56.11** Роль **primary**, она же мастер-нода;
**node2 192.168.56.12** Роль **standby**. Обычная рабочая нода;
**node3 192.168.56.13** Роль **witness**. В терминологии repmgr **witness** это нода, которая не является частью кластера и предназначена для выбора новой мастер-ноды в случае возникновения проблем с кластером.
Ниже перечислено ПО, которое будет использоваться в статье:
**Ansible**;
**Vagrant**;
**VirtualBox**;
**PostgreSQL**;
**repmgr**.
Сначала на управляющий хост (основной хост, с которого будет вестись управление Vagrant и Ansible) необходимо установить **Ansible**, **Vagrant** и **VirtualBox**.
Произвести установку Ansible можно разными способами. В данном примере установка будет произведена при помощи официального репозитория ansible. Для этого необходимо выполнить следующие шаги:
1) Обновить списки пакетов:
```
sudo apt update
```
2) Установить пакет software-properties-common:
```
sudo apt -y install software-properties-common
```
3) Добавить официальный репозиторий Ansible:
```
sudo add-apt-repository --yes --update ppa:ansible/ansible
```
4) Установить Ansible:
```
sudo apt -y install ansible
```
После того как установка будет завершена, можно проверить, что Ansible установился корректно, путем вывода его версии. Для этого достаточно выполнить команду:
```
ansible --version
```
Если команда отобразила версию (первая строка с названием **ansible [core <версия>**]), значит, пакет успешно и без ошибок установлен в системе.
Далее необходимо установить Vagrant. Установка производится из официального репозитория. Шаги по установке Vagrant:
1) Добавить gpg ключ от официального репозитория Vagrant:
```
wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
```
2) Добавить официальный репозиторий hashicorp:
```
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
```
3) Обновить список репозиториев и установить пакет vagrant:
```
sudo apt update && sudo apt -y install vagrant
```
После установки необходимо убедиться, что установка прошла успешно. Для этого в терминале необходимо ввести команду:
```
vagrant
```
Если команда вернула список команд и их описание, значит установка vagrant прошла успешно.
Последний шаг – установка VirtualBox. Необходимые пакеты уже присутствуют в официальных репозиториях. Для установки достаточно выполнить одну команду:
```
sudo apt -y install virtualbox virtualbox-dkms
```
Создание и подготовка Vagrantfile
---------------------------------
Для создания виртуальных машин в vagrant используется специальный файл – **vagranfile**. Для его создания необходимо выполнить команду:
```
vagrant init
```
Команда сгенерирует специальный шаблон, где указываются ВМ, которые будут созданы. Также в этом файле прописываются имена хостов, IP адреса хостов и способ подключения к ним.
Содержимое файла будет следующим
```
Vagrant.configure("2") do |config|
(1..3).each do |n|
config.vm.define "node#{n}" do |define|
define.ssh.insert_key = false
define.vm.box = "ubuntu/bionic64"
define.vm.hostname = "node#{n}"
define.vm.network :private_network, ip: "192.168.56.1#{n}"
# if you would like to use port forwarding, uncomment the line below
# define.vm.network :forwarded_port, guest: 5432, host: "543#{n}"
define.vm.provider :virtualbox do |v|
v.cpus = 1
v.memory = 1024
v.name = "node#{n}"
end
if n == 3
define.vm.provision :ansible do |ansible|
ansible.limit = "all"
ansible.playbook = "playbook.yaml"
ansible.host_vars = {
"node1" => {:connection_host => "192.168.56.11",
:node_id => 1,
:role => "primary" },
"node2" => {:connection_host => "192.168.56.12",
:node_id => 2,
:role => "standby" },
"node3" => {:connection_host => "192.168.56.13",
:node_id => 3,
:role => "witness" }
}
# to enable ansible playbook verbose mode, uncomment the line below
# ansible.verbose = "v"
end
end
end
end
end
```
Где:
**define.ssh.insert\_key** – если выставлен в **false,** то vagrant не будет автоматически создавать и использовать собственные SSH ключи;
***define.vm.box*** – задает имя образа для ВМ. Образы хранятся на сайте Vagrant Cloud;
**define.vm.hostname** – задает hostname виртуальным машинам;
**define.vm.network** – задает тип сети и диапазон IP адресов;
**v.cpus** – задает количество ядер, которое будет выделено для ВМ;
**v.memory** – задает количество оперативной памяти, которое будет выделено для ВМ;
**ansible.playbook** – прописывается полный путь до playbook Ansible. Vagrant имеет полную поддержку и интеграцию с Ansible;
**ansible.host\_vars** – в данном блоке прописываются хосты, на которых будет запущен playbook Ansible. Эквивалентен файлу инвентаризации в Ansible.
### Создание ролей в Ansible
Так как для установки и настройки кластера необходимо выполнить много действий, они будут разбиты на роли.
Роли в Ansible – это способ логического разбиения файлов или, проще говоря, независимая сущность, решающая какой-то набор задач. С технической точки зрения роль – это директория с поддиректориями и файлами, где расположены задачи.
Для удобства создадим директорию с именем **postgres-cluster:**
```
mkdir postgres-cluster
```
Далее необходимо перейти в созданный каталог и создать следующие директории:
```
mkdir group_vars
mkdir roles
```
В директории **roles** будут храниться все необходимые роли. В ней необходимо создать:
```
mkdir roles/postgres_12/tasks
mkdir roles/postgres_12/templates
mkdir roles/registration/tasks
mkdir roles/registration/templates
mkdir roles/repmgr/tasks
mkdir roles/repmgr/templates
mkdir roles/ssh/files/keys
mkdir roles/ssh/tasks
```
Начнем заполнять директории файлами с описанием необходимых действий (в терминологии Ansible каждая задача называется task). Но сначала необходимо заполнить файл с переменными. Они будут храниться в директории **group\_vars** в файле с именем **all.yaml**.
Содержимое файла представлено ниже:
```
group_vars/all.yaml
node1_ip: "192.168.56.11"
node2_ip: "192.168.56.12"
node3_ip: "192.168.56.13"
pg_version: "12"
```
В переменных с именем node прописаны IP-адреса, которые будут присвоены виртуальным машинам. Переменная ***pg\_version*** содержит версию PostgreSQL, которая будет установлена на хосты. В данном примере будет использоваться 12 версия.
Далее описываются роли. Для каждой роли в своей директории будет создана еще одна директория с именем **roles**, в которой будет находиться файл с именем **main.yaml.**
Первая роль предназначена для установки PostgreSQL
```
roles/postgres_12/tasks/main.yaml
- name: Add PostgreSQL apt key
apt_key:
url: https://www.postgresql.org/media/keys/ACCC4CF8.asc
- name: Add PostgreSQL repository
apt_repository:
# ansible_distribution_release = xenial, bionic, focal
repo: deb http://apt.postgresql.org/pub/repos/apt/ {{ ansible_distribution_release }}-pgdg main
- name: Install PostgreSQL 12
apt:
name: postgresql-12
update_cache: yes
- name: Copy database configuration
template:
src: full_postgresql.conf.j2
dest: /etc/postgresql/12/main/postgresql.conf
group: postgres
mode: '0644'
owner: postgres
- name: Copy user access configuration
template:
src: pg_hba.conf.j2
dest: /etc/postgresql/12/main/pg_hba.conf
group: postgres
mode: '0640'
owner: postgres
```
Порядок действий, описанный в роли, следующий:
1) Добавление ключа от официального репозитория postgres;
2) Добавление официального репозитория postgres;
3) Установка PostgreSQL 12;
4) Копирование и использование конфигурационного файла **full\_postgresql.conf.j2**,который заменит стандартный конфигурационный файл postgresql.conf;
5) Копирование и использование конфигурационного файла **pg\_hba.conf.j2***,*который заменит стандартный конфигурационный файл pg\_hba.conf.
Конфигурационные файлы **full\_postgresql.conf.j2**и **pg\_hba.conf.j2**будут находиться по следующему пути: **roles/postgres\_12/templates**.
Содержимое файлов описано ниже
```
roles/postgres_12/templates/full_postgresql.conf.j2
data_directory = '/var/lib/postgresql/12/main'
hba_file = '/etc/postgresql/12/main/pg_hba.conf'
ident_file = '/etc/postgresql/12/main/pg_ident.conf'
external_pid_file = '/var/run/postgresql/12-main.pid'
port = 5432
max_connections = 100
unix_socket_directories = '/var/run/postgresql'
shared_buffers = 128MB
dynamic_shared_memory_type = posix
# repmgr
listen_addresses = '*'
shared_preload_libraries = 'repmgr'
wal_level = replica
max_wal_senders = 5
wal_keep_segments = 64
max_replication_slots = 5
hot_standby = on
wal_log_hints = on
```
Строки под комментарием **# repmgr** относятся к настройкам утилиты repmgr и предназначены для настройки репликации.
В конфигурационном файле **pg\_hba.conf.j2** прописаны сетевые доступы до всех нод кластера.
Следующая задача – создание SSH ключей для подключения к виртуальным машинам. Сначала на хостовой ОС необходимо сгенерировать SSH ключи. Команда ниже эквивалента команде ssh-keygen с той лишь разницей, что команда ниже сгенерирует ключи без интерактивного режима:
```
ssh-keygen -q -t rsa -f ~/.ssh/id_rsa <</dev/null 2>&1
```
Закрытый (**id\_rsa**) и открытый (**id\_rsa.pub**) ключи будут сохранены по умолчанию — в домашней директории пользователя в скрытой директории **.ssh**
Далее необходимо скопировать файл с открытым и закрытым ключом в директорию **/roles/ssh/files/keys** Итого в поддиректории keys будет два файла — **id\_rsa** и **id\_rsa.pub**.
Роль по использованию SSH ключей описана ниже
```
roles/ssh/tasks/main.yaml
- name: Install OpenSSH
apt:
name: openssh-server
update_cache: yes
state: present
- name: Create postgres SSH directory
file:
mode: '0755'
owner: postgres
group: postgres
path: /var/lib/postgresql/.ssh/
state: directory
- name: Copy SSH private key
copy:
src: "keys/id_rsa"
dest: /var/lib/postgresql/.ssh/id_rsa
owner: postgres
group: postgres
mode: '0600'
- name: Copy SSH public key
copy:
src: "keys/id_rsa.pub"
dest: /var/lib/postgresql/.ssh/id_rsa.pub
owner: postgres
group: postgres
mode: '0644'
- name: Add key to authorized keys file
authorized_key:
user: postgres
state: present
key: "{{ lookup('file', 'keys/id_rsa.pub') }}"
- name: Restart SSH service
service:
name: sshd
enabled: yes
state: restarted
```
Порядок действий, описанный в роли, следующий:
1) Установка пакета OpenSSH.
2) Создание директории, где будут храниться SSH ключи - /var/lib/postgresql/.ssh/;
3) Копирование закрытого ключа в директорию /var/lib/postgresql/.ssh/;
4) Копирование открытого ключа в директорию /var/lib/postgresql/.ssh/;
5) Добавление открытого ключа в файл authorized\_key;
6) Перезапуск демона sshd.
Следующая задача – установка и настройка repmgr.
Посмотреть
```
roles/repmgr/tasks/main.yaml
- name: Download repmgr repository installer
get_url:
dest: /tmp/repmgr-installer.sh
mode: 0700
url: https://dl.2ndquadrant.com/default/release/get/deb
- name: Execute repmgr repository installer
shell: /tmp/repmgr-installer.sh
- name: Install repmgr for PostgreSQL {{ pg_version }}
apt:
name: postgresql-{{ pg_version }}-repmgr
update_cache: yes
- name: Setup repmgr user and database
become_user: postgres
ignore_errors: yes
shell: |
createuser --replication --createdb --createrole --superuser repmgr &&
psql -c 'ALTER USER repmgr SET search_path TO repmgr_test, "$user", public;' &&
createdb repmgr --owner=repmgr
- name: Copy repmgr configuration
template:
src: repmgr.conf.j2
dest: /etc/repmgr.conf
- name: Restart PostgreSQL
systemd:
name: postgresql
enabled: yes
state: restarted
```
Порядок действий, описанный в роли, следующий:
1) Скачивание установщика, содержащего официальный репозиторий repmgr;
2) Запуск скачанного установщика;
3) Установка пакета repmgr для 12 версии PostgreSQL;
4) Инициализация и создание репликационного кластера;
5) Копирование и использование конфигурационного файла **repmgr.conf.j2**, который заменит стандартный конфигурационный файл **repmgr.conf**;
6) Перезапуск демона PostgreSQL.
Конфигурационный файл **repmgr.conf.j2** будет находиться по следующему пути **roles/repmgr/templates**
Содержимое файла описано ниже
```
roles/repmgr/templates/repmgr.conf.j2
node_id = {{ node_id }}
node_name = 'node{{ node_id }}'
conninfo = 'host={{ connection_host }} user=repmgr dbname=repmgr'
data_directory = '/var/lib/postgresql/{{ pg_version }}/main'
use_replication_slots = yes
reconnect_attempts = 5
reconnect_interval = 1
failover = automatic
pg_bindir = '/usr/lib/postgresql/{{ pg_version }}/bin'
promote_command = 'repmgr standby promote -f /etc/repmgr.conf'
follow_command = 'repmgr standby follow -f /etc/repmgr.conf'
log_level = INFO
log_file = '/var/log/postgresql/repmgr.log'
#monitoring_history=yes
#monitor_interval_secs=5
#log_status_interval=5
#promote_check_timeout=5
#promote_check_interval=1
#master_response_timeout=5
```
Последняя роль – это присвоение ролей нодам кластера.
Посмотреть
```
roles/repmgr/registration/main.yaml
- name: Register primary node
become_user: postgres
shell: repmgr primary register
ignore_errors: yes
when: role == "primary"
- name: Stop PostgreSQL
systemd:
name: postgresql
state: stopped
when: role == "standby"
- name: Clean up PostgreSQL data directory
become_user: postgres
file:
path: /var/lib/postgresql/{{ pg_version }}/main
force: yes
state: absent
when: role == "standby"
- name: Clone primary node data
become_user: postgres
shell: repmgr -h {{ node1_ip }} -U repmgr -d repmgr standby clone
ignore_errors: yes
when: role == "standby"
- name: Start PostgreSQL
systemd:
name: postgresql
state: started
when: role == "standby"
- name: Register {{ role }} node
become_user: postgres
shell: repmgr -h {{ node1_ip }} {{ role }} register -F
ignore_errors: yes
when: role != "primary"
- name: Start repmgrd
become_user: postgres
shell: repmgrd
ignore_errors: yes
```
Порядок действий, описанный в роли, следующий:
1) Регистрация primary ноды (она же мастер-нода).
2) Остановка демона PostgreSQL.
3) Удаление всех данных из директории /var/lib/postgresql/12/main.
4) Регистрация stan-by ноды.
5) Запуск демона PostgreSQL.
6) Запуск демона repmrg.
Создание и запуск playbook
--------------------------
Чтобы собрать все задачи воедино, необходимо создать один общий playbook, в который будут включены все задачи и файлы, что были созданы ранее. Для этого в корневой директории (в данном примере это директория с именем **postgres-cluster**) необходимо создать файл с именем **playbook.yaml** со следующим содержанием:
```
postgres-cluster/playbook.yaml
---
- hosts: all
gather_facts: yes
become: yes
roles:
- postgres_12
- ssh
- repmgr
- registration
```
В параметре **roles** перечислены все роли, которые будут запущены на хостах. Обратите внимание на порядок ролей.
В итоге получится следующая структура файлов:
Также в корневой директории присутствует ранее созданный **Vagrantfile**.
Когда все файлы будут созданы, можно запускать установку виртуальных машин и playbook Ansible. Для этого достаточно выполнить одну команду:
```
vagrant up
```
Начнется процесс установки (см. скриншот ниже). Сначала будут созданы 3 виртуальные машины, далее будет запущен playbook, который установит СУБД PostgreSQL, утилиту repmgr и настроит репликацию.
Ниже показан процесс запуска ролей Ansible:
После того как установка будет завершена, можно подключиться к любой из 3 созданных ВМ для проверки статуса репликации. Для этого необходимо ввести команду **vagrant ssh node1**, где node1 — это имя хоста одной из ВМ:
При подключении по SSH пароль вводить не нужно, так как был настроен вход по SSH ключам.
Для проверки статуса кластера и репликации необходимо выполнить команду:
```
repmgr service status
```
Как видно из вывода команды, у нас создался кластер PostgreSQL с 3 нодами. У каждой ноды своя роль (столбец Role).
Итог
----
Созданный кластер можно использовать в качестве тестовой инсталляции, а также для знакомства с утилитой репликации repmgr. Роли нод кластера при желании можно поменять. Также можно легко производить горизонтальное масштабирование – добавлять новые ноды кластера.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/699644/ | null | ru | null |
# Организация рабочих потоков: управление состоянием движка
Данная статья является продолжением статьи — [Организация рабочих потоков: синхронизационный канал](http://habrahabr.ru/post/141509/). Продолжение родилось как попытка написать пример использования подхода с синхронными сообщениями.
В этой части я хочу на примере показать, как можно организовать управление и отображение состояния движка с рабочим потоком, используя синхронные сообщения между потоками. И показать, как при этом обойти проблему взаимной блокировки потоков при закрытии приложения.
Давайте вернемся к примеру с предыдущей статьи. У нас есть графический интерфейс, отображающий состояние движка с рабочим потоком. Допустим движок можно запустить, остановить, поставить на паузу и соответственно снять с паузы. Для реализации такого поведения проще всего применить что-то подобное шаблонам проектирования конечный автомат и наблюдатель.
Для начала определимся с набором состояний движка. Движок у нас будет асинхронным, по этому в наборе состояний будут также и переходные состояния. У меня получился следующий набор состояний: NotStarted, StartPending, Started, PausePending, Paused, ResumePending, StopPending.
Эти состояния прежде всего будут использоваться для изменения состояния GUI. Тоесть GUI будет получать уведомление о изменении состояния движка, и соответствующим образом отображать это состояние. Например, при переходе в состояние NotStarted, GUI должно показать кнопку «Старт», а кнопки «Пауза» «Продолжить» и «Остановить» должны быть заблокированными. Соответственно при переходе в состояние Paused кнопки «Старт» и «Пауза» будут заблокированными, а кнопки «Продолжить» и «Остановить» должны быть разблокированными.
Давайте посмотрим, как может выглядеть обработчик уведомления о изменении состояния движка, на примере WTL диалога с соответствующими управляющими кнопками:
```
void CMainDlg::OnStateChanged(EngineState::State state)
{
// Это функция обратного вызова, она вызывается только из GUI потока по средством класса CSyncChannel,
// по этому нет необходимости в дополнительной синхронизации при доступе к членам класса диалога
// В случае Pending состояний, блокируем все кнопки, дальше мы разблокируем только нужные кнопки
// Так было сделано для уменьшения количества строчек в примере
GetDlgItem(IDC_BUTTON_START).EnableWindow(FALSE);
GetDlgItem(IDC_BUTTON_STOP).EnableWindow(FALSE);
GetDlgItem(IDC_BUTTON_PAUSE).EnableWindow(FALSE);
GetDlgItem(IDC_BUTTON_CONTINUE).EnableWindow(FALSE);
switch (state)
{
case EngineState::NotStarted:
GetDlgItem(IDC_BUTTON_START).EnableWindow(TRUE);
break;
case EngineState::Started:
GetDlgItem(IDC_BUTTON_STOP).EnableWindow(TRUE);
GetDlgItem(IDC_BUTTON_PAUSE).EnableWindow(TRUE);
break;
case EngineState::Paused:
GetDlgItem(IDC_BUTTON_STOP).EnableWindow(TRUE);
GetDlgItem(IDC_BUTTON_CONTINUE).EnableWindow(TRUE);
break;
}
}
```
Для управления своим состоянием, движок будет иметь соответствующий набор функций: Start, Pause, Resume, Stop, которые в классе диалога будут вызываться из соответствующих обработчиков нажатия на кнопки.
За счет использования синхронных сообщений, переход из одного состояния в другое будет выполняться синхронно по отношению к потоку GUI. То есть, пока поток GUI находится в обработчике нажатия на кнопку «Старт», движок не может перейти в состояние Started или Paused асинхронно, он ждет пока обработчик нажатия на кнопку «Старт» завершится. Это существенно упрощает управление состояниями движка.
Переход в ожидающие состояния, такие как StartPending, осуществляется внутри вызова управляющих функций, таких как Start, и по этому, после выхода из функции Start, движок будет иметь состояние StartPending. То есть уведомление о переходе в состояние StartPending будет вызвано синхронно, еще до завершения вызова функции Start.
Посмотрим на реализацию движка.
Привожу класс движка полностью, т.к. при работе с многопоточностью любая упущенная деталь может играть большую роль.
```
//Engine.h
namespace EngineState
{
enum State {
NotStarted,
StartPending,
Started,
PausePending,
Paused,
ResumePending,
StopPending
};
};
class IEngineEvents {
public:
virtual void OnStateChanged(EngineState::State state) = 0;
};
class CEngine {
public:
CEngine(IEngineEvents* listener);
~CEngine(void);
public:
// Управляющие команды для рабочего потока
void Start();
void Stop();
void Pause();
void Resume();
public:
// GUI поток должен вызывать эту функцию для всех своих сообщений
bool ProcessMessage(MSG& msg);
private:
void WaitForThread();
static DWORD WINAPI ThreadProc(LPVOID param);
void Run();
bool CheckStopAndPause();
void ChangeState(EngineState::State state);
void OnStateChanged(EngineState::State state);
private:
CSyncChannel m_syncChannel; // Этот класс был описан в предыдущей статье
IEngineEvents* m_listener;
HANDLE m_hThread;
volatile EngineState::State m_state;
};
```
```
// Engine.cpp
CEngine::CEngine(IEngineEvents* listener) :
m_listener(listener),
m_hThread(NULL),
m_state(EngineState::NotStarted)
{
m_syncChannel.Create(GetCurrentThreadId());
}
CEngine::~CEngine(void)
{
// Если рабочий поток не был остановлен, необходимо установить флаг завершения потока
m_state = EngineState::StopPending;
// Необходимо дождаться, пока завершиться рабочий поток.
// Если рабочий поток в этот момент пошлет сообщение на GUI, то он заблокируется.
// Для того, чтобы разрешить ситуацию с взаимной блокировкой потоков,
// закрываем m_syncChannel, после чего рабочий поток будет разблокирован.
m_syncChannel.Close();
// Теперь рабочий поток успешно завершиться.
WaitForThread();
}
void CEngine::WaitForThread()
{
if (m_hThread)
{
// Ожидание завершения рабочего потока.
// Рабочий поток завершиться при переходе в одно из состояний:
// StopPending или NotStarted
_ASSERT(m_state == EngineState::StopPending || m_state == EngineState::NotStarted);
// Ждем полной остановки рабочего потока
DWORD waitResult = WaitForSingleObject(m_hThread, INFINITE);
_ASSERT(waitResult == WAIT_OBJECT_0);
// Рабочий поток полностью завершился, теперь можно освободить HANDLE рабочего потока
CloseHandle(m_hThread);
m_hThread = NULL;
}
}
void CEngine::Start()
{
// Это управляющая комманда, вызывается из GUI потока
// Запустить рабочий поток можно только в том случае, если он еще не запущен
// Для этого проверяем состояние движка
if (m_state == EngineState::NotStarted)
{
// Если функция Start была вызвана повторно, после завершения рабочего потока,
// предыдущий рабочий поток может некоторое время продолжать работать
// Необходимо дождаться его полного завершения перед тем, как создавать новый поток
WaitForThread();
// Создаем новый рабочий поток,
// передаем параметром this, чтобы поток мог вызвать функцию Run для текущего объекта
m_hThread = CreateThread(NULL, 0, CEngine::ThreadProc, this, 0, NULL);
if (m_hThread)
{
// Переключаем состояние движка в StartPending
// Рабочий поток уже мог вызвать функцию ChangeState(EngineState::Started)
// Но так, как для переключения состояния используется SyncChannel,
// то состояние не может быть изменено асинхронно,
// рабочий поток будет ждать, пока не завершится обработка нажатия на кнопку "Start"
// И по этому состояние StartPending гарантированно придет перед тем,
// как придет состояние Started от рабочего потока
ChangeState(EngineState::StartPending);
}
}
}
void CEngine::Stop()
{
// Это управляющая комманда, вызывается из GUI потока
if (m_state != EngineState::NotStarted && m_state != EngineState::StopPending)
{
// Устанавливаем флаг остановки, если он еще не установлен и поток еще работает
ChangeState(EngineState::StopPending);
}
// Рабочий поток остановится асинхронно, после выхода этой функции
// поток еще будет продолжать работать
// После остановки рабочий поток вызовет функцию ChangeState(EngineState::Stopped)
// Для ожидания полной остановки потока необходимо вызвать функцию WaitForThread
}
void CEngine::Pause()
{
// Это управляющая комманда, вызывается из GUI потока
if (m_state == EngineState::Started)
{
// Переход в состояние PausePending возможен только из состояния Started
ChangeState(EngineState::PausePending);
}
}
void CEngine::Resume()
{
// Это управляющая комманда, вызывается из GUI потока
if (m_state == EngineState::Paused)
{
// Переход в состояние ResumePending возможен только из состояния Paused
ChangeState(EngineState::ResumePending);
}
}
bool CEngine::ProcessMessage(MSG& msg)
{
// GUI поток вызывает эту функцию для всех своих сообщений
return m_syncChannel.ProcessMessage(msg);
}
DWORD WINAPI CEngine::ThreadProc(LPVOID param)
{
// Это статическая функция потока, получаем указатель
// на объект класса и вызываем его функцию Run
reinterpret_cast(param)->Run();
return 0;
}
void CEngine::Run()
{
// Оповещаем GUI о том, что рабочий поток запустился
ChangeState(EngineState::Started);
for (;;)
{
// Это функция рабочего потока, здесь выполняется какая-то работа
// При этом необходимо периодически проверять флаг остановки и паузы
if (!CheckStopAndPause())
{
break;
}
// Выполняется важная работа - хорошо поспать, мечта всех родителей :)
Sleep(1000);
}
// Оповещаем о том, что рабочий поток завершился
ChangeState(EngineState::NotStarted);
// После переключения в состояние NotStarted рабочий поток
// еще какое-то время продолжает свое выполнение по этому необходимо
// дождаться завершения рабочего потока с использованием функции WaitForSingleObject
}
bool CEngine::CheckStopAndPause()
{
// Эта функция вызывается периодически из рабочего потока.
// Частота вызова этой функции влияет на отзывчивость GUI.
if (m\_state == EngineState::StopPending)
{
// Была вызывана функция Stop, необходимо остановить рабочий поток
return false;
}
if (m\_state == EngineState::PausePending)
{
// Ставим рабочий поток на паузу,
// для этого оповещаем GUI поток о изменении состояния
// и входим в цикл ожидания дальнейших команд
ChangeState(EngineState::Paused);
while (m\_state == EngineState::Paused)
{
Sleep(100);
}
if (m\_state == EngineState::StopPending)
{
// Была вызывана функция Stop, необходимо остановить рабочий поток
return false;
}
// Снимаем рабочий поток с паузы
// Для этого оповещаем GUI о изменении состояния и возвращаем управление рабочему потоку
ChangeState(EngineState::Started);
}
// Рабочий поток может продолжать свое выполнение
return true;
}
void CEngine::ChangeState(EngineState::State state)
{
// Эта функция может быть вызвана рабочим потоком,
// транслируем вызов в GUI поток, используя m\_syncChannel
m\_syncChannel.Execute(boost::bind(&CEngine::OnStateChanged, this, state));
}
void CEngine::OnStateChanged(EngineState::State state)
{
// Эта функция вызывается только из GUI потока, устанавливаем переменную m\_state
// Таким образом изменение переменной m\_state будет происходить только из одного потока
// и не требует использования объектов синхронизации, таких как критические секции или мьютексы
// То есть состояние рабочего потока не может переключится асинхронно по отношению к GUI потоку
m\_state = state;
m\_listener->OnStateChanged(m\_state);
}
```
Использование класса CEngine.
В моем примере объект класса CEngine объявлен членом класса WTL диалога.
Набор функций диалога сводится к обработчикам нажатия на клавиши «Старт», «Стоп», «Продолжить», «Пауза» которые перевызывают соответствующие фукнции объекта CEngine.
Также класс диалога подписывается на уведомления о изменении состояния движка при помощи интерфейса IEngineEvents, реализация функции OnStateChanged этого интерфейса была приведена в начале статьи.
Для обеспечения трансляции сообщений потока в класс CEngine, класс диалога устанавливает себя фильтром оконных сообщений, используя стандартные методы WTL::CMessageLoop::AddMessageFilter, и реализует интерфейс WTL::CMessageFilter:
```
class CMessageFilter
{
public:
virtual BOOL PreTranslateMessage(MSG* pMsg) = 0;
};
```
Реализация функции PreTranslateMessage сводится к перевызову функции CEngine::ProcessMessage
Для решения проблемы взаимной блокировки потоков при закрытии приложения, в классе диалога никаких дополнительный действий не требуется. Эта проблема полностью решена за счет использования CSyncChannel::Close в деструкторе класса CEngine. Таким образом рабочий поток полностью инкапсулирован внутри класса CEngine, что дает ощутимые преимущества при работе с таким классом. | https://habr.com/ru/post/141783/ | null | ru | null |
# Управление роботами, созданными с помощью LEGO® Mindstorms® NXT Brick через язык Wolfram Language (Mathematica)
*Скачать статью в виде [документа Mathematica (NB)](http://www.mathematica-journal.com/data/uploads/2013/03/Cousineau.nb), [CDF-файла](http://www.mathematica-journal.com/data/uploads/2013/03/Cousineau.cdf) или [PDF](http://www.mathematica-journal.com/data/uploads/2013/03/Cousineau.pdf).*
NXT — процессор общего назначения, который используется для управления двигателями и датчиками; он идеально подходит для создания автономных роботов. Он также может сообщаться с более сложным программным обеспечением на компьютере посредством Bluetooth. В этой статье мы покажем, как правильно взаимодействовать с NXT через язык [Wolfram Language](http://www.wolfram.com/language) (*[Mathematica](http://www.wolfram.com/mathematica)*), посылая корректные сигналы. Мы также представим пакет, который управляет всеми взаимодействиями между функциями. Эти функции могут использоваться в сочетании с динамическими ячейками для отображения статуса робота и управления его двигателем.
### Введение
Роботы являются идеальными объектами для проверки когнитивных теорий, таких как обучение, адаптация, а так же для классификации воздействий среды. Ключевым элементом большинства роботов является центральный процессор, который получает данные среды посредством сенсоров и воздействует на среду с помощью моторов. С этой целью в 2006-м году LEGO представила новый программируемый конструктор — LEGO MINDSTORMS NXT. Этот конструктор, оборудованный четырьмя сенсорами и тремя моторами, имеет 256 Кбайт флэш памяти для хранения данных. Он может запускать программы, скомпилированные специально для этого конструктора (файлы с расширением .rxe, скомпилированные посредством LEGO LabVIEW или сторонними компиляторами, такими как NBC или NXC). Универсальность и низкая стоимость этого конструктора делают его идеальным объектом для проектов по разработке роботов.
NXT хорошо подходит для разработки автономных роботов, в том числе и разведывательных. Так же можно исследовать алгоритмы обучения; к примеру, можно найти более оптимальные способы решения задачи поиска выхода из лабиринта, нежели обычным методом проб и ошибок. Наконец, NXT также может быть использован для изучения социальных когнитивных моделей, в которых многочисленные роботы должны взаимодействовать, чтобы повысить выживаемость группы.
В этой статье показывается, как управлять конструктором посредством Bluetooth. Мы также представим пакет **Math4NXT**, который облегчает ряд задач. Используясь в сочетании со встроенной функцией **[Dynamic](http://reference.wolfram.com/language/ref/Dynamic.html)** в *Mathematica*, управление роботом LEGO становится очень простым.
### Создание линии связи
В первый раз, когда Вы запустите NXT, используйте Bluetooth на Вашем компьютере, чтобы найти его и создать связь. Что касается самого первого использования, Вам нужно будет ввести пароль на конструкторе (по умолчанию – “1234″) и компьютере. Затем Вам нужно будет выбрать сервис «Dev», доступный на конструкторе. Тем самым COM порт выделяется в качестве линии связи между компьютером и конструктором. Имя COM порта задается как переменная (к примеру, COM11), однако остается постоянным для конкретной пары компьютер-NXT (более подробные инструкции по созданию пары можно найти в [1]). После того, как Вы задали определённый COM порт, Вам больше не нужно будет повторять этот процесс.
Конструктор NXT имеет операционную систему (прошивку), которая сразу же обрабатывает запросы, получаемые от COM порта. Он это делает, даже если в данный момент на конструкторе запущена программа. Данные команды в документации LEGO [2] называются *прямыми*. Прямые команды включают в себя операции над файлами, управление мотором, настройку сенсоров и считывание с них данных, взаимодействие между разными конструкторами. Команды передаются через COM порт посредством сообщений, представляющих из себя последовательность байтов (числа от 0 до 255). Некоторые команды подразумевают ответ конструктора, который высылается так же в виде сообщения. Перед каждым сообщением отправляется информация о длине этого сообщения, на которую выделяется 2 байта. Таким образом, управление конструктором NXT представляет собой отправку определённых байтов в определённом порядке через последовательный порт.
Для того, чтобы использовать последовательный COM порт, следует использовать пакет для *Mathematica* под названием SerialIO [3]. Этот пакет состоит из двух частей. Первый — это исполняемая программа, предназначенная для вашего компьютера и операционной системы. SerialIO представляет такие программы для Linux, Windows (32- и 64-разрядных), а также для OS X. Вторая часть содержит функции *Mathematica*, которые могут быть использованы в Вашем проекте. Она включает в себя команды **SerialOpen** и **SerialClose**, для открытия и закрытия канала связи на данном COM порте, а **SerialWrite** и **SerialRead** записывает или считывает данные с COM порта. Представленный ниже рисунок показывает различные уровни, через которые информация поступает во время сообщения между NXT и компьютером.
*Рисунок 1. Архитектура программного обеспечения, с помощью которой сообщаются NXT и компьютер. Последние три окна справа представляют программы Mathematica, а остальные два выдаются пакетом Math4NXT, о котором будет сказано далее.*
Скачайте пакет SerialIO из [Wolfram Library Archive](http://library.wolfram.com/) и установите его в выбранную Вами папку (лучшего всего в AddOns *Mathematica*, которая находится в папке ExtraPackages). Для большего удобства Вы можете поместить свою рабочую папку по этому адресу, в результате чего MathLink-совместимые программы будут автоматически туда сохраняться.
Далее следует загрузить пакет посредством [Needs](http://reference.wolfram.com/language/ref/Needs.html).
Если команда будет выполнена успешно, то Вы сможете увидеть процесс SeriallO, работающий на Вашем компьютере в фоновом режиме. Следующая команда открывает COM-порт и устанавливает канал связи с конструктором (он должен быть включен).
Если у вас есть конструктор NXT и Вы хотите вычислить ячейки кода, которые представлены в данной статье, то Вам нужно выбрать какую-то ячейку, удерживая клавишу Alt, таким образом будут выделены все ячейки. Далее, из главного меню *Mathematica* необходимо выбрать Cell Cell Properties Evaluatable. Без подключённого NXT выполнение этих команд вернёт сообщение об ошибке и невычисленную ячейку.
Чтобы убедиться, что соединение открыто, посмотрите на дисплей на конструкторе, который находится в верхнем левом углу. Если вы видите <, то это значит, что соединение не установлено. А <> означает, что соединение установлено. Переменная **mybrick** содержит дескриптор потока данных с СОМ порта и используется во всех последующих сообщениях. Закрытие COM порта осуществляется с помощью следующей команды.
Выход из *Mathematica* (или прекращение работы ядра) закрывает COM порт и завершает процесс SeriallO, который работает в фоновом режиме.
### Отправка сообщения и получение ответа
Пакет SerialIO был сделан, чтобы отправлять текст через СОМ-порт (или отдельные символы/строки текста). Однако, что касается управления NXT, имеет больше смысла отправить числа напрямую. Следовательно, нам нужно преобразовывать числа в соответствующие символы в ASCII-коде до того, как мы их отправим. Это немного неудобно, и мы предложим позже более аккуратнее решение.
Сообщение всегда начинается с байта, который указывает, следует ли NXT отвечать на него. Тут уж как кому удобнее, но многие команды, посылаемые конструктору, возвращают только байт состояния (0 — успешное выполнение, в противном случае — сообщение об ошибке). В случае ответного сообщения в виде байта состояния ответ является довольно таки бесполезным. Чтобы запросить ответ, первый байт должен быть равен 0; 128 означает, что NXT не должен отвечать.
Второй байт сообщения всегда является номером команды. Всё это представлено в документации LEGO Group [2]. Последующие байты зависят от отправленной команды.
Например, запрос к NXT проиграть звук задаётся прямой командой PlayTone. Номер этой команды — 3. Затем должны быть заданы два параметра: частота тона (число от 200 до 14000) и длительность тонов (в миллисекундах, число от 0 до 65535). Эти два параметра закодированы как UWORD (беззнаковое слово — WORD), то есть выделяется более двух байтов, наименее значащий байт ставится сначала. Для удобства, мы напишем функцию преобразования **toUWORD**.
Таким образом, частота тона в 480 Гц и продолжительность в две секунды соответствуют следующей последовательности байтов.
Всё сообщение выглядело бы так.
Перед самим сообщением должна быть указана его длина, которую можно получить посредством следующей команды.
Мы соединяем две части, чтобы получить полное сообщение и получить список символов, соответствующих их номерам (такие символы могут быть недоступны для просмотра на Вашем компьютере) в этой строке кода.
Давайте отправим эти символы конструктору NXT один за одним.
Теперь Вы можете услышать звуковой сигнал. Поскольку мы запросили ответ (первый байт был нулевым), нам нужно прочитать его.
Опять же, ответ состоит из текста (символы могут быть недоступны для просмотра). Давайте преобразуем их в список номеров.
Байты возвращаются в следующем порядке: длина возвращаемого сообщения, закодированная в более чем двух байтах в UWORD (в данном случае 3, 0 означает длину сообщения в 3 символа), второй байт показывает, что это ответное сообщение; третий байт указывает номер команды, которая выдала ответ (в данном случае команда Playtone) и, наконец, статус команды (где 0 указывает на успех). Команда PlayTone не возвращает другую информацию; некоторые прямые команды могут возвращать более сложные сообщения.
В качестве примера, мы отправляем команду GetBatteryLevel. Эта команда имеет номер 11 и не требует никаких параметров/дополнительной информации. Если ответ запрошен (но бессмысленно отправлять эту команду и не просить ответ) она возвращает статус команды (0 для успеха), за которым следуют два байта, указывающих напряжение батарей на NXT в милливольтах. Чтобы расшифровать напряжение, давайте создадим другую функцию преобразования – **fromUWORD**.
Давайте соберём всё сообщение, объединим с его длиной, сконвертируем это в список символов и отправим их.
Теперь давайте прочитаем ответ и преобразуем его в числа.
Первые два байта означают длину ответа (5 байт); 2 и 11 показывают, что это ответ на команду GetBatteryLevel; 0 указывает, что команда была успешно выполнена; и, наконец, 247 и 27 показывают напряжение аккумулятора, который мы преобразуем в число командой **fromUWORD**, описанной выше.
Таким образом, батареи имеют напряжение 7,16 вольт, что гораздо ниже ожидаемых 9 вольт для свежих батарей.
### Переопределение **SerialWrite**, для отправки целых чисел или их списков
Поскольку удобнее представлять числа, а не символы, которые отправляются к конструктору, мы расширяем команду **SerialWrite**, содержащуюся в пакете SerialIO, чтобы иметь возможность отправки как отдельных целых чисел от 0 до 255 (байты), так и их списков.
С этим расширением всё сообщение (которое состоит из байтов) может быть передано одним вызовом **SerialWrite**. К примеру, следующие инструкции собирают повторно команду PlayTone (на этот раз без ответа).
Всё сообщение отправлено с помощью вызова одной команды.
### Прямые команды, представленные в **Math4NXT**
Вышеупомянутое показывает, как какая-либо команда может отправляться к конструктору NXT, а его ответ — считываться. Потом, это просто вопрос сборки сообщения в правильном порядке и с нужной информацией, и, если потребуется, чтение ответа и его интерпретация. Для этих целей документация, предоставленная LEGO Group (особенно приложение 2 в [2]), является довольно полной.
Для большей простоты мы кодировали все прямые команды в пакете под названием **Math4NXT**. Сначала следует получить пакет **Math4NXT**. Так как он использует пакет SerialIO в фоновом режиме, также установите его в директорию, в которой осуществляет поиск *Mathematica* (например, *FileNameJoin[{$ InstallationDirectory, «AddOns», «ExtraPackages», «SerialIO»}]*). Затем загрузите **Math4NXT** с помощью следующей команды.
Поскольку мы поместили пакет **Math4NXT** не в одну из тех папок, по которым осуществляет поиск *Mathematica*, нам необходимо задать путь посредством команды **Needs**. Затем следует открыть последовательный порт (если это ещё не было сделано), как было показано ранее.
Все прямые команды начинаются с букв **NXT**. Следовательно, команда для чтения уровня батарей в пакете будет называться **NXTGetBatteryLevel**.
По умолчанию, команда возвращает ответ, используя именованные строки (например, **«Status»**). Вы можете извлечь какую-то часть информации обычным способом.
Этот формат может быть изменен, например, на raw (т. е. на выдачу в байтах, как и в двух предыдущих разделах), используя опцию **ResultFormat**.
С другой стороны, переданные и полученные байты могут быть отображены в отдельном окне с помощью опции .
Эта опция открывает *окно сообщений*.
*Рисунок 2. Окно с сообщением открывается автоматически, когда опция  используется.*
Все прямые команды доступны.
### Расширение прямых команд
Прямые команды имеют много ограничений. Во-первых, из-за природы СОМ порта, сообщение не может быть длиннее 253 байт. Это является большим ограничением при работе с файлами, которые могут быть гораздо больше. Кроме того, датчики LEGO работают весьма по-разному; некоторые датчики являются пассивными, не требующими питания, в то время как другие являются активными, а третьи являются программируемыми — как датчики I2C. Чтобы использовать команды единообразно и избежать ограничения по длине, мы задали команды более высокого уровня, внутри которых решаются эти проблемы.
Имена всех этих команд начинаются с **M4N**.
Одним из примеров является команда **M4NFileNames** которая перечисляет все файлы, присутствующие на конструкторе (опционально — с размером файла).
Эта команда работает, вызывая прямые команды **NXTFindFirst** (номер команды 134), **NXTFindNext** (135), и **NXTClose** (132), с помощью алгоритма, приведенного в Программе 1. Чтобы увидеть несколько вызовов команд NXT, используйте опцию  в **M4NFileNames**.
```
res=NXTFindFirst[mybrick,"*.*"];
While [("Status"/.res)=0,
res=NXTFindNext[mybrick,"Handle"/.res]
]
NXTClose[mybrick];
```
*Программа 1. **M4NFileNames** использует общий алгоритм для получения всех имён файлов, присутствующих на NXT. Этот алгоритм не показывает, как собрать имена файлов (содержащихся в виде байтов в **res**) в список.*
Аналогичным образом, чтобы облегчить использование датчиков, имеется команда, которая передаёт сообщение в *Mathematica* о типах подключённых датчиков. Чтение с датчика впоследствии производится в соответствии с его типом. Чтобы установить тип датчика, используйте **M4NSetSensor**.
После этого чтение с датчика производится универсальной командой **M4NReadSensor**. Чтобы соответствовать стилю прямых команд, первый датчик ставится на порт **0** входа NXT.
Результат представляется либо как **1** для «нажатого» состояния, либо **0** как для «ненажатого». Эта команда работает одинаково вне зависимости от типа подключенного датчика. Поэтому, если Вы подключите ультразвуковой датчик на третий вход, Вы можете запустить следующие две команды.
Ультразвуковой датчик — сложный датчик, созданный для обнаружения расстояния до препятствий перед ним (в см). Он оснащен микропроцессором, который работает по протоколу I2C. Он должен быть сначала включён, и после его загрузки с него можно начать считывать данные. Используя опцию , Вы увидите, что для для инициализации ультразвукового датчика требуется гораздо больше обмена информацией, чем при инициализации сенсорного датчика. Тем не менее, весь этот обмен информацией совершенно невидим с командами **M4N**.
### Работа с моторами
Другое ограничение прямых команд прошивки NXT касается управления двигателем. Новые моторы LEGO содержат встроенные счётчики оборотов, которые отслеживают количество вращательного движения. Однако, прямая команда может только остановить двигатель при достижении определенного количества пройденных градусов, после чего мотор меняет направление вращения.
PID-регулятор мотора является более эффективным способом контроля вращения. Он устанавливает количество градусов и регулирует мощность двигателя так, чтобы он замедлялся, когда цель почти достигнута (с помощью интеграла и производной; см. [4, 5]).
Авторы [5] разработали PID-регулятор для NXT. Этот контроллер находится на NXT; компьютер посылает заданное движение, после чего контроллер берет на себя управление двигателем, регулируя силу до тех пор, пока число градусов поворота не будет достигнуто. Программа контроллера называется **MotorControl22.rxe**, для версии 2.2.
Возьмите программу MotorControl22.rxe и отправьте её на конструктор. Чтобы сделать это, импортируйте содержимое файла в *Mathematica* и загрузите его в NXT. После установки (этот шаг может занять несколько минут при передаче через Bluetooth — файл весит 37 килобайт) можно запустить контроллер. Вот команды для выполнения этого; первая часть проверяет, что файл ещё не на конструкторе.
Наконец, посредством **M4NSetMotor** сообщите Вашей программе, какие у Вас типы двигателей и через какой порт они связаны.
Кстати, **M4NSetMotor** загружает MotorControl22.rxe, если он не присутствует на конструкторе и запускает эту программу, если она ещё не запущена. Следовательно, Вы можете не беспокоиться об этих деталях и можете полагаться только на **M4NSetMotor**.
Теперь, когда контроллер запущен и работает, вы можете отправить ему указания с помощью команд, связанных с моторами.
**M4NRunMotor**, **M4NStopMotor** и **M4NBrakeMotor** могут использоваться как на обычных двигателях, так и на двигателях со счётчиком оборотов (тахометром). Однако, **M4NRunMotorFor** может использоваться только с моторами, оснащёнными тахометром и PID-контроллером. Если двигатель управляется PID-контроллером, то Вам не стоит отправлять какие-то другие инструкции. Следовательно, **M4NRunMotorFreeQ** может использоваться для проверки контроллера.
Следующий набор команд запускает два мотора.
Остановить моторы можно с использованием двух различных режимов (**M4NBrakeMotor** блокирует двигатель, в то время как **M4NStopMotor** перестает питать двигатель).
Следующие команды проверяют, что мотор **MOTORA** свободен — до движения, во время движения (10 полных оборотов) и через шесть секунд после того, как движение начиналось.
### Настройка робота
На уровне программы, робот имеет конкретную конфигурацию, которая определяет какие датчики соединены со входом и какие моторы имеются на выходе. Ранее мы показали две команды, которые могут быть использованы для определения датчиков и моторов.
Мы создали обобщённую команду **M4NInitialize**, целью которой является установка всех этих элементов в одной команде. Кроме того, она также может использоваться для установки уровня громкости и присвоения имени конструктору (если у вас их много, то было бы неплохо переименовать по имени COM порта, к которому они подключены).
Помимо этого **M4NInitialize** проверяет — совместима-ли версия прошивки на NXT с этим пакетом и что батарея имеет достаточный уровень заряда (в противном случае возвращает предупреждение). Также можно задать путь к папке, содержащей контроллер MotorControl22.rxe с помощью опции **MotorControlPath**, в случае, если она всё еще не находится на NXT.
### Динамическое управление роботом
Команды **M4N** и **NXT** могут использоваться динамически. Например, чтобы получить текущее состояние сенсорных датчиков, следует выполнить следующие шаги.
Во-первых, инициализировать датчики, используя **M4NInitialize** или **M4NSetSensor**.
Функция **ShowSensor** создает панель с элементами **On** и **Off**, которые выставляются в зависимости от значения датчика. Эта функция использует некоторые опции только в целях удобства.
Затем, мы можем использовать **ShowSensor** четыре раза подряд, чтобы получить строку с индикаторами.
Опция [UpdateInterval](http://reference.wolfram.com/language/ref/UpdateInterval.html) определяет, через какой промежуток времени сообщаться с датчиками.
В качестве последнего примера мы создалим джойстик который управляет двумя моторами. Скорость вращения мотора (отрегулированная опцией **MotorPower**) зависит от положения джойстика (вертикальная ось). Кроме того, двигатели движутся синхронно, если положение джойстика центрировано по горизонтальной оси.
Сначала мы определим расширенную функцию ClickPane, которая работает с большим количеством событий, чем обычная функция [ClickPane](http://reference.wolfram.com/language/ref/ClickPane.html).
Мы должны не забыть инициализировать моторы (чтобы PID контроллер включён).
Вот и все. Следующий пример отображает панель с красной точкой (верхняя часть джойстика). Таким образом мы постоянно задаём мощность двигателя, чтобы она была пропорциональна положению джойстика. Кроме того, если джойстик отпущен, он возвращается к центру с показательной функцией, представленной переменной **mult**. Наконец, если вы нажмете на панель в любом месте, джойстик мгновенно возвратится к центру со звуковым сигналом.
### Робот, движущийся по заданной траектории
Чтобы проиллюстрировать простой пример автономного робота, мы создадим робота, движущегося по определённой траектории. Цель этого робота состоит в том, чтобы следовать по краю определённой линии. Линия должна быть тёмной на светлом фоне (или наоборот); контрастность на границе является важным фактором. Чтобы добиться этого, Вам понадобится робот, оснащённый спереди датчиком света (см., например, указания по сборке, данные на стр. 33 обучающей брошюры MINDSTORMS [2]).
Для этого проекта нам потребуются датчик света и два мотора, которые мы инициализировали.
На первом этапе мы должны откалибровать датчик так, чтобы показания на светлых и темных поверхностях были заданы. Используйте представленный ниже код, чтобы получить 100 показаний при движении робота по светлой поверхности.
Затем воспользуйтесь этим кодом при движении робота по тёмной поверхности.
Среднее вышеприведённых двух значений — критическое значение. Если робот, который следует по левому краю тёмной линии, наблюдает более светлый участок, чем среднее значение, нам нужно, чтобы он шёл вправо (и наоборот).
Следующая короткая программа перемещает робота на умеренной скорости (переменная **basespeed** имеет значение 20) и регулирует базовую скорость в соответствии с разностью между показанием о токе и среднем значении.
Константа **mult** используется для контроля коэффициента рулевого управления. Большие значения приводят к произведению роботом резких изменений направления. Эта величина должна быть небольшой для плавного движения. Тем не менее, если на траектории есть крутые повороты, малый множитель не даёт возможности роботу повернуться на достаточный угол, чтобы найти край снова. В выводах будут представлены некоторые подробности.
### Технические ограничения
Есть несколько прямых команд, которые мы решили не реализовывать в этом пакете. Они связаны с перезагрузкой NXT, изменением его прошивки, стиранием флэш-памяти, выполнением сброса. В сущности, эти команды уничтожают робота.
С командами **M4N** и **NXT** робот может управляться очень эффективно и легко. Однако, COM порт не очень быстр. Важно отметить, что каждое переключение направления передачи сигнала порта занимает 6 мс. Это причина, почему ответов следует избегать, если они не являются действительно необходимыми. В некоторых приложениях эти задержки могут быть настолько важными, что программа должна быть перемещена в конструктор полностью или частично. PID контроллер MotorControl22.rxe является примером, в котором программа распределена между двумя машинами: компьютер задаёт необходимые движения, и конструктор исполняет решения миллисекунда за миллисекундой для достижения цели.
### Выводы
Есть одна новая теория в когнитивной науке — теория воплощений. Она утверждает, что когнитивная система должна быть в интерактивной связи с внешним миром, чтобы разработать осмысленное представление о мире. Этот взгляд противоречит классическому взгляду на искусственный интеллект (ИИ), в котором утверждается, что когнитивные агенты манипулируют признаками или символами, которые могут быть не связаны с аспектами внешнего мира. Следовательно, с точки зрения ИИ, датчики и приводы не зависят от когнитивных функций и могут быть построены отдельно. Этот взгляд имеет силу, когда мы разрабатываем когнитивные системы в виртуальном мире (например, основанные на компьютерном моделировании). Тем не менее, когда роботы получают физическое воплощение, мы видим, как трудно удержать эту позицию.
Простая программа следования траектории показывает это. В виртуальной среде робот, следующий траектории, может работать на полной скорости, и повороты могут быть резкие, потому что нет инерции и риска, что робот упадёт. Когда робот получает физическое воплощение, данные аспекты становится очень серьёзными проблемами. Конечно, программист адаптирует программу, чтобы учесть эти риски (снижение скорости и уменьшение фактора усиления). Кроме того, данные о светлых и тёмных участках откалиброваны программистом весьма простым способом. Тем не менее, если внешнее освещение меняется, калибровка должна быть сделана снова. Кроме того, как было сказано раньше, если множитель **mult** имеет слишком маленькое значение, робот может не иметь возможности перемещаться достаточно быстро вокруг резкой кривой. Наконец, робот, следующий траектории, использует колёса. Если бы он использовал ноги вместо этого, гибкость и ограничения мышц вступили бы в силу.
Все вышеприведённые проблемы могут рассматриваться в худшем случае, как неудобства, а в лучшем случае как вызовы для программиста. Тем не менее, простейшие животные невосприимчивы ко всем этим проблемам. Теория воплощений утверждает, что организмы создали надлежащие представления о мире, взаимодействуя с ним, и что эти представления стали надежными в отношении всех возможных источников неисправности. Представления и алгоритмы, заданные программистом, с другой стороны, могут не отвечать требованиям реального мира, какими бы простыми и элегантными они не были.
NXT является простой, но полноценной платформой для испытания роботов в реальной жизни. В сочетании с вычислительной мощностью системы *Mathematica*, легко разрабатывать адаптивные алгоритмы, такие как нейронные сети и наблюдать, какие представления о мире получает робот. Ещё предстоит выяснить, как выглядит простейшая адаптивная программа робота, который следует по заданной траектории.
### Благодарности
Автор хотел бы поблагодарить Vincent Brault, Dominic Langlois и Sylvain Chartier из CONEC laboratory (Оттавский университет) за их помощь в разработке пакета **Math4NXT**.
### Использованная литература
[1] MathWorks. “Set Up a Bluetooth Connection.” (Feb 4, 2013) [www.mathworks.com/help/simulink/ug/bluetooth-communications.html](http://www.mathworks.com/help/simulink/ug/bluetooth-communications.html).
[2] The LEGO Group. “LEGO MINDSTORMS NXT Bluetooth Developer Kit.” (Jan 7, 2013) [mindstorms.LEGO.com/en-us/support/files/default.aspx](http://mindstorms.LEGO.com/en-us/support/files/default.aspx).
[3] R. Raguet-Schofield. “SerialIO.” Wolfram Library Archive. (Jan 7, 2013) [library.wolfram.com/infocenter/MathSource/5726](http://library.wolfram.com/infocenter/MathSource/5726).
[4] J. Sluka. “A PID Controller For LEGO MINDSTORMS Robots.” (Jan 7, 2013) [www.inpharmix.com/jps/PID\_Controller\_For \_Lego \_Mindstorms \_Robots.html](http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html).
[5] Institute of Imaging & Computer Vision. “RWTH—MINDSTORMS NXT Toolbox.” (Jan 7, 2013) [www.mindstorms.rwth-aachen.de/trac/wiki/MotorControl](http://www.mindstorms.rwth-aachen.de/trac/wiki/MotorControl).
D. Cousineau, “Controlling Robots Built with the LEGO MINDSTORMS NXT Brick,” *The Mathematica Journal*, 2013. dx.doi.org/doi:10.3888/tmj.15-3.
### Об авторе
Denis Cousineau является профессором Оттавского университета в области когнитивной психологии. Он проводит исследования в области искусственного интеллекта и процесса классификации объектов человеком.
Контактные данные: École de psychologie, Université d’Ottawa, 136, rue Jean-Jacques Lussier, Ottawa (ON), K1N 6N5, CANADA, e-mail: Denis.Cousineau@UOttawa.ca | https://habr.com/ru/post/256345/ | null | ru | null |
# Как пропатчить K̶D̶E̶ TCP-стек под FreeBSD
Когда стоит вопрос выбора между проприетарным и открытым программным обеспечением, часто в пользу последнего приводят следующий аргумент: при необходимости можно изменить исходники под нужды своего проекта, или исправить ошибку прямо сейчас, а не дожидаясь месяцами реакции вендора. Зачастую это соображение является оторванным от практики — куда проще исправить SQL запрос, чем оптимизировать SQL-планировщик, или поменять проблемное оборудование вместо того, чтобы искать и исправлять ошибку в драйвере. Тем не менее, иногда именно открытость кода позволяет избежать потенциальных убытков и перерасхода вычислительных ресурсов. Хочу рассказать об одном из таких кейсов, случившемся за время моей работы в Advanced Hosting
### Всплеск трафика и первые подозрения на DDoS
В субботу поздним вечером слег один из серверов. Весь кластер данного проекта состоял из 3+3 штук, и каждый тянет всю нагрузку своей тройки, так что выпадение одного ничем сервису не грозило. Но все же было крайне неприятно, что сервера, доселе спокойно принимающие суммарный входящий трафик в 10+К http-запросов в секунду, и имевшие (как казалось) ещё несколько-кратный запас по производительности, вдруг оказались не такими уж и устойчивыми. Пока ребилдился RAID1 и PostgreSQL догонял репликацию, было время посмотреть на остальные сервера.
Стоит заранее объяснить, как устроен данный кластер. Сервера стоят в разных местах, два в Европе и четыре в USA. Они разбиты на тройки и обслуживают свою группу IP (т.е. для каждой тройки один сервер в Европе и остальные два в USA). Трафик распределяется средствами anycast — на всех серверах тройки прописаны одни и те же IP адреса, и поднята BGP-сессия с его непосредственным роутером. Если какой-либо сервер ложится, то соответствующий роутер перестает анонсировать его сеть в Internet и трафик автоматически уходит на оставшиеся сервера.
Смотреть было не на что. По данным мониторинга непосредственно перед падением был сильный всплеск входящего и исходящего трафика на оба европейских сервера (один из них и слег), причем если бэндвич увеличился в два раза, то количество пакетов в секунду выросло уже раз в десять, причем в обе стороны. Т.е. пакеты были мелкие, и их было много (под 200К в секунду).
На HighLoad сервисах трафик просто так не меняется, тем более в таких размерах. Очень похоже на DDoS, не так ли? Не сказать, что я сильно удивился, DDoS-ов разных видов мне пришлось повидать немало, и пока что, если сетевое оборудование у провайдеров позволяло доставлять трафик без потерь на сервера, их всегда удавалось блокировать. Настораживало то, что всплеск трафика был только на европейских серверах: ведь если ботнет распределенный, то и трафик должен быть распределен на весь кластер.
### Потери пакетов и рост количества активных TCP-сессий
После ввода сервера в строй я запустил `top`, `nload` и стал мониторить загрузку. Вскоре трафик опять поднялся в два раза и ssh сессия начала ощутимо лагать. Налицо потери пакетов, `mtr -ni 0.1 8.8.8.8` данную гипотезу сразу и подтвердил, а `top -SH` указал, что дело в ядре ОС — обработчику входящих сетевых пакетов не хватает CPU. Что же, теперь понятно, почему завис сервер — потери пакетов ему смерти подобны.
У FreeBSD на момент написания поста была одна весьма неприятная особенность в сетевом стеке — он плохо масштабируется относительно количества TCP-сессий. Увеличение кол-ва TCP-сессий в несколько раз приводит к непропорционально бОльшему потреблению CPU. Пока сессий немного, проблем нет; но начиная с нескольких десятков тысяч активных TCP-сессий обработчик входящих пакетов начинает испытывать нехватку CPU и ему приходится дропать пакеты. А это приводит к цепной реакции — из-за потерь пакетов активные TCP-сессии начинают медленно обслуживаться, тут-же начинает расти их количество, а с ним растет и нехватка CPU и дальше поднимается уровень потерь пакетов.
Пока сервер окончательно не завис, срочно тушу BGP-сессию, и параллельно запускаю проверку потерь пакетов на том сервере, что принял на себя европейский трафик. Он имеет более мощное железо — т.е. есть шансы, что в Штатах ничего плохого не случится. С проблемным сервером нужно что-то делать и первым делом я выключаю HTTP keep-alive — TCP-сессии начнут завершаться раньше и в сумме их будет уже меньше. Тюнинг настроек сетевой карты занял не один десяток минут, проверяя наличие потерь пакетов каждый раз кратковременным поднятием BGP-сессии — пришлось оставить polling режим, но активировать idlepoll — теперь одно ядро процессора было занято исключительно сетевой картой, но зато потери пакетов прекратились.
Оставались еще непонятные моменты — например, количество TCP-сессий во время атаки и в обычном рабочем режиме практически не отличалось, то есть проблема была не в значительном увеличении их числа. Но вот что было совершенно непонятно, так это почему на американских серверах этой атаки не было видно вообще! Во время отключения европейских серверов на штатовские приходил только актуальный рабочий трафик, но не было никакого дополнительного! Хотя после возвращения трафика в Европу он какое-то время держался на рабочем уровне, а потом начинался очередной всплеск.
Время было за час ночи, потери пакетов, кажется, удалось прекратить, а с этими сетевыми странностями можно разбираться и на свежую голову. С такими мыслями я отправился обратно спать, но через пару часов меня опять разбудили — в этот раз лежали уже оба европейских сервера. Это привнесло очередную странность в копилку этого случая — ведь время уже было позднее, и пик трафика был давно позади. Хотя, как для DDoS-атаки это нормально, потому что большинство специалистов спит и заниматься атакой, как правило, некому. Оба сервера были вскоре запущены, но последующий мониторинг ситуации ничего нового не дал — атака в тот день больше не повторялась.
### Краткосрочное решение
В воскресенье пришлось немного поработать. Отдельный скрипт уже мониторил количество TCP-сессий и временно снимал трафик (т.е. переводил его в Штаты) в случае повышенной нагрузки, что уменьшало полученный ущерб. Пока что штатовские сервера работали без проблем, но все же надо было разобраться с этим трафиком и научиться его блокировать. В http-логах никаких аномалий не было, netstat и подобные утилиты тоже ничего подозрительного не показывали. Тем не менее, если мы видим повышение трафика на сетевой карте, можно его изучать, используя tcpdump.
Пролистывать тонны дампов сетевых пакетов бывает непросто, но в этот раз долго искать не пришлось — среди обычного HTTP/HTTPS обмена было видно аномально много пустых TCP-пакетов, т.е. легальных пакетов с корректными IP и TCP заголовками, но без данных. При выключеном HTTP keep-alive пустых пакетов и так немало — три пустых на установление соединения, потом два пакета обмена данными (запрос-ответ), и потом опять пустые пакеты закрывают соединения. Кроме этого, при использовании HTTPS у нас тоже есть пакеты с данными для установки TLS-сессии.
Выборочная проверка отдельных TCP-сессий показала, что по некоторым сессиям действительно происходит очень интенсивный обмен пустыми TCP-пакетами. Почти все эти сессии были родом из Индии! Было и немного Саудовской Аравии с Кувейтом. Сложно сказать, что это за такой хитрый ботнет, да пока и не до этого. Пишу второй несложный скрипт, который каждую секунду запускает tcpdump на 30к пакетов и ищет среди них сессии, в которых количество последовательных обменов пустыми пакетами превышает указанный лимит, найденные IP немедленно блокируются. Результат не заставил себя ждать — при блокировке только пяти IP трафик тут же падает в два раза. Каждую минуту блокировался ещё один-два новых IP. Победа!
### Анализ симптомов и выявление проблемы
После обсуждения этого кейса с коллегами в Advanced Hosting, оказалось, что все не так радужно. Во первых, интенсивность блокировки новых IP нарастала — уже не в пик трафика скорость блокировки доходила до нескольких десятков штук в минуту. Во вторых, затронутыми оказались не только эти сервера, но и много других, причем других клиентов. Что характерно, все в Европе и все на FreeBSD. Стало ясно, что это никакая не DDOS-атака.
Заблокированные IP пришлось освободить и вместо блокировки теперь дропались сами TCP-сессии (во FreeBSD для этого есть утилита tcpdrop). Это так же эффективно удерживало нагрузку под контролем и позволяло даже включить обратно HTTP keep-alive.
Надо опять брать в руки tcpdump и смотреть трафик дальше. Не буду детально описывать те часы, которые были потрачены на поиск аномалий и закономерностей в данных. TCP-сессии были разные. Были и полностью пустые, а были и с обменом данными, которые потом переходили в цикл обмена пустыми пакетами.
Но зацепка все же была. Перед уходом в цикл обмена пустыми пакетами от удаленной стороны приходил FIN пакет (пакет с флагом FIN сигнализирует, что данных больше не будет и сессию надо закрывать), иногда и не один, а бывало и RST пакет (пакет с флагом RST указывает, что сессия уже закрыта и больше не валидна).
Что интересно, несмотря на наличие FIN и RST пакетов, потом бывало что на сервер приходили и пакеты с данными. Либо где-то настолько криво реализован TCP-стек, что маловероятно, либо где-то происходит грубое вмешательство в TCP-сессии, а вот это уже вполне вероятно (особенно этим любят баловаться мобильные операторы, не буду показывать пальцем). Вторую версию также подтверждал тот факт, что проверка по http-логу найденных зловредных TCP-сессий показала, что практически во всех них был задействован мобильный браузер, причем как Android, так и iOS.
Логично было предположить, FIN или RST пакет переводил TCP-сессию в закрытое состояние, в котором TCP-стек просто подтверждал получение пакетов. Было интересно, какое конкретно из TCP-состояний
**tcp\_fsm.h**
```
#define TCP_NSTATES 11
#define TCPS_CLOSED 0 /* closed */
#define TCPS_LISTEN 1 /* listening for connection */
#define TCPS_SYN_SENT 2 /* active, have sent syn */
#define TCPS_SYN_RECEIVED 3 /* have sent and received syn */
/* states < TCPS_ESTABLISHED are those where connections not established */
#define TCPS_ESTABLISHED 4 /* established */
#define TCPS_CLOSE_WAIT 5 /* rcvd fin, waiting for close */
/* states > TCPS_CLOSE_WAIT are those where user has closed */
#define TCPS_FIN_WAIT_1 6 /* have closed, sent fin */
#define TCPS_CLOSING 7 /* closed xchd FIN; await FIN ACK */
#define TCPS_LAST_ACK 8 /* had fin and close; await FIN ACK */
/* states > TCPS_CLOSE_WAIT && < TCPS_FIN_WAIT_2 await ACK of FIN */
#define TCPS_FIN_WAIT_2 9 /* have closed, fin is acked */
#define TCPS_TIME_WAIT 10 /* in 2*msl quiet wait after close */
```
так себя ведет, и перед вызовом `tcpdrop` я добавил поиск удаляемой TCP-сесии в выводе `netstat -an`. Результат был немного обескураживающим — они все были в состоянии ESTABLISHED! Это уже было сильно похоже на баг — не может закрытая TCP-сессия перейти обратно в состояние ESTABLISHED, не предусмотрен такой вариант. Я немедленно начал проверять исходники и ядра и был обескуражен второй раз:
```
tp->t_state = TCPS_ESTABLISHED
```
в коде вызывается ровно два раза, и оба раза непосредственно перед этим проверяется текущее значение t\_state — в одном случае оно равно TCPS\_SYN\_SENT (сервер отослал SYN пакет и получил подтверждение), а во втором это TCPS\_SYN\_RECEIVED (сервер получил SYN, отправил SYN/ACK и получил подтверждающий ACK). Вывод из это следует вполне конкретный — FIN и RST пакеты сервером игнорировались, и никакого бага в TCP-стеке нет (по крайней мере, бага с неправильным переходом из одного состояния в другое).
Все же было непонятно, зачем серверу отвечать на каждый полученный TCP пакет. Обычно в этом нет необходимости, и TCP-стек работает по другому — он принимает несколько пакетов, а потом отсылает одним пакетом подтверждение для всех сразу — так экономнее. Пролить свет на ситуацию помогло внимательное изучение содержимого пакетов, в частности 32-х битных счетчиков TCP — Sequence (SEQ) и Acknowledgement (ACK). Поведение tcpdump по умолчанию — показывать разницу seq/ack между пакетами вместо абсолютных значений — в данном случае сыграло дурную службу.
`16:03:21.931367 IP (tos 0x28, ttl 47, id 44771, offset 0, flags [DF], proto TCP (6), length 60)
46.153.19.182.54645 > 88.208.9.111.80: Flags [S], cksum 0x181c (correct), seq 3834615051, win 65535, options [mss 1460,sackOK,TS val 932840 ecr 0,nop,wscale 6], length 0
16:03:21.931387 IP (tos 0x0, ttl 64, id 1432, offset 0, flags [DF], proto TCP (6), length 60)
88.208.9.111.80 > 46.153.19.182.54645: Flags [S.], cksum 0xa4bc (incorrect -> 0xf9a4), seq 1594895211, ack 3834615052, win 8192, options [mss 1460,nop,wscale 6,sackOK,TS val 2509954639 ecr 932840], length 0
16:03:22.049434 IP (tos 0x28, ttl 47, id 44772, offset 0, flags [DF], proto TCP (6), length 52)
46.153.19.182.54645 > 88.208.9.111.80: Flags [.], cksum 0x430b (correct), seq 3834615052, ack 1594895212, win 1369, options [nop,nop,TS val 932852 ecr 2509954639], length 0
16:03:22.053697 IP (tos 0x28, ttl 47, id 44773, offset 0, flags [DF], proto TCP (6), length 40)
46.153.19.182.54645 > 88.208.9.111.80: Flags [R], cksum 0x93ba (correct), seq 211128292, win 1369, length 0
16:03:22.059913 IP (tos 0x28, ttl 48, id 0, offset 0, flags [DF], proto TCP (6), length 40)
46.153.19.182.54645 > 88.208.9.111.80: Flags [R.], cksum 0xa03f (correct), seq 0, ack 1594897965, win 0, length 0
16:03:22.060700 IP (tos 0x28, ttl 47, id 44774, offset 0, flags [DF], proto TCP (6), length 52)
46.153.19.182.54645 > 88.208.9.111.80: Flags [.], cksum 0x3a48 (correct), seq 3834615953, ack 1594896512, win 1410, options [nop,nop,TS val 932853 ecr 2509954639], length 0
16:03:22.060706 IP (tos 0x0, ttl 64, id 3974, offset 0, flags [DF], proto TCP (6), length 52)
88.208.9.111.80 > 46.153.19.182.54645: Flags [.], cksum 0xa4b4 (incorrect -> 0x475c), seq 1594895212, ack 3834615052, win 135, options [nop,nop,TS val 2509954768 ecr 932852], length 0`
Посмотрим внимательно на абсолютные значения. Первый пакет содержит seq 3834615051, в ответ от сервера ушел пакет seq 1594895211, ack 3834615052 (в out-ack ушел номер in-seq + 1).
Потом пришло пару RST пакетов, они нам не интересны.
А вот следующий пакет нам интересен — в нем записаны номера seq 3834615953, ack 1594896512. Оба эти номера существенно больше чем initial seq/ack, а это означает, что удаленная сторона уже отослала 3834615953-3834615052=901 байт и даже успела получить 1594896512-1594895212=1300 байт.
Разумеется, этих пакетов с данными мы не видим и не увидим — этот обмен был с MiTM системой. Но сервер то этого не знает. Он видит пакет с seq 3834615953, а следовательно, делает вывод, что ему не пришло 901 байт данных, и поэтому отсылает обратно пакет с последними валидными seq/ack номерами, ему известными — seq 1594895212, ack 3834615052. Удаленная сторона получает этот пакет, и в свою очередь рапортует, что у неё все отлично, 1300 байт данных получены успешно. Вот у нас и зацикливание.
Также становится понятным, почему штатовские сервера не видели этого трафика — он на самом деле был, но во много раз меньше — во столько же раз, во сколько пинг из Индии в Америку больше, чем пинг из Индии в Европу.
### Итоговый патч
Осталось, собственно, найти, как исправить этот баг. Опять берем исходники, интересующий нас код находится в файле tcp\_input.c. Это было не сложно, так как первичной обработкой TCP-пакета занимается функция tcp\_input(). Алгоритм функции устроен таким образом, что пакет передается на обработку в функцию tcp\_do\_segment() в самом конце, когда он прошел все проверки и TCP-соединение находится в состоянии ESTABLISHED.
Необходимо добавить ещё одну проверку — если ack-счетчик от удаленной стороны показывает, что она получила данные, которые сервер не отсылал — пакет надо игнорировать. Обрывать сразу соединение нельзя — иначе мы откроем злоумышленникам простой способ обрывать чужие TCP-соединения.
Тестирование патча показало, что в TCP-трафике также присутствуют пакеты с нулевым значением ack — их игнорировать уже не надо. Итоговый патч занял три строчки (без учета комментариев):
```
+ if(SEQ_GT(th->th_ack, tp->snd_max) && th->th_ack != 0) {
+ goto dropunlock;
+ }
```
PR (problem report) разработчикам FreeBSD отправлен [в тот же день](https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=219991).
**P.S.** Как с этой проблемой обстоят дела в Linux и Windows? А там все нормально, такие пакеты игнорируются (тестировал Windows 10 и Linux 3.10). | https://habr.com/ru/post/331072/ | null | ru | null |
# Интернет через ICMP
Здравствуйте! Вы забыли заплатить за интернет, провайдер заблокировал TCP и UDP, а про ICMP забыл, и любой ресурс пингуется? Тогда этот топик для вас!
Предполагается, что у вас есть VPS или Dedicated или что-то еще под linux с tun и компьютер, с которого вы хотите подключиться, под linux.
#### Софт
Я сначала использовал ptunnel и туннель почти не работал, я думал, так и должно быть, это же icmp, но потом попробовал [hanstunnel](http://code.gerade.org/hans/) и очень сильно обрадовался.
#### Установка и настройка
Ищем в репозиториях / собираем самостоятельно hans на обоих компьютерах
На сервере запускаем:
```
echo 1 | sudo tee /proc/sys/net/ipv4/icmp_echo_ignore_all
sudo hans -s 192.168.x.x -p PASSWORD
```
где 192.168.x.x — диапазон IP-адресов, а PASSWORD — пароль.
На клиенте:
```
sudo hans -c SERV_IP_ADDR -p PASSWORD
```
где SERV\_IP\_ADDR — адрес с запущенным hans, а PASSWORD — пароль.
Итак, hans запущен на обоих компьютерах, ip получены, что делать дальше? Дальше, на сервере выполняем:
```
sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -t nat -I POSTROUTING -s 192.168.x.x -j MASQUERADE
```
На клиенте:
```
sudo ip route add SERV_IP_ADDR via $(ip route | grep default | awk '{print $3}')
sudo ip route del default
sudo ip route add default via 192.168.x.x
```
Вот и все! Таким образом, скорее всего, можно обойти месячное ограничение трафика или даже ограничение скорости(но тут как повезет). На скриншоте выше показана реальная скорость, которую в данный момент обеспечивает мой туннель. | https://habr.com/ru/post/131800/ | null | ru | null |
# «Баг»-не-баг нецентрирования рисунков атрибутом align=center
Как известно, Хабр использует «олдскульные» атрибуты тегов, допускающие форматирование текста и рисунков в статьях и комментариях авторами. Среди таких тегов оказался один, отсутствующий в стандартах W3C. Это — ![](). Обнаружилось, что часть авторов «наивно» пользуется этим атрибутом, потому что другого редактор Хабра просто не предоставляет. Как ни странно, в части браузеров этот атрибут на Хабре поддерживается, хотя эксперименты с чистыми тестовыми страницами показывают, что чудес нет, в img он не работает.
Заинтересовал вопрос, в каких случаях атрибут поддерживается и что надо дописать в стилях, чтобы он начал поддерживаться везде. Если бы это заработало на сайте, мы поддержали бы наивное мнение, что это правильный атрибут, но, тем не менее, получили бы инструмент центрирования рисунков.
На самом деле, атрибут align=«center» в HTML предназначен для блочных элементов (div, p, ...) и относится не к ним самим, а к внутреннему содержанию элемента. Поэтому, если напишем
```
```
то центрирование работать будет (это показано ниже на тестовой странице рисунками с alt="**рис.-под-тест**").
Но этого нельзя написать на Хабре, таковы правила парсера тегов.
Чтобы проверить, как это работает на Хабре, можно воспользоваться предпросмотром при написании комментария или в черновике статьи. Это не совсем точно будет совпадать с окончательным видом, но пользоваться для тестов можно.
```
```
Вот что увидим:
В большинстве браузеров, кроме Firefox, вторая картинка центрируется (если стили Хабра ещё не исправили), хотя [тесты показывают](http://spmbt.kodingen.com/habrahabr/testImgAlignCenter.htm), что этот атрибут браузерами не поддерживается (кроме редких исключений с доктайпами).
Почему же этот неправильный текст не работает везде, но работает на Хабре, причём не в Firefox?
**UPD 25 янв. 2013** *(через год):* обнаружилось, что стили Хабра перестали поддерживать этот неправильный атрибут. Для его задействования на сайте пришлось дописать юзерстили так же, как раньше это было сделано для Firefox.
Посмотрев на стили рисунка, находим причину.
```
img[align="center"] {
display: block;
margin: 0 auto !important;
}
```
Да, на Хабре в файле all.css поддерживается этот финт превращения неправильного атрибута в «правильный». Именно эти свойства нужно иметь рисунку, чтобы начать центрироваться — **быть блоком** и центрироваться стилем **margin: 0 auto;**.
*(А ведь те, кто знает, что такого атрибута нет, не могут сами догадаться, что он работает на Хабре — документации нет, тест в Fx не проходит. Я, например, чисто случайно узнал о его существовании, увидев в [заметках](http://habrahabr.ru/users/aleksandrit/blog/) [aleksandrIt](http://habrahabr.ru/users/aleksandrit/) (почти в каждой аннотации), посмотрев через Chrome.)*
Осталось разобраться, почему центрирование не работает в Firefox.
Дело за малым — тоже посмотреть стили (с помощью Firebug). Здесь обнаруживаем, что атрибут чудесным образом изменился на align=«middle» и даже ручное переименование не помогает его исправить. Браузер сам меняет неправильный атрибут на, «по его мнению», наиболее подходящий (вертикальное выравнивание в потоке строчных элементов). Поэтому правило стилей img[align=«center»] перестаёт работать.
Следовательно, для полной поддержки браузеров на Хабре не хватает правила:
```
img[align="center"], img[align="middle"]{
display: block;
margin: 0 auto !important;
}
```
### Тест чистой страницы с атрибутами
Чтобы посмотреть тестовую страницу проверки работы атрибута img align=«center» в разных браузерах, посетите ссылку [spmbt.kodingen.com/habrahabr/testImgAlignCenter.htm](http://spmbt.kodingen.com/habrahabr/testImgAlignCenter.htm). В Firefox будет выглядеть примерно так, в других браузерах несколько иначе. Картинки и блоки подкрашены, чтобы лучше различались. Реальных картинок нет, чтобы наблюдать подписи в ALT.
Сначала увидим под надписью «Основной тест» голубоватый блок "**Пустой рис.**" с искомым атрибутом и несрабатывание атрибута в изображении, что совершенно логично.
Одним кликом на ссылке «Включить исправляющие стили» можно увидеть применение полученных нами правил стилей, чтобы центрирование начало работать во всех браузерах.
Технические замечания. Ососбенный вид функции применения стилей addRules() вызвано желанием включить в исполнение скрипт в браузере IE8. (В IE9 не проверялось, но должно работать, как в остальных.) Без доктайпа в IE8 не будет работать правило margin: 0 auto, но заработают атрибуты align:right и left.
### Что делать?
Такое правило специально для правки ошибки было прописано в стилях Habr [ZenComment](http://userstyles.org/styles/36690) и независимо от них, в скрипте [HabrAjax](http://userscripts.org/scripts/show/121690) (Хабр-аджакс), после чего центрирование атрибутом align=«center» стало работать правильно во всех браузерах.
**Для выводов вообще**, надо сказать, что не следовало бы поддерживать мнение среди вебмастеров, что этот атрибут может работать в тегах IMG. Пусть время атрибутов прошло и все пользуются стилями, некоторым неопытным веб-строителям может запасть мнение, что такой атрибут существует.
**UPD 25 янв. 2013** *(через год):* обнаружилось, что стили Хабра перестали поддерживать этот неправильный атрибут. Для его задействования на сайте пришлось дописать юзерстили так же, как раньше это было сделано для Firefox. | https://habr.com/ru/post/135818/ | null | ru | null |
# Приручение черного дракона. Этичный хакинг с Kali Linux. Часть 1. Подготовка рабочего стенда
Приветствую тебя, дорогой читатель в самой первой вводной части серии статей «Приручение черного дракона. Этичный хакинг с Kali Linux».
Полный список статей прилагается ниже, и будет дополняться по мере появления новых.
**Приручение черного дракона. Этичный хакинг с Kali Linux:**
[Часть 1. Вводная часть. Подготовка рабочего стенда.](https://habr.com/ru/post/694886/)
[Часть 2. Фазы атаки.](https://habr.com/ru/post/695112/)
[Часть 3. Footprinting. Разведка и сбор информации.](https://habr.com/ru/post/695140/)
[Часть 4. Сканирование и типы сканирования. Погружение в nmap.](https://habr.com/ru/post/695160/)
[Часть 5. Методы получения доступа к системе.](https://habr.com/ru/post/696840/)
[Часть 6. Пост-эксплуатация. Способы повышения привилегий.](https://habr.com/ru/post/697784/)
[Часть 7. Пост-эксплуатация. Закрепление в системе.](https://habr.com/ru/post/700004/)
Идеей, побудившей меня к написанию данной серии статей является мое желание поделиться собственным опытом в области тестирования на проникновение в рамках проводимых мной аудитов информационной безопасности финансовых организаций, и попытаться осветить важные, на мой взгляд, ключевые моменты касаемо подхода, инструментов, приемов и методов. Конечно же в сети очень много статей и книг посвященных данной теме (например, замечательная книга Дениела Г. Грэма «Этичный хакинг. Практическое руководство по взлому» или «Kali Linux. Тестирование на проникновение и безопасность» - труд целого коллектива высококлассных специалистов), программы курсов от Offensive Security, EC-Council, но далеко не у всех есть материальные возможности оплачивать дорогостоящие курсы, а в дополнение к учебникам хотелось бы больше практических примеров основанных на чьем-то опыте.
Я искренне надеюсь, дорогой читатель, что в этой серии статей мне удастся охватить большую часть интересующих тебя тем, и ответить на большую часть вопросов возникающих у тебя по мере погружения в таинственный мир информационной безопасности и пентестинга в частности.
Мы будем использовать подход максимально приближенный к сценариям атак проводимых злоумышленниками, а также вдоволь попрактикуемся на отдельных примерах и разберем такие темы как разведка и сбор информации (footprinting), сканирование ресурсов с целью обнаружения известных уязвимостей, применение эксплоитов из базы Metasploit framework для получения доступа к системе, повышение привилегий до уровня root-пользователя за счет уязвимого ПО (privilege escalation), рассмотрим методы социальной инженерии, сетевые атаки канального уровня (MAC-spoofing, ARP-spoofing, DHCP starvation), способы атак на веб-сервера, перехват и анализ трафика с помощью сетевых снифферов и многое другое.
В качестве примеров я буду использовать атаки на специально подготовленные уязвимые машины. Мы рассмотрим и проанализируем в деталях каждый метод, а так же поговорим о том как защитить свои устройства и сетевую инфраструктуру, от подобного рода атак.
Во избежание нарушения каких-либо законов (ведь наша серия статей посвящена именно ЭТИЧНОМУ хакингу), все наши эксперименты мы будем проводить в специально подготовленной виртуальной лаборатории. Ниже я опишу пошагово все действия необходимые для подготовки этой самой лаборатории. Для комфортной работы нам понадобится ПК либо ноутбук с объемом оперативной памяти не менее 6-8 Гигабайтов и любым современным 2-х ядерным процессором с поддержкой технологии виртуализации.
И так, после недолгого вступления, перейдем к практической части и начнем собирать нашу лабораторию.
Первым делом, нам необходимо будет скачать гипервизор, на котором и будем в дальнейшем разворачивать нашу виртуальную лабораторию.
Если сильно не вдаваться в подробности виртуализации, то гипервизор — это специальная программа, которая позволяет нам параллельно запускать на нашем компьютере операционные системы/программы с различной архитектурой (Windows, Linux, FreeBSD).
Для работы я буду использовать бесплатную версию гипервизора VMware Workstation Player, который доступен для скачивания на официальном сайте компании vmware по [ссылке](https://www.vmware.com/ru/products/workstation-player/workstation-player-evaluation.html).
Гипервизор доступен для платформ Windows и Linux
Процесс установки очень простой и быстрый. Несколько нажатий кнопки NEXT, принятие условий лицензионного соглашения и наш гипервизор готов к работе.
Следующим шагом, нам необходимо скачать виртуальную машину Kali Linux.
Это специально разработанная компанией Offensive Security операционная система для тестирования на взлом и проникновение, которая просто до отказа нафарширована различными инструментами под любые типы проверок и атак.
Скачать ее можно совершенно бесплатно [c официального сайта по ссылке](https://www.kali.org/get-kali/).
Версий дистрибутива несколько, нам нужна именно виртуальная машина (Virtual Machines) для платформы VMware.
После того, как архив с образом системы скачается, разархивируем его в заранее подготовленную папку (например VMs).
После завершения распаковки папки с образом Kali Linux, запускаем VMware Workstation Player и открываем в нем существующую машину (при желании, можно скачать образ дистрибутива Kali и установить самому, однако, разворачивать готовый преднастроенный образ куда быстрее).
При первом запуске наш гипервизор выдаст окно с предложением продолжить использовать бесплатную версию, либо ввести лицензионный ключ. Оставляем первый вариант
После чего уже откроется основное окно программы, где мы открываем нашу машину
Заходим в папку VMs – kali-linux-2022.3-vmware-amd64 и открываем файл образа (он единственный отобразится в списке)
Буквально через несколько секунд, в списке у нас появится готовая к работе машина Kali Linux. Но прежде чем ее запустить, зайдем в настройки и кое-что изменим
Здесь мы видим настройки касающиеся самой виртуальной машины и ее виртуальных устройств (сетевые адаптеры, жесткие диски, выделенный объем ОЗУ и т. д.)
Для улучшения производительности добавим ей оперативной памяти (опять же, если на нашей физической машине ее достаточно), а также убедимся, что тип адаптера стоит NAT (такой же тип будет настроен на наших уязвимых машинах, которые желательно изолировать за NAT-ом от вашей физической сети).
Запускаем виртуальную машину Kali и, при открытии окна с запросом ввода логина и пароля вводим kali/kali.
После успешного входа нас приветствует стильный рабочий стол Kali Linux с черным драконом в центре. Заострять внимание на интерфейсе рабочего стола мы сейчас не будем, поскольку большую часть времени нам придется работать в терминале.
Его и откроем для начала.
С учетом того, что все операции в большинстве своем требуют для выполнения наличия прав суперпользователя, введем команду sudo -s пароль kali и перейдем в режим с правами root.
Далее, первым делом, синхронизируем все списки пакетов в системе, а также обновим их следующей командой:
`apt update -y && apt upgrade -y`
По завершению выполнения всех обновлений пакетов можно перейти к загрузке уязвимых машин для нашего киберполигона.
Для дальнейшей работы нам понадобятся:
1) Машина Metasploitable2 на базе Linux, представляющая собой уязвимую машину специально подготовленную для обучения этичному хакингу.
[Скачиваем ее тут](https://sourceforge.net/projects/metasploitable/)
2) Несколько машин с ресурса Vulnhub подготовленных для соревнований типа CaptureTheFlag (CTF). Ими будут: HappyCorp1, CyberSploit1, CyberSploit2, Mr-Robot.
Прямые ссылки для скачивания:
<https://www.vulnhub.com/entry/happycorp-1,296/>
<https://www.vulnhub.com/entry/cybersploit-1,506/>
<https://www.vulnhub.com/entry/cybersploit-2,511/>
<https://www.vulnhub.com/entry/mr-robot-1,151/>
Процедура скачивания и установки машин из образов не отличается от вышеописанной и не должна вызвать сложностей.
**ВАЖНО! У всех установленных виртуальных машин в разделе интерфейсов должен стоять тот же тип, что и у машины Kali Linux (NAT).**
На этом первая вводная часть подошла к концу, и мы полностью готовы к тому, чтобы начать постигать тайны этичного хакинга. В следующей части мы рассмотрим такую важную тему, как фазы атаки. Спасибо за внимание и до новых встреч! :) | https://habr.com/ru/post/694886/ | null | ru | null |
# Тем, кто учится программировать и решил написать вопрос на Stack Overflow: «Почему код не работает?»
На сайте Stack Overflow много вопросов от людей, ещё только изучающих языки программирования. Лайфхак: ответы на многие эти вопросы можно получить сразу, запустив анализатор кода. Получится быстрее.
Эту заметку меня побудила написать дискуссия "[Segmentation fault when converting char \* to char \*\*](https://stackoverflow.com/questions/72478692/segmentation-fault-when-converting-char-to-char/)" на сайте Stack Overflow. Человек, изучающий программирование, интересуется, что не так с его кодом.
```
#include
#include
#include
#include
#include
char \*\*get\_words(char \*buffer, char delimiter)
{
printf("buffer = %s\n", buffer);
char \*\*words = malloc(sizeof(char \*) \* 100);
if (words == NULL) {
printf("Malloc Error\n");
exit(84);
}
for (int i = 0; i < 100; i++) {
words[i] = malloc(sizeof(char) \* 100);
if (words[i] == NULL) {
printf("Malloc Error\n");
exit(84);
}
}
int word\_count = 0;
int l = 0;
for (int i = 0; buffer[i] != '\0' && buffer[i] != '\n'; i++, l++) {
if (buffer[i] == delimiter) {
words[word\_count][l] = '\0';
word\_count++;
l = -1;
}
else
words[word\_count][l] = buffer[i];
}
words[word\_count][l] = '\0';
return (words);
}
int main()
{
char \*buffer = malloc(sizeof(char) \* 100);
buffer = "hello world !\n";
char \*\*words = get\_words(buffer, ' ');
printf("words[0]= %s\n", words[0]);
free (buffer);
char \*\*reply = get\_words("Second call\n", ' ');
printf("reply[0] = %s\n", reply[0]);
}
```
Таких вопросов достаточно на Stack Overflow. И часто на них отвечают медленно и неохотно. Это обоснованно. Согласитесь, не хочется изучать достаточно большой текст программы только ради того, чтобы найти какую-то скучную ошибку. Эти ошибки, как правило, связаны с ещё недостаточным знанием языка, и ответ, скорее всего, сведётся к совету прочитать определённый раздел книги или документации.
Это не снобизм со стороны более опытных разработчиков. Им просто не очень интересно тратить время на то, чтобы разбираться, что не так с лабораторными работами.
Вернёмся к вопросу на Stack Overflow, про который я говорил выше. Вопрос висел уже пару дней, а ответа всё нет. Как человеку продвинуться дальше?
Одним из помощников в обучении программированию может стать статический анализатор. Это программа, которая выполняет [code review](https://pvs-studio.com/ru/blog/terms/0073/) и сообщает о подозрительных участках кода. Статические анализаторы не заменяют практику обзора кода, выполняемого коллегой, но хорошо дополняют его и позволяют находить многие ошибки на самом раннем этапе.
[Запустим](https://godbolt.org/z/svdEPrW8n) online-версию анализатора PVS-Studio для приведённого в вопросе кода. Первым интересным и важным предупреждением является сообщение: [V1031](https://pvs-studio.com/ru/docs/warnings/v1031/) The 'malloc' function is not declared. Passing data to or from this function can be affected.
Без объявления функции *malloc* программа уже работает непонятным образом. В языке Си считается, что если функция не объявлена, то она возвращает *int*. А на самом деле это указатель. Чем это опасно, рассказано в заметке "[Красивая 64-битная ошибка на языке Си](https://pvs-studio.com/ru/blog/posts/cpp/0033/)". Исправим эту проблему, добавив *#include* .
Теперь [вывод анализатора](https://godbolt.org/z/ehqsaeMqW) изменится, и мы видим следующую серьёзную проблему: 43:1: note: V773 The 'buffer' pointer was assigned values twice without releasing the memory. A memory leak is possible.
Ошибка здесь:
```
char *buffer = malloc(sizeof(char) * 100);
buffer = "hello world !\n";
....
free (buffer);
```
Значение указателя перетирается. Чтобы скопировать строку в буфер, нужно использовать специальные функции, например *[strcpy](https://en.cppreference.com/w/c/string/byte/strcpy)*. Внесём исправления.
[Исправленный код](https://godbolt.org/z/Kar998xbv):
```
#include
#include
#include
#include
#include
#include
char \*\*get\_words(char \*buffer, char delimiter)
{
printf("buffer = %s\n", buffer);
char \*\*words = malloc(sizeof(char \*) \* 100);
if (words == NULL) {
printf("Malloc Error\n");
exit(84);
}
for (int i = 0; i < 100; i++) {
words[i] = malloc(sizeof(char) \* 100);
if (words[i] == NULL) {
printf("Malloc Error\n");
exit(84);
}
}
int word\_count = 0;
int l = 0;
for (int i = 0; buffer[i] != '\0' && buffer[i] != '\n'; i++, l++) {
if (buffer[i] == delimiter) {
words[word\_count][l] = '\0';
word\_count++;
l = -1;
}
else
words[word\_count][l] = buffer[i];
}
words[word\_count][l] = '\0';
return (words);
}
int main()
{
char \*buffer = malloc(sizeof(char) \* 100);
if (buffer == NULL)
exit(84);
strcpy(buffer, "hello world !\n");
char \*\*words = get\_words(buffer, ' ');
printf("words[0]= %s\n", words[0]);
free (buffer);
char \*\*reply = get\_words("Second call\n", ' ');
printf("reply[0] = %s\n", reply[0]);
}
```
Этот код ещё нельзя назвать красивым и безопасным, но он работает. Так что такой способ поиска ошибок вполне может помочь в процессе обучения.
**Дополнительные ссылки:**
1. [Статический анализ кода](https://pvs-studio.com/ru/blog/terms/0046/).
2. PVS-Studio: [online версия](https://pvs-studio.com/ru/pvs-studio/godbolt/).
3. PVS-Studio: [бесплатное использование для студентов](https://pvs-studio.com/ru/order/for-students/).
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. ["Why doesn't my code work?" — to anyone learning the art of programming and writing to the Stack Overflow community](https://pvs-studio.com/en/blog/posts/cpp/0959/). | https://habr.com/ru/post/673788/ | null | ru | null |
# Drupal Composer рецепты
В этом посте мы хотим поделиться некоторыми рецептами использования Composer, которые мы накопили работая с Drupal проектами созданными с помощью Drupal Composer template. Так же мы рассмотрим как перевести существующий Drupal проект на Composer.
Если вы до сих пор не используете [Composer](https://getcomposer.org/) в Drupal проектах, вы должны начать делать это прямо сейчас! [Drupal Composer template](https://github.com/drupal-composer/drupal-project) поможет с справиться с этой задачей. [Создать новый проект](https://github.com/drupal-composer/drupal-project#usage) — очень просто.
Если вы до сих пор не уверенны, взгляните на преимущества Drupal Composer разработки:
* Нет необходимости хранить код контриб модулей (и само ядро!) в вашей системе контроля версий.
* Единый инструмент управления пакетами для всего: ядро Drupal, контриб модули, JS библиотеки, ваши собственные модули используемые в разных проектах, и т.д.
* Максимально простой и удобный патчинг ядра и модулей.
* Это гораздо проще использования [Git submodules](https://habrahabr.ru/post/164019/).
(Все рецепты подразумевают использование Drupal 8, но они так же должны работать и для Drupal 7)
Установка контриб модулей
-------------------------
* `composer require drupal/:~8.0` что бы установить последний стабильный релиз (или последнюю dev версию, если релизов для Drupal 8 пока нет)
* `composer require drupal/:dev-` что бы установить последнюю dev версию
* `composer require drupal/:dev-#` что бы установить конкретную версию
Обновление ядра Drupal и модулей
--------------------------------
* `composer update` что бы обновить всё
* `composer update --dry-run` что бы проверить обновления
* `composer update drupal/` что бы обновить конкретный модуль
Патчинг пакетов
---------------
Плагин [cweagans/composer-patches](https://github.com/cweagans/composer-patches) (входящий в состав Drupal Composer template) использует патчи описаные в секции «extra» файла composer.json:
```
"extra": {
"patches": {
"": {
"": "",
...
},
...
}
}
```
Пример:
```
"extra": {
"patches": {
"drupal/core": {
"Fix language detection": "patches/2189267-24.patch"
}
}
}
```
После того как патч добавлен, запустите:
* `composer install` что бы применить патч
* `composer update nothing` (или `composer update --lock`) что бы composer-patches плагин сделал необходимые изменения в файле composer.lock
Установка кастомных/форкнутых модулей с Github
----------------------------------------------
#### Если репозиторий модуля содержит собственный composer.json файл
Зарегистрируйте репозиторий в секции «repositories» файла composer.json:
```
"repositories": [
{
"type": "vcs",
"url": "https://github.com/"
},
...
],
```
Используйте `composer require drupal/:dev-#` что бы установить модуль.
#### Если файл composer.json отсутствует в репозитории модуля
Используйте чуть более расширенный вариант:
```
"repositories": [
{
"type": "package",
"package": {
"name": "drupal/",
"version": "dev-custom",
"type": "drupal-module",
"source": {
"type": "git",
"url": "git@github.com:.git",
"reference": ""
}
}
},
...
],
```
Используйте `composer require drupal/:dev-custom#` что бы установить модуль.
#### Если целевая директория должна отличаться от modules/contrib
В дополнение к вышеприведённым рецептам, используйте composer/installers плагин:
```
"extra": {
"installer-paths": {
"web/modules/custom/": ["drupal/"],
...
}
}
```
Установка JS библиотеки
-----------------------
Популярные JS библиотеки могут быть с лёгкостью установлены с помощью Composer, так как они (скорее всего) уже существуют в репозитории [Packagist](https://packagist.org/). Сложность заключается в том что большинство Drupal модулей требуют установки JS библиотек в директорию «libraries», в то время как Composer устанавливает их в директорию «vendor».
Плагин composer/installers может переназначать путь установки, но только для тех пакетов которые указывают его как зависимость. Таким образом, вам нужно подменить файл composer.json библиотеки, указав в нём зависимость от composer/installers.
Взглянем на пример:
```
"repositories": [
{
"type": "package",
"package": {
"name": "enyo/dropzone",
"version": "4.3",
"type": "drupal-library",
"source": {
"url": "https://github.com/enyo/dropzone.git",
"type": "git",
"reference": "master"
},
"dist": {
"url": "https://github.com/enyo/dropzone/archive/v4.3.0.zip",
"type": "zip"
},
"require": {
"composer/installers": "~1.0"
}
}
},
...
],
...
"extra": {
"installer-paths": {
"web/libraries/{$name}" : ["type:drupal-library"],
...
}
}
```
После того как этот код добавлен в composer.json, запустите `composer require enyo/dropzone:4.3` что бы установить библиотеку. Заметьте что мы указали конкретную версию и добавили секцию «dist» что бы Composer мог загрузить zip архив вместо клонирования репозитория.
Переключаем существующий пакет на форкнутую версию
--------------------------------------------------
Зарегистрируете форк-репозиторий в composer.json:
```
"repositories": [
{
"type": "vcs",
"url": "https://github.com/"
},
...
],
```
Запустите `composer require :dev-#`
Переключаем существующий Drupal 8 project на Composer
-----------------------------------------------------
* Сделайте бекап ;)
* Удалите всё чем будет управлять Composer: директорию «core» Drupal, контриб модули, и т.д.
* Удалите все корневые Drupal файлы, такие как index.php, update.php, README.txt… Все их.
* Создайте директорию «web» в корне проекта и переместите туда все оставшиеся Drupal директории (sites, modules, themes, libraries, profiles, и т.д.)
* Скопируйте файлы [Drupal Composer template](https://github.com/drupal-composer/drupal-project) в корень проекта.
* Приготовьте список версий контриб модулей используемых в проекте, ядра Drupal и всего остального чем будет управлять Composer. Затем запустите `composer require` указывая конкретную версию для каждой зависимости. Вам понадобится перевести Drupal версии в Composer версии, вот несколько примеров:
+ `drupal/core:8.1.8` тут всё сходится
+ `drupal/admin_toolbar:8.1.15` поразумевает admin\_toolbar 8.x-1.15
+ `drupal/ctools:8.3.0-alpha26` поразумевает ctools 8.x-3.0-alpha26
+ `drupal/config_installer:dev-8.x-1.x#a16cc9acf84dd12b9714def53be0ce280a5b0c1a` поразумевает dev версию config\_installer созданную из коммита a16cc9a бранча 8.x-1.x
* В секции «require» файла composer.json измените версии ядра Drupal и контрибных модулей на "~8.0". Это сделает возможным будущие обновления.
* Запустите `composer drupal-scaffold`, это создаст необходимые корневые Drupal файлы.
* Убедитесь что ваш веб-сервер использует диркторию «web» в качестве web root. | https://habr.com/ru/post/313298/ | null | ru | null |
# Мои размышления про экранную клавиатуру для Flipper Zero под экранчик 128х64 пикселя
Недавно я увидел пост с [приглашением разработчиков](https://habr.com/ru/post/514326/) в проект Flipper Zero и подал заявку. Меня добавили в репозиторий с прошивкой и я стал много думать над юзабилити устройства. Приснилось, что мне надо отсканировать кучу ключей-брелков от разных подъездов. Во сне были разные люди, квартиры, дождь, и почему-то мне дали целую горсть этих желтых кругляшей, отличающихся друг от друга только количеством грязи на них. И естественно, чтобы как-то совладать с этим беспорядком, я решил внести все эти ключи во Flipper Zero.
Прямо во сне, я заносил новые идентификаторы и все они добавлялись в менюшку как «Ключ», что делало действо еще бессмысленней. Получился большой список, состоящий только из слова «Ключ». Подумалось, что надо переписать прошивку. И тут как раз преимущество сна — все задуманное сбывается одномоментно. Ключи стали добавляться с рандомным суффиксом как «Ключ 74», а следом за ним мог добавиться «Ключ 22». Номер именно рандомный, не путать с контрольными суммами или хешами. В принципе, если есть хорошая память, то можно запомнить, что «Ключ 22» от Ленина 54, а «Ключ 74» от Пушкина 29. Подумалось, что неплохо бы как-то редактировать номера, прямо на Флиппере, прямо в списке ключей: у нас же свободны кнопки влево-вправо, пусть они инкрементируют/декрементируют номер! А длинное удержание вызовет вызов полноценной клавиатуры! Но стоп, какую клавиатуру рисовать? Стандартную Qwerty с переключением на Йцукен? Русифицированную Яверты? У нас же экран всего 128х64 пикселя, к тому же в него надо как-то запихнуть еще вывод набираемого! Как все это уместить? Неужели вводить текст Азбукой Морзе?
Примитивная клавиатура
----------------------
Сказать, что набирать что-либо на такой клавиатуре удобно — явно нельзя. Что быстро — тоже. Простота и большой набор символов — это единственное, что тут можно получить, а в остальном же от такой клавиатуры хочется бежать и не оглядываться. Удивительно, но в прошлом подобный метод ввода был весьма распространен.
Qwerty
------
Так, а что, если взять стандартную клавиатурку от Андроида, применить эффект линзы и посмотреть, что из этого выйдет? 10 часов в Афтер Эффектсе и вот оно:
У меня был скрипт, который конвертирует графику в CGA-палитру, после обработки получилось такое:
Мне это понравилось, и даже понравились полутона. СТОП. На Флиппере же чернобелый экран! Но зато он обладает энерционностью, а значит можно получить полутона, быстро включая/выключая пиксели. Пришлось изобретать свой вариант дизеринга. В процессе был изобретен Дизеринг Курильщика:
Это вариация дизеринга Баера и немного модифицированной матрицы распределения ошибок Билла Аткинсона. После некоторой отладки и исправления 9000 ошибок, получилось такое:
Не сказать, что этот вариант мне нравится сильно больше, зато на LCD-экранчике оно должно выглядеть лучше, особенно хорошо должны получиться полутона за счет постоянного вращения матриц. Пока что я не получил свой Флиппер, так что проверить на деле это не могу, но в теории должно выглядеть хорошо.
Хм, а если постараться и нарисовать как можно более маленькую клавиатурку?
В принципе, получилось неплохо. Все вмещается, если захотеть. Опционально можно припилить клавишу RUSLAT, как и много других полезных клавиш. Но каких? Залезть в стандарт HID и натырить оттуда клавиши «кофе» и «красная кнопка»?
Раскладка
---------
Стандартная раскладка QWERTY имеет следующие особенности:
1. Предназначена для печатающих машинок, подразумевающие ручной ввод (двух рук)
2. Предполагается смена рук при наборе текста. Пока одна рука нажимает клавишу, вторая рука готовится к нажатию. Однако, многие слова английского языка могут быть набраны только на левой части клавиатуры.
3. Диагональное расположение клавиш ведет свою историю от физического расположения рычагов на печатающей машинке
Следующие слова приписываются Августу Двораку, создателю “клавиатуры Дворака”, альтернативы QWERTY:
> Можно, не прилагая особых усилий, создать десятки клавиатурных раскладок, которые будут по крайней мере не хуже, чем универсальная клавиатура Шоулза. Если буквы и символы из трёх нижних рядов клавиатуры Шоулза перемешать и расставить случайным образом, то чаще всего получится более удобная клавиатурная раскладка, при которой нагрузка на руки и отдельные пальцы будет распределена более равномерно. При этом станет меньше слов, набираемых лишь одной рукой, и будет меньше сложноосуществимых последовательностей нажатий буквенных клавиш, чем при работе на упомянутой выше универсальной клавиатуре Шоулза.
Но так получилось, что ни Дворак, ни его приемник, Колемак, так и не завоевали популярности.
Но вернемся к Флипперу. У нас есть на нем рычаги? Можно ли использовать сразу 2 руки для набора текста? Имеет ли смысл чередовать руки? Хотим ли мы более эффективно задействовать мизинцы, как это рекламирует автор Колемак? Нужна ли нам совместимость с популярными Windows-хоткеями, такими как CTRL+C/CTRL+V? Ответ на все эти вопросы: НЕТ. Вывод: надо изобретать свою раскладку, так как QWERTY не отвечает нашим задачам и целям.
Шарики
------
Я взял пару статей из википедии, скопировал из них текст и посчитал уникальные символы, вот они:
`!$%&'(),-./01234567
89:;?ABCDEFGHIJKLM
NOPQRSTUVWXYZ[]a
bcdefghijklmnopqrstu
vwxyz|£¥«°²»àéœ́АБВ
ГДЕЖЗИЙКЛМНОПРС
ТУФХЦЧШЭЮЯабвгде
жзийклмнопрстуфхцч
шщъыьэюяё—’“„…№
↑▲`
Забавно, но тут нету символа двойной кавычки ", зато есть «ёлочки».
Я попробовал визуализировать частоту использования каждой буквы, но сразу пришлось применить логарифмическую шкалу, чтобы хоть что-то разглядеть:
Давайте подумаем, как расположить эти символы на экране, чтобы пользователю было удобнее их вводить?
Самая первая идея: посчитать частоту использования той или иной буквы вместе с соседями. И использовав эти данные, запустить симулятор «Шариков», где между шариками есть некоторая сила притяжения, равная частоте использования этих букв по соседству.
Первый опыт был таким:
Тут мало что можно разглядеть, но если приглядеться, то можно увидеть, как кириллица и латиница образовали между собой кластеры, практически не связанные между собой, а из пробела вылетают малоиспользуемые символы.
После 9000 часов отладки и боли, была сделана более приятная глазу симуляция:
К моему разочарованию, символы сильно мешают друг другу двигаться. Я попробовал поиграться с силой притяжения, менял ее динамически, даже устраивал ручные «вихри», но ничего не помогало.
Тут уже видно, что хотя кластеры уже по большей части сформированы, но в них присутствуют инородные элементы. Надо придумать какой-то другой способ расстановки клавиш…
С другой стороны, если положить это все в диаграмму Вороного…
Выглядит очень круто! Хм, да с такой клавиатуркой можно будет даже оставить Флиппера и начать производство собственных реальных клавиатур! Правда, кому еще нужны клавиатуры для 1-пальцевого ввода? Что мне писать на кикстартере? Пойду плакать в подушку над очередным своим бесполезным изобретением.
Генетика
--------
Ладно, поплакав, я продолжил свои изыскания. За основу я взял прототип [китайской клавиатурки](https://en.wikipedia.org/wiki/Chinese_input_methods_for_computers):
А именно, я взял матрицу 16х16 знакомест и насыпал туда набор символов в случайном порядке. Вообще, по началу я хотел их как-то красиво упаковать, использовав частотные данные о соседних символах, в голове проносились аналоги деревьев Хаффмана, но ничего толкового я родить так и не смог. Потому просто расположил клавиши в центре, располагая их по спирали от центральной ячейки. В последствии, я еще начал их перемешивать, так что мытарства с деревьями Хаффмана были излишни.
А дальше я просто запустил простой генетический поиск: делал набор для мутаций, отбирал лучшие (см.далее), делал их родителями следующих поколений. И так пока не зависнет, т.е. не упрется в эволюционную яму.
**Было много экспериментов:**
* Сначала я переставлял 2 соседние клавиши местами, а в конце выяснил, что лучше передвигать клавишу по всему полю
* Количество мутаций в одном поколении варьировал от 30 до 3000. Выяснил, что пусть лучше рожает чаще и чаще дохнет, для эволюции это полезней — остановился на 30.
* Мутировать за раз лучше как можно меньше, таким образом оно сможет более точно подстраиваться на последних этапах, когда все будет почти закончено.
* Эволюционная яма наступает не сразу, а где-то за 5к итераций до того, как станет очевидной
* Если уперлись в яму и долго не можем найти новых улучшений, то лучше все бросить и начать с нуля, может быть в этот раз эволюция пойдет лучшим путем. Из-за этого в результатах есть досадные недостатки в виде пары клавиш, которые присутствуют не в своих кластерах
Далее я считал, насколько эффективной оказалась та или иная мутация. Пришлось изобрести свою систему оценки. Для этого я взял текст из Википедии, и сделал что-то вроде симулятора процесса набора текста. Виртуальная клавиатура 16х16, виртуальный джойстик, виртуальный текст. В конце симуляции я смотрел, сколько понадобилось нажатий, чтобы набрать этот текст. Это и был рейтинг эффективности. Если количество нажатий было меньше, чем в других вариациях мутации, и тем более до переставления клавиш, то значит эта «мутация» оказывалась лучше и она использовалась для продолжения обсчета. Получилось в итоге такое:
Местами мне очень нравится получившийся numpad, местами кириллица и латиница образовали некоторое подобие «Инь и Янь», почти везде символы доллара, евро и фунтов находятся рядом, как и символ процента. Номер слева означает, сколько раз надо будет нажать на кнопки джойстика, чтобы набрать тестовый текст. Возможно, если бы я запустил симулятор на недельку, то были бы более интересные варианты, но у меня старенький компьютер для таких экспериментов. А внимательный читатель найдет еще и полупасхалку-полубагу: почти на всех вариантах раскладки присутствует слово KFC, так как обучалось оно на статье про KFC и каких-то теннисисток.
В принципе, меня подмывает взять и переставить некоторые клавиши руками, особенно кириллическую Й, которая вечно оказывается около латиницы, или же латинскую Х, которая порой бывает среди кириллицы, а символы равномерно распределить кругом или ссыпать в кучку, но… А что ответит эволюция на это? Насколько эффективным будет такая перестановка? Да, писать интерактивную переставлялку мне было лень. Но оно и к лучшему: теперь я знаю, что даже для кириллицы/латиницы может быть несколько раскладок, а пользователь уж пускай сам выбирает, что ему лучше.
Если интересны другие варианты раскладок, которые сгенерировались за время обсчета, то посмотрите файлы [anon.fm/articles/flipper-keyboard/layouts.html](https://anon.fm/articles/flipper-keyboard/layouts.html) и [anon.fm/articles/flipper-keyboard/layouts-more.html](https://anon.fm/articles/flipper-keyboard/layouts-more.html)
Можно экспериментировать достаточно долго, вот идеи для опытов:
1. Заворачивание краев пространства друг на друга. Т.е. это не курсор двигается по клавиатуре, а клавиатура двигается, причем по мере ухода в одну сторону экрана, она появляется с другой стороны.
2. Отказ от двумерного пространства и заворачивание плоскости в какой-то трехмерный объект, скажем натягивание на глобус или же еще какую геометрическую фигуру. Возможностей зацикливания пространства становится больше.
3. Добавление частоиспользуемых символов в нескольких экземляров. К примеру, почему бы не сделать десяток пробелов? Вот в Колемаке есть 2 бекспейса, только в нашем случае умножать стоит скорее пробел.
4. Добавление частоиспользуемых буквосочетаний, на манер дерева Хаффмана, где длинные последовательности заменяются короткими. В нашем случае — частые последовательности букв заменяются одинарными нажатиями
5. Динамическое подставление символов, предугадывая дальнеший набор текста, как это сделано в Dasher
Если кто не знает про Dasher, то бегом сюда: [f-droid.org/en/packages/dasher.android](https://f-droid.org/en/packages/dasher.android/) — тут все про наш девайс и даже более: ввод текста с джойстиков, трекболов, мышек, глазных трекеров и прочих одноручных, однопальцевых и носимых устройств. Интерфейс может быть запущен хоть в разрешении 32х32 пикселя, и это без потерь для юзабилити. Работало на Pocket PC и пережило долгие годы! Но, как бы я не фанател от этой штуки, не смотря на большой выбор опций, я так и не научился этим пользоваться, ощущая при этом удобство, поэтому для меня это скорее технодемка возможностей, возможности взаимодействия с машиной. Если кто-то хочет портировать Dasher, то милости просим, патчи до сих пор приходят в репозиторий регулярно, думаю будет много желающих, увидеть такую штуку на своем Флиппере.
Сюда же можно занести разнообразные варианты аккордовых клавиатур, или же экранных клавиатур времен Palm, таких как MessagEase. Идея, лежащая в MessagEase замечательная, но проблема в том, что зажатие 2-х кнопок лично для меня неприемлемо, потому лично я превращать Флиппера в аккордовую клавиатуру не буду. Но я уверен, что настоящий хакерский девайс не сможет выжить без аккордовой клавиатуры, потому ее наверняка добавит кто-то еще.
Подводя итог: вариантов клавиатуры может быть великое множество. Но я должен не только представлять, как это должно быть, но еще и реализовать все описанное выше. Так что, если есть желающие — можете попробовать, а мне работать надо.
Реализация
----------
А в следующей части мы попробуем реализовать все задуманное. Мы напишем небольшой эмулятор и попробуем изобрести API.
Напоследок, вот вам еще несколько анимаций с концептами клавиатурки:
Клавиатурка, натянутая на то, что в Максе зовется Torus Knot:
А это, попытка натянуть сову на глобус^W^W^Wклавиатурку на сферу. Тут я немного поэкспериментировал с дизерингом, и к Дизерингу Курильщика у меня добавился еще и Дизеринг Эпилептика.
Аналогично предыдущему, только для CGA.
UPD: я совсем забыл прикрепить исходники всего этого безобразия. Они кому-нибудь интересны? | https://habr.com/ru/post/517014/ | null | ru | null |
# B+ дерево в реальном проекте
В этой статье мы подробно рассмотрим, как сделано B+ дерево в распределенной БД [Apache Ignite](https://github.com/apache/ignite).
На Хабре уже есть пара статей о B-деревьях ([раз](https://habrahabr.ru/post/337594/), [два](https://habrahabr.ru/post/114154/)), но они скорее теоретические и даже если и содержат реализацию, то не [production ready](https://softwareengineering.stackexchange.com/questions/61726/define-production-ready). От того и возникает интерес поглядеть на реализацию, которую используют в жизни.
Прежде чем читать статью дальше, советую посмотреть [лекцию Максима Бабенко](https://youtu.be/KFcpDTpoixo), если вы ещё не знаете, что такое B-дерево в теории. А вот глубоко знать Java или проект Apache Ignite не нужно — детали я либо напишу явно, либо спрячу под спойлерами.
При чтении исходников Ignite советую пропускать в уме аргументы методов, смысл которых не очень понятен и вчитываться в имена функций — читать тело функции намного проще, если заранее знать, что она делает.
Учтите, что я не являюсь ведущим разработчиком Apache Ignite и что-то мог неверно понять из кода. Так что за скобки я выношу фразу "на сколько я понял", которую следует мысленно добавить перед каждым утвердительным предложением.
Зачем B+ дерево в Apache Ignite
===============================
Apache Ignite это in memory БД, однако с версии 2.1 у неё появился [persistent data store](https://habrahabr.ru/company/gridgain/blog/335294/) — функционал сохранения данных на диск *(не имеет ничего общего с [persistent data structure](https://en.wikipedia.org/wiki/Persistent_data_structure))*. Поэтому понятно зачем нужна структура для внешней памяти, осталось разобраться, почему не выбрали другую.
Начнём с того, что B+ дерево — это оптимизация B-дерева, где значения хранятся только в листьях. В этой оптимизации больше ключей умещается в узел, что увеличивает степень ветвления. Поэтому резона использовать классическое B-дерево не много.
[B\*](https://ru.wikipedia.org/wiki/B*-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) и B+\* — плотнее лежат на диске, но у них хуже производительность, а т.к. мы храним данные из оперативной памяти, нам важнее производительность.
[LSM-дерево](https://ru.wikipedia.org/wiki/LSM-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) судя по [бенчмаркам](https://github.com/wiredtiger/wiredtiger/wiki/Btree-vs-LSM) быстрее на запись, но медленнее на чтение. Причем потери на чтении больше, чем выигрыш на записи, поэтому для гипотетического общего случая я бы тоже взял B+ дерево.
Есть ещё диковинные [фрактальные деревья](https://en.wikipedia.org/wiki/Fractal_tree_index), однако они, по всей видимости, запатентованы и реализованы только в [TokuDB](https://en.wikipedia.org/wiki/TokuDB).
Лично меня больше интересует, почему нельзя было взять готовый дисковый бекенд, вроде [LevelDB](https://habrahabr.ru/post/256207/)? Частичный ответ заключается в том, что PDS поддерживает сторонние хранилища.
Реализация в крупную клетку
===========================
Изначально компания GridGain разработала Apache Ignite, но до ухода в open-source он носил имя компании, поэтому имена некоторых компонентов начинаются с `Grid`, а других с `Ignite`. Поэтому `GridCursor`, но `IgniteTree`. Иной логики здесь нет.
Код Apache Ignite написан по лекалам Java best practices и каждый класс наследует интерфейс, а то и не один. От интерфейса `IgniteTree` и начнём пляску. Привожу код без javadoc, для краткости.
```
public interface IgniteTree {
public T put(T val) throws IgniteCheckedException;
public void invoke(L key, Object x, InvokeClosure c) throws IgniteCheckedException;
public T findOne(L key) throws IgniteCheckedException;
public GridCursor find(L lower, L upper) throws IgniteCheckedException;
public GridCursor find(L lower, L upper, Object x) throws IgniteCheckedException;
public T findFirst() throws IgniteCheckedException;
public T findLast() throws IgniteCheckedException;
public T remove(L key) throws IgniteCheckedException;
public long size() throws IgniteCheckedException;
interface InvokeClosure {
void call(@Nullable T row) throws IgniteCheckedException;
T newRow();
OperationType operationType();
}
enum OperationType {
NOOP,
REMOVE,
PUT
}
}
```
Интерфейс `IgniteTree` описывает стандартный набор операций. Обратите внимание, что наличие поиска по диапазону требует провязать листья в список. Бонусом поддерживается произвольная операция над записью — `invoke`.
Операция `put` принимает лишь один аргумент типа `T` без ключа. Вы не найдете объяснения этому в `IgniteTree`, однако ответ скрывается в заголовке `BPlusTree`.
```
public abstract class BPlusTree extends DataStructure implements IgniteTree
```
Как видите, значение наследует ключ, поэтому в операции put ключ вычисляют из значения. Это не ограничивает функционал дерева. Мое предположение, что так компактнее хранить set-ы.
Обычно из map делают set с помощью подкладывания в значение мусорной константы. Однако, в B+ дереве в узлах хранят *только ключи*, если же значение хранит ещё и ключ, то в листьях достаточно хранить *только значения*. А если дерево представляет собой set, тогда автоматически получится, что в листьях будут только ключи без мусорных значений.
Теперь посмотрим на код поиска элемента.
```
/**
* @param g Get.
* @throws IgniteCheckedException If failed.
*/
private void doFind(Get g) throws IgniteCheckedException {
for (;;) { // Go down with retries.
g.init();
switch (findDown(g, g.rootId, 0L, g.rootLvl)) {
case RETRY:
case RETRY_ROOT:
checkInterrupted();
continue;
default:
return;
}
}
}
/**
* @param g Get.
* @param pageId Page ID.
* @param fwdId Expected forward page ID.
* @param lvl Level.
* @return Result code.
* @throws IgniteCheckedException If failed.
*/
private Result findDown(final Get g, final long pageId, final long fwdId, final int lvl)
throws IgniteCheckedException {
long page = acquirePage(pageId);
try {
for (;;) {
// Init args.
g.pageId = pageId;
g.fwdId = fwdId;
Result res = read(pageId, page, search, g, lvl, RETRY);
switch (res) {
case GO_DOWN:
case GO_DOWN_X:
assert g.pageId != pageId;
assert g.fwdId != fwdId || fwdId == 0;
// Go down recursively.
res = findDown(g, g.pageId, g.fwdId, lvl - 1);
switch (res) {
case RETRY:
checkInterrupted();
continue; // The child page got split, need to reread our page.
default:
return res;
}
case NOT_FOUND:
assert lvl == 0 : lvl;
g.row = null; // Mark not found result.
return res;
default:
return res;
}
}
}
finally {
if (g.canRelease(pageId, lvl))
releasePage(pageId, page);
}
}
```
Основа алгоритма обхода B-дерева осталась без изменений: рекурсивно спускаются по дереву до нужного листа: если значение присутствует, то возвращают результат, а если нет — то `null`. Рекурсию видимо оставили для удобства, все равно B-деревья не глубокие.
Я удивился, так как в голове была четкая установка: в реальном проекте рекурсию всегда убирают ([в Java нет оптимизации хвостовой рекурсии](https://habrahabr.ru/post/319282/), в проектах на других языках рекурсия допустима). Но действительно, высота B-дерева измеряется единицами, ведь размер блока порядка , а число данных порядка  и того высота будет .
В Apache Ignite [любят concurrency](https://youtu.be/t0psp84lyms). Поэтому дерево поддерживает конкурентную модификацию. На момент операции одна страница блокируется, однако другой поток может модифицировать остальную часть дерева так, что потребуется повторное чтение. Причем так процедура может дойти до корня.
Я сперва не понял смысла такого функционала, ведь диск медленный и один поток спокойно обработает все операции ввода-вывода. Понятно, что поиск в загруженном с диска узле сколько-то стоит и за это время можно нагрузить диск другой операцией, но повторные попытки съедят выигрыш. Однако потом до меня дошло, что в этой реализации узлы не сразу сбрасываются на диск после модификации, а некоторое время висят в памяти, чтобы затем применить сразу множество модификаций. Данные не потеряются благодаря Write Ahead Log. Подробнее о нем будет в конце статьи.
Теперь посмотрим код добавления элемента.
```
private T doPut(T row, boolean needOld) throws IgniteCheckedException {
checkDestroyed();
Put p = new Put(row, needOld);
try {
for (;;) { // Go down with retries.
p.init();
Result res = putDown(p, p.rootId, 0L, p.rootLvl);
switch (res) {
case RETRY:
case RETRY_ROOT:
checkInterrupted();
continue;
case FOUND:
// We may need to insert split key into upper level here.
if (!p.isFinished()) {
// It must be impossible to have an insert higher than the current root,
// because we are making decision about creating new root while keeping
// write lock on current root, so it can't concurrently change.
assert p.btmLvl <= getRootLevel();
checkInterrupted();
continue;
}
return p.oldRow;
default:
throw new IllegalStateException("Result: " + res);
}
}
}
catch (IgniteCheckedException e) {
throw new IgniteCheckedException("Runtime failure on row: " + row, e);
}
catch (RuntimeException e) {
throw new IgniteException("Runtime failure on row: " + row, e);
}
catch (AssertionError e) {
throw new AssertionError("Assertion error on row: " + row, e);
}
finally {
checkDestroyed();
}
}
/**
* @param p Put.
* @param pageId Page ID.
* @param fwdId Expected forward page ID.
* @param lvl Level.
* @return Result code.
* @throws IgniteCheckedException If failed.
*/
private Result putDown(final Put p, final long pageId, final long fwdId, final int lvl)
throws IgniteCheckedException {
assert lvl >= 0 : lvl;
final long page = acquirePage(pageId);
try {
for (;;) {
// Init args.
p.pageId = pageId;
p.fwdId = fwdId;
Result res = read(pageId, page, search, p, lvl, RETRY);
switch (res) {
case GO_DOWN:
case GO_DOWN_X:
assert lvl > 0 : lvl;
assert p.pageId != pageId;
assert p.fwdId != fwdId || fwdId == 0;
res = p.tryReplaceInner(pageId, page, fwdId, lvl);
if (res != RETRY) // Go down recursively.
res = putDown(p, p.pageId, p.fwdId, lvl - 1);
if (res == RETRY_ROOT || p.isFinished())
return res;
if (res == RETRY)
checkInterrupted();
continue; // We have to insert split row to this level or it is a retry.
case FOUND: // Do replace.
assert lvl == 0 : "This replace can happen only at the bottom level.";
return p.tryReplace(pageId, page, fwdId, lvl);
case NOT_FOUND: // Do insert.
assert lvl == p.btmLvl : "must insert at the bottom level";
assert p.needReplaceInner == FALSE : p.needReplaceInner + " " + lvl;
return p.tryInsert(pageId, page, fwdId, lvl);
default:
return res;
}
}
}
finally {
if (p.canRelease(pageId, lvl))
releasePage(pageId, page);
}
}
```
Разница только в том, что после обнаружения позиции код разветвляется на `replace` и `insert`. Код `remove` можно уже не смотреть. Базовый механизм заключается в том, чтобы с повторными попытками пройтись рекурсивно по дереву вместе со специальным объектом в зависимости от операции: `Get`, `Put` или `Remove`.
`Invoke` работает таким же образом, только операция происходит с копией записи, потом определяется её тип: `NOOP` — для чтения, `REMOVE` — для удаления и `PUT` для обновления или добавления, и затем генерируется соответствующий объект `Put` или `Remove`, который применяется к записи в дереве.
Использование
=============
Ниже я подробно рассмотрю два наследника `BPlusTree`: `CacheDataTree` и `PendingEntriesTree`. За бортом остается реализация индексов — это тема для отдельной дискуссии, к которой я пока не готов.
Прежде чем идти дальше, уточню, что местный распределенный map имеет функционал вытеснения и называется `IgniteCache` — далее просто кеш.
`CacheDataTree`
---------------
`CacheDataTree` — это отображение нескольких `IgniteCache` на диск. Сортировка многоуровневая: сперва сортируют по id кеша, чтобы сгруппировать ключи в одном кеше, а потом по хешам.
`CacheDataTree` не итерируют по диапазону, так как индексы реализованы в наследниках `H2Tree extends BPlusTree`, поэтому конкретный вид сортировки не важен: для операций `put` и `get` хватит любой. Сравнивать же хеши быстрее, чем объекты. Но куда важнее то, что равномерный хеш плотнее заполнит дерево.
Деревья балансируют, чтобы они не выродились в список. Но если добавлять равномерно распределенные ключи в дерево поиска, оно автоматически окажется сбалансированным. Поскольку B-деревья запускают процедуру балансировки по мере возникновения проблем, а хеши равномерно перемешивают ключи, то сортировка по хешам уменьшает частоту балансировки.
Использование хешей в дереве поиска не такая странная идея как кажется, её логическое развитие приведет к [Hash array mapped trie](https://habr.com/post/266861/).
`PendingEntriesTree`
--------------------
`PendingEntriesTree` хранит ключи для данных со временем жизни и используется как set. Сортировка многоуровневая: сперва сортируют по id кеша, чтобы сгруппировать ключи в одном кеше, а затем по времени жизни. Далее идет ещё один раунд сравнения — судя по всему, чисто технический, чтобы различать элементы. По сортировке легко догадаться, что используется этот класс для поиска диапазонов. Это дерево дублирует ключи записей в кеше для вытеснения.
Понять, как это работает отдельное приключение.
**Приключение**В `IgniteCacheOffheapManagerImpl.expire()` берут курсор и удаляют записи из `PendingEntriesTree`. Записи в `CacheDataTree` удаляют в замыкании `c`, который передают в параметрах.
```
@Override public boolean expire(
GridCacheContext cctx,
IgniteInClosure2X c,
int amount
)
```
Apache Ignite только недавно прекратил поддержку Java 7, поэтому замыкание создают через анонимный класс.
```
private final IgniteInClosure2X expireC =
new IgniteInClosure2X() {
@Override public void applyx(GridCacheEntryEx entry, GridCacheVersion obsoleteVer) {
boolean touch = !entry.isNear();
while (true) {
try {
if (log.isTraceEnabled())
log.trace("Trying to remove expired entry from cache: " + entry);
if (entry.onTtlExpired(obsoleteVer))
touch = false;
break;
}
catch (GridCacheEntryRemovedException ignore) {
entry = entry.context().cache().entryEx(entry.key());
touch = true;
}
}
if (touch)
entry.context().evicts().touch(entry, null);
}
};
```
То, что мы ищем находится в методе `GridCacheMapEntry.onTtlExpired()`, где в блоке `finally` лежит заветная строчка.
```
cctx.cache().removeEntry(this);
```
Детали реализации
=================
Работа со страницами в Offheap
------------------------------
[Offheap](https://habrahabr.ru/company/odnoklassniki/blog/148139/) — техника оптимизации ручного управления памятью в языке со сборщиком мусора.
Это миф, что из-за сборщика мусора все тормозит, обычно коллекторы стоят [жалкие проценты производительности](https://plumbr.io/blog/garbage-collection/gc-impact-on-throughput-and-latency). Даже большие кучи сами по себе не проблема, т.к. коллекторы работают конкурентно (например [CMS и G1](https://habrahabr.ru/post/269863/) в Java), а у серверов [десятки ядер](https://en.wikipedia.org/wiki/Xeon_Phi). Конечно, сборщик добавляет непредсказуемых пауз в работу приложения, что важно для игр, но терпимо для базы данных.
Но вот что на самом деле будет проблемой, так это нарушение гипотезы о поколениях на большой куче.
**Гипотезы о поколениях**Оптимизации GC используют гипотезу о поколениях. Эта гипотеза существует в двух версиях: сильной и слабой.
**Слабая гипотеза о поколениях:** большинство объектов умирают молодыми.
**Сильная гипотеза о поколениях:** чем старше объект, тем дольше он проживёт.
Из сильной гипотезы следует слабая, но не наоборот. В идеале GC должен довольствоваться выполнением слабой гипотезы, однако на практике это не так.
Посмотрите доклады Алексея Шипилева о новом GC в Java, если хотите лучше разобраться в теме: [раз](https://youtu.be/ZYiQCHxgABI) и [два](https://youtu.be/EgsA9cMVf9Q?t=7h27m57s).
И тут такое дело, что до появления PDS Apache Ignite позиционировался главным образом как кэш между сервисами и дисковой БД (например [Hadoop](https://www.gridgain.com/solutions/database-performance/hadoop-acceleration)). Потому мапы в Ignite называются `IgniteCache` и имеют соответствующий функционал вытеснения. А кеши как раз нарушают гипотезу о поколениях — в них вероятность удаления объекта растет со временем жизни. Потому-то в этом случае Offheap для хранения пользовательских данных улучшает производительность.
Ещё бонусы:
* В offheap проще реализовать структуры вмещающие больше чем `Integer.MAX_VALUE` элементов.
* [Если держать кучу меньше 32ГБ, то ссылки будут весить 4 байта](https://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html), что экономит несколько гигабайт.
* Так как коллектор строит граф объектов он потребляет память пропорционально их числу. А число объектов пропорционально кучи. Так же коллектор потребляет CPU, которое лучше потратить на сжатие данных например.
* На очень больших кучах, даже если гипотеза о поколениях не нарушается в целом, все равно найдется достаточно много по абсолютной величине старых объектов, которые будут её нарушать.
Поскольку данные потом отправятся на диск, то объекты сериализуют в память напрямую через `unsafe`, а затем эту область памяти используют под буфер ввода-вывода.
Write Ahead Log
---------------
[Write Ahead Log](http://postgresql.ru.net/manual/wal-intro.html) это журнал операций с линейной структурой, добавление в него стоит константу в отличии от дерева. Дерево обновляют реже, а если данные потеряются из-за падения, то их восстанавливают из лога применяя операции начиная с последнего сохраненного состояния. В результате улучшается производительность без ущерба надежности. Советую взглянуть на интерфейс `IgniteWriteAheadLogManager` — там подробная документация.
Обход узла
----------
Поскольку узлы в B-деревьях не маленькие их обходят бинарным поиском. Для этого используют потомков класса `BPlusTree.GetPageHandler`, причем для разных операций разные.
**Реализация бинарного поиска**
```
private int findInsertionPoint(int lvl, BPlusIO io, long buf, int low, int cnt, L row, int shift)
throws IgniteCheckedException {
assert row != null;
int high = cnt - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int cmp = compare(lvl, io, buf, mid, row);
if (cmp == 0)
cmp = -shift; // We need to fix the case when search row matches multiple data rows.
//noinspection Duplicates
if (cmp < 0)
low = mid + 1;
else if (cmp > 0)
high = mid - 1;
else
return mid; // Found.
}
return -(low + 1); // Not found.
}
```
Метод `compare` разный для разных потомков `BPlusTree`. Через отрицательный индекс кодируют отсутствие элемента с позицией, где он мог бы быть. Так же делает `Collections.binarySearch` из стандартной библиотеки.
Обратите внимание на следующие строки.
```
if (cmp == 0)
cmp = -shift;
```
Для операции `findOne`, этот код ничего не делает, т.к. `shift` ставится в ноль, т.е. если в дереве лежат одинаковые ключи, то найдут произвольный из них.
Однако, если так искать диапазон, то потеряются элементы, поэтому там `shift` ставится в `1`. В результате поиск *не находит элемент даже если он там есть*, но для поиска диапазона это не важно.
Список листов
-------------
Чтобы обходить диапазон эффективно, листы провязывают в список. В качестве результата поиска возвращают `BPlusTree.ForwardCursor`, который ходит от листа к листу. Судя по всему, проход по курсору не изолирован от других операций в дереве, т.к. при проходе блокировка берется только на одну страницу. Механизма синхронизации, который защищает доступ к методам курсора, я не обнаружил.
Заключение
==========
Поскольку B+ дерева в Apache Ignite молодое по сравнению с другими реляционными БД, получаем необходимый набор для production ready B+ дерева:
* **WAL** дает дешевую безопасность, в результате дерево редко обновляют на диске.
* **Offheap** с данными в сериализованном виде.
* **Concurrency** — для загруженных в память частей дерева. | https://habr.com/ru/post/413749/ | null | ru | null |
# Настоящий Unix — не есть приемлемый Unix
Командная строка Unix полна сюрпризов. Например, вы знали, что инструмент `ls`, который чаще всего используется для получения списка файлов в текущем каталоге, в версии OS X распознаёт не менее [38 разных флагов](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/ls.1.html)?
Я не знал, так что [затвитил](https://twitter.com/rtraschke/status/585933203183165441) этот факт. И получил парочку ответов, [один из которых](https://twitter.com/rtraschke/status/585933203183165441) заставил меня задуматься: действительно ли саму Unix нужно винить в этом?
Насколько я знаю, ни Linux, ни OS X не были спроектированы в строгом соответствии с [философией Unix](http://en.wikipedia.org/wiki/Unix_philosophy). Будет лицемерием основывать критику “Unix” только на этих производных от Unix, которые есть у нас сегодня.
Но я всё-таки попробую показать, как много проблем с интерфейсами командной строки в современных наследниках Unix восходят к корням самой Unix. В частности, я попытаюсь объяснить свой скепсис относительно идеи, что окружение командной строки Unix могло *когда-либо* поддерживать экосистему программ, каждая из которых хорошо выполняет одну функцию.
Но я немного опережаю события. Прежде чем я начну говорить об этом, давайте более пристально посмотрим на команду `ls` и попробуем выяснить, что конкретно она делает не так.
Много всего, но слабо
=====================
Разные версии `ls` распознают разные наборы флагов, но в целом эти флаги можно распределить по нескольким широким категориям. Пользователи `ls` применяют флаги, чтобы:
* **Определить формат выдачи**. `−C` упорядочивает записи в аккуратную сетку; `−m` выдаёт разделённый запятыми «поток» записей; `−1` выдаёт каждую запись в своей собственной строке; `−q` заменяет непечатаемые символы в названиях файлов вопросительными знаками.
* **Отобразить дополнительную информацию о каждом файле**. `−F` добавляет символы к названиям каталогов (`/`), исполняемым файлам (`*`), симлинкам (`@`) и другим «особым» типам файлов; `−s` выдаёт размер каждого файла рядом с его именем.
* **Изменить порядок файлов**. `−r` для списка в обратном порядке; `−t` для списка файлов по времени последнего изменения.
* **Включить или исключить определённые файлы**. `−a` включает в список файлы, скрытые по умолчанию; `−R` показывает рекурсивный список файлов в подкаталогах текущего каталога.
Если опустить первую категорию флагов, то в остальных трёх есть кое-что интересное. Знатоки функционального программирования, в частности, могут увидеть в них нечто знакомое.
Так и есть — каждая из этих трёх категорий примерно соответствует единственной общей функции высшего порядка, которая работает с последовательностями!
* Флаги для *отображения дополнительной информации о каждом файле* можно выразить в терминах `map`, которая применяет заданную трансформацию на каждый элемент в последовательности независимо от других.
* Флаги для *изменения порядка файлов* можно выразить в терминах `sort`, которая использует заданное условие для попарного сравнения элементов и соответствующей сортировки.
* Флаги для *включения и исключения определённых файлов* можно выразить в терминах `filter`, которая проверяет каждый элемент относительно заданного утверждения и отклоняет те, что признаны неподходящими.
`ls` кажется раздутой, потому что она *действительно* раздутая. Ряд функций высшего порядка могут взять на себя бóльшую часть функциональности, которая сейчас втиснута в `ls` в виде флагов.
Что пошло не так?
=================
Идея того, что каждая программа должна вмещать в себе самодостаточную единицу функциональности, ни в коем случае не нова. Десятилетиями сторонники Unix превозносили достоинства конвейеров: «программ», созданных на лету соединением маленьких компонуемых фильтров друг за другом. В таком случае как можно объяснить эволюцию настолько концептуально простого инструмента как `ls` в сторону всё возрастающей сложности?
Экстремальная скупость командной строки Unix подсказывает одно возможное объяснение. Когда Unix изобрели, максимальная ширина экрана ограничивалась примерно 80 символами, а использование компьютера означало сидеть перед терминалом и набирать команды на клавиатуре. В таком окружении имело смысл пожертвовать удобочитаемостью и компонуемостью, чтобы втиснуть больше информации в минимально возможное количество символов.
В ту эпоху авторы самых популярных утилит сильно склонялись к тому, чтобы создавать сокращения везде, где только возможно. `ls` называется `ls` по той же самой причине, по которой её флаги представляют собой зашифрованные руны из одного символа вместо осмысленных слов или, не дай бог, целых фраз: она была разработана для небольшой группы узкоспециализированных экспертов в среде, где каждое нажатие клавиши, каждый символ на экране имел реальную и выразительную цену.
Аналогично и сами флаги являются сокращениями для наиболее общих сценариев реального использования. Зачем тратить время и добавлять шаг фильтрации к конвейеру, чтобы исключить скрытые файлы из выдачи, если 90% времени всё равно никто не хочет видеть скрытые файлы? Зачем отображать всю информацию о каждом файле, если 90% времени пользователю нужны только имена?
Такой образ мышления — что нажатия имеют высокую цену и что должны быть сокращения абсолютно для всего — определил многие из проблем `ls` и окружения командной строки Unix в целом.
«Универсальный интерфейс»
=========================
Но почему не написать более простую альтернативу `ls` — функцию, которая берёт произвольный каталог, или рабочий каталог по умолчанию, и возвращает список файлов из него, не обращая внимания на флаги? В конце концов, хакнуть Unix проще чем что-либо другое: если вам не нравится `ls`, можете заменить её.
Отвечу на этот вопрос гипотезой. Представьте язык программирования, в котором каждая функция принимает в точности один аргумент (строку) и возвращает в точности один результат (другую строку).
Ой, посмотрите — такой язык существует, и он называется шелл.
Unix позволяет программам общаться друг с другом и с пользователем исключительно через потоки символов. Вы не можете написать функцию, которая возвращает список файлов, потому что шелл не знает, что такое «список», не знает, что такое «файлы» и не сможет сказать вам разницу между «функцией» и «программой», даже если от этого будет зависеть его жизнь.
Программы не «принимают аргументы» и не «возвращают значения», они читают символы из `stdin` и печатают символы в `stdout`!
> *Пишите программы для обработки текстовых потоков, потому что это универсальный интерфейс.*
>
> Дуглас Макилрой, «[Проектирование программ в среде UNIX](http://harmful.cat-v.org/cat-v/unix_prog_design.pdf)»
Изначальные архитекторы Unix рассматривали «простоту» текстовых потоков как преимущество. Поэтому они отказывались накладывать любую структуру на данные, которые передаются между программами. Это решение, призванное избежать ненужной сложности, вместо этого просто перенесло излишнюю сложность дальше вниз по течению.
Помните первую категорию флагов `ls` — те флаги, которые мы не могли выдать за сокращения стандартных трансформаций последовательности? Выходит, что это просто сокращения для неформального кодирования условных *списков файлов* в виде строк, которые определённые другие программы (или, в некоторых случаях, человеческие существа) знают, как парсить.
Система неспособна предоставить абстракции, нужные пользователям. В ответ пользователи [изобретают их заново](http://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule), скудными, непоследовательными и не в тех местах. Это удручающе обычная практика.
Неприемлемый Unix
=================
Знание истории информатики и ограничений, в которых формировались текущие ментальные модели, дарует нам своеобразную суперсилу: мы можем определить, когда необходимый прежде компромисс стал нелепым и устарел.
Многие проблемы юзабилити, которые поднял Дон Норман в своей [критике Unix](http://www.ceri.memphis.edu/people/smalley/ESCI7205F2009/misc_files/The_truth_about_Unix_cleaned.pdf) 1981 года, остались практически без изменений до настоящего времени. В качестве подарка мы разработали графические интерфейсы, которые держат «обычных пользователей» в стороне от командной строки, но по-прежнему предполагается, что «серьёзные разработчики» опустятся в явно негуманную среду, чтобы сделать там нечто осмысленное.
Вместо переоценки командной строки Unix с прицелом на улучшение юзабилити, когда современное оборудование уже не так ограничивает интерфейс, мы написали [эмуляторы терминала](http://www.secretgeometry.com/apps/cathode/), которые добросовестно воспроизводят ограничения середины 1970-х. Мы требуем от новых альтернативных оболочек [совместимости с sh](http://unix.stackexchange.com/questions/145522/what-does-it-mean-to-be-sh-compatible) и слепо верим, что [иерархические файловые системы](https://www.usenix.org/legacy/event/hotos09/tech/full_papers/seltzer/seltzer.pdf) — оптимальный способ организации информации.
Каковы шансы, что 40 лет назад мы как-то натолкнулись на лучший возможный интерфейс взаимодействия с компьютером? Другими словами, каковы шансы, что наши действия сегодня имеют смысл?
Даже самая ранняя версия Unix была только частной, имеющий недостатки реализацией философии Unix. Если мы хотим поощрить более широкое распространение *философии*, то не стóит защищать *реализацию*, преуменьшая её недостатки. Вместо этого нужно прямо взяться за эти недостатки. Строить системы, которые устраняют их, в то же время придерживаясь духа — если не буквы — принципов, на которых построен Unix. | https://habr.com/ru/post/326176/ | null | ru | null |
# Тест производительности: удивительно и просто
Так сложилось, что последние полгода я активно занимался тестами производительности и мне кажется, что в этой области IT царит абсолютное непонимание происходящего. В наше время, когда рост вычислительных мощностей снизился (vertical scalability), а объем задач растет с прежней скоростью, проблема производительности становится всё острее. Но прежде, чем броситься на борьбу с производительностью, необходимо получить количественную характеристику.
Краткое содержание статьи:
* [Простейший тест](#SimpleTest): способы измерения теста, выбор статистики (квантили, медиана, среднее).
* [Параметризованный тест](#ParameterTest): оценка сложности алгоритма, применения МНК к оценки линейности теста.
* [Тесты на многоядерных машинах](#CoreTest): сложность экстраполяции результатов тестов на многоядерные машины, закон Амдала и целесообразность измерений.
* [Поведенческий тест](#BehaviorTest): каким, при заданной модели поведения пользователей, будет время ожидание запроса и что может привести к коллапсу системы. Пропускная способность (throughput) и как его считать.
* [Удивительное статическое распределение](#TestDistribution) результатов performance теста.
### Предыстория
Однажды, путешествуя в поезде, я захотел посчитать, каково расстояние между столбами электропередач. Вооружившись обычными часами и оценивая среднюю скорость поезда 80-100км/ч (25 м/с), я засекал время между 2-мя столбами. Как ни странно, этот наивный метод давал очень удручающие результат, вплоть до 1.5-2 кратной разницы. Естественно метод несложно было исправить, что я и сделал, достаточно было засечь 1 минуту и посчитать количество столбов. И не важно, что мгновенная скорость на протяжении минуты может варьироваться и даже не важно посчитаем мы последний столб или минута истечет посередине, потому как измерений вполне достаточно для требуемого результата.
Смысл теста в том, чтобы получить убедительные для себя и для других измерения.
##### Тесты «на коленке»
Эта история мне напоминает то, что происходит с тестированием производительности в Software Engineering. Достаточно частое явление — запуск 1-2 тестов, построение графиков и получение выводов о scalability системы. Даже, если есть возможность применить МНК или узнать стандартную ошибку, это не делается за «ненадобностью.» Особенно интересная ситуация, когда после этих 2 измерений, люди обсуждают насколько быстрая система, как она масштабируется и сравнивают её с другими системами по личным ощущениям.
Конечно, оценить, насколько быстро выполняется команда, не сложно. С другой стороны, быстрее не значит лучше. Системы ПО имеют свыше 10 различных параметров, от hardware на котором они работают до input, которые вводит пользователь в разные моменты времени. И зачастую 2 эквивалентных алгоритма могут давать совершенно разные параметры масштабируемости в разных условиях, что делает выбор совсем не очевидным.
##### Недоверие к тестам
С другой стороны результаты измерений всегда остаются источником спекуляций и недоверий.
— Вчера мы меряли было X, а сегодня 1.1\*X. Кто-то что-то менял? — 10% — это нормально, у нас теперь больше записей в БД.
— При проведении теста был отключен антивирус, скайп, анимация заставки?
— Не-не, для нормальных тестов нам надо закупить кластер серверов, установить микросекундную синхронизацию времени между ними… удалить ОС, запускать в защищенном режиме…
— Сколько пользователей мы поддерживаем? У нас 5000 зарегистрированных пользователей, вдруг 20% из них залогинится, надо запускать тесты с 1000 параллельными агентами.
##### Что же нам делать?
Во-первых, стоит признать, что железо, которое мы имеем, у нас уже есть и надо получить максимум результатов именно на нём. Другой вопрос, как мы сможем объяснить поведение на других машинах (production/quality testing). Те кто ратует, за эксперименты «чистой комнаты», попросту вам не доверяют, так как вы не даете достаточно объяснений или данных, «чистая комната» — это иллюзия.
Во-вторых, самое главное преимущество в тестировании программ — это дешевизна тестов. Если бы физики могли провести 100 тестов упрощенной ситуации вместо 5 полноценных, они бы точно выбрали 100 (и для проверки результатов 5 полноценных :) ). Ни в коем случае, нельзя лишаться дешевизны тестов, запускайте их у себя, у коллеги, на сервере, утром и в обед. Не поддавайтесь соблазну «реальных» часовых тестов с тысячами пользователей, важнее понимать, как ведет себя система, нежели знать пару абсолютных чисел.
В-третьих, храните результаты. Ценность тестов представляют сами измерения, а не выводы. Выводы гораздо чаще бывают неправильными, чем сами измерения.
Итак, **наша задача** провести достаточное число тестов, для того, чтобы **прогнозировать** поведение системы в той или иной ситуации.
### Простейший тест
Сразу оговоримся, что мы рассматриваем систему как «черный ящик». Так как системы могут работать под виртуальной машиной, с использованием БД и без, не имеет смысла расчленять систему и брать измерения в середине (обычно это приводит к неучтенным важным моментам). Зато если есть возможность тестировать систему, в разных конфигурация это обязательно следует делать.
Для тестирования, даже простого теста, лучше иметь независимую систему как JMeter, которая может подсчитать результаты, усреднить. Конечно, настройка система требует время, а хочется получить результат гораздо быстрее и мы пишем что-то такое.
```
long t = - System.currentTimeMillis();
int count = 100;
while (count -- > 0) operation();
long time = (t + System.currentTimeMillis()) / 100;
```
##### Запись результата измерения
Запустив один раз мы получаем число X. Запускаем еще раз получаем 1.5\*X, 2 \*X, 0.7\*X. На самом деле тут можно и нужно остановиться, если мы делаем временный замер и нам не надо вставлять это число в отчет. Если же мы хотим поделиться этим числом с кем-то, нам важно, чтобы оно сходилось с другими измерениями и не вызывало подозрений.
Первым «логичным» шагом кажется положить числа X и усреднить их, но, на самом деле, усреднение средних ни что иное, как увеличение count для одного теста. Как ни странно увеличение count может привести к еще более не стабильным результатам, особенно если вы будете запускать тест и делать что-то одновременно.
##### Минимальное время исполнения как лучшая статистика
Проблема в том, что **среднее** является не стабильной характеристикой, одного заваленного теста, выполнявшегося в 10 раз дольше, будет достаточно, чтобы ваши результаты не совпадали с другими. Как не парадоксально для простых performance тестов желательно брать **минимальное время исполнения** . Естественно operation() должна быть измеряемая в данном контектсе, обычно 100 мс — 500 мс для системы более, чем достаточно. Конечно, минимальное время не будет 1 к 1 совпадать с наблюдаемым эффектом или с реальным, но это число будет сравнимо с другими измерениями.
##### Квантили
Квантили 10%, 50% (медиана), 90% являются более стабильными, чем среднее, и гораздо информативнее. Мы можем узнать с какой вероятностью запрос будет выполняться время 0.5\*X или 0.7\*X. С ними есть другая проблема, посчитать квантили на коленке гораздо сложнее чем взять min, max.
JMeter предоставляет измерение медианы и 90% в Aggregate Report из коробки, чем естественно следует пользоваться.
### Параметризованный тест
В результате измерений мы получаем некоторое число (медиану, минимум или другое), но что мы можем сказать о нашей системе (функции) по одному числу? Представьте вы автоматизируете процесс получения этого числа и каждый день вы будете его проверять, когда вам надо бить тревогу и искать виноватых? К примеру, вот типичный график один и тот же тест каждый день.
**Скрытый текст**
Если мы захотим написать отчет производительности, с одним числом он будет выглядеть пусто. Поэтому мы обязательно протестируем для разных параметров. Тесты для разных параметров дадут нам красивый график и представление о scalability системы.
##### Тест с одним параметром
Рассмотрим систему с одним числовым параметром. Прежде всего необходимо выбрать значения параметров. Не имеет смысла выбирать числа из разных диапазонов, как [1, 100, 10000], вы попросту проводите 3 абсолютно разных несвязных теста и найти зависимость на таких числах будет невозможно. Представьте вы хотите построить график, какие числа вы бы выбрали? Что-то похожее на [X\*1, X \* 2, X\*3, X\*4,X\*5, ].
Итак выбираем 5-10 (7 лучшее) контрольных точек, для каждой точки проводим 3-7 измерений, берем минимальное число для каждой точки и строим график.
##### Сложность алгоритма
Как можно заметить точки располагаются аккурат вокруг мнимой прямой линии. Теперь мы подходим к самой интересной части измерений, мы можем определить **сложность алгоритма** исходя из измерений. Определение сложности алгоритма на основании тестов гораздо проще для сложных программ, чем анализ текста исходных программ. При помощи теста можно даже найти специальные точки, когда сложность меняется, например, запуск Full GC.
Определение сложности программы по результатам теста является прямой задачей **[Регрессионного анализа](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7)**. Очевидно, что не существует общего способа нахождения функции только по точке, поэтому для начала делается предположение о некоторой зависимости, а затем оно проверяется. В нашем случае и в большинстве других, мы предполагаем что функцией является линейная зависимость.
##### Метод наименьших квадратов (линейная модель)
Для поиска коэффициентов линейной зависимости имеется простой и оптимальный метод [МНК](http://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BD%D0%B0%D0%B8%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BE%D0%B2). Преимущество этого метода в том, что формулы можно запрограммировать в 10 строчек и они абсолютно понятны.
```
y = a + bx
a = ([xy] - b[x])/[x^2]
b = ([y] - a[x])/ n
```
Представим наши вычисления в таблице.
В выделенная строчке мы видим линейный коэффициент нашей модели, он равняется 95.54, свободный коэффициент 2688. Теперь мы можем проделать простой, но не очевидный фокус, мы можем придать значение этим числам. 95.54 измеряется в миллисекундах (как и наши измерения), 95.54 — время которое мы тратим, на каждую компоненту, а 2688 мс время, которое мы тратим на саму систему, не зависит от количества компонент. Данный метод позволил нам выделить достаточно точно время внешней системы, в данном случае БД, хотя оно в десятки раз превышает время 1-й компоненты. Если бы мы пользовались формулой Time\_with\_N\_component/N нам бы пришлось замерять для N>1000, чтобы погрешность оказалась меньше 10%.
Линейный коэффициент модели является самым важным числом нашего измерения и как ни странно он является самым стабильным числом наших измерений. Так же линейный коэффициент позволяет адекватно измерить и интерпретировать операции, которые происходят за наносекунды, причем отделив overhead самой системы.
На графике результаты независимых запусков теста в разное время, что подтверждает большую стабильность линейного коэффициента, чем отдельно взятых тестов.
##### Оценка линейности модели и коэффициент Пирсона
Используя график мы можем наглядно увидеть, что наши измерения действительно удовлетворяют линейной модели, но этот метод далеко не точный и мы не можем его автоматизировать. В этом случае нам может помочь [коэффициент Пирсона](http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D0%BA%D0%BE%D1%80%D1%80%D0%B5%D0%BB%D1%8F%D1%86%D0%B8%D0%B8_%D0%9F%D0%B8%D1%80%D1%81%D0%BE%D0%BD%D0%B0). Этот метод действительно показывает отклонения от прямой линии, но для 5-10 измерений его явно недостаточно. Ниже приведен пример, явно не линейной зависимости, но коэффициент Пирсона достаточно высок.
Возвращаясь к нашей таблице, зная overhead системы (свободный коэффициент) мы можем посчитать линейный коэффициент для каждого измерения, что в таблице и сделано. Как мы видим числа (100, 101, 93, 96, 102, 81, 94, 100, 93, 98) — достаточно случайно распределены около 95, что и дает нам весомые основания полагать, что зависимость линейная. Следуя букве математике, на самом деле отклонения от средней величины должны удовлетворять нормальному распределения, а для проверки нормального распределения достаточно проверить критерий Колмогорова-Смирнова, но это мы оставим для искушенных тестировщиков.
Как это ни странно, не все зависимости являются линейными. Первое, что приходит на ум, это квадратичная зависимость. На самом деле квадратичная зависимость очень опасна, она убивает performance сначала медленно, а затем очень быстро. Даже если у вас для 1000 элементов все выполняется за доли секунды, то для 10000 это уже будут десятки секунд (умножается на 100). Другим примером, является сортировка, которая не может быть решена за линейное время. Посчитаем насколько применим метод линейной анализа для алгоритмов со сложность O(n\*log n)
```
(10n log 10n )/ (n log n)= 10 + (10*log 10)/(log n)
```
То есть для n >= 1000, отклонение будет в пределах 10%, что существенно, но в некоторых случаях может применяться, особенно если коэффициент при log достаточно большой.
Рассмотрим пример нелинейной зависимости.
**Нелинейная сложность алгоритма**
Первое, что следует отметить, отрицательный overhead, по очевидным причинам система не может иметь отрицательное время затрачиваемое на подготовку. Второе, глядя на колонку коэффициентов, можно заметить закономерность, линейный коэффициент падает, а затем растет. Это напоминает график параболы.
##### Тест с двумя и большим числом параметров
Естественно, что большинство систем не состоят из одного параметра. К примеру, программа чтения из таблицы уже состоит из 2-х параметров, колонок и строк. Используя параметризованные тесты, мы можем посчитать каковы затраты на чтение строки из 100 колонок (пусть 100мс) и каковы затраты на чтение колонки для 100 строк (пусть 150мс). 100\*100мс != 100\*150мс и это не парадокс, просто мы не учитываем, что в скорости чтения строк уже заложен overhead чтения 100 колонок. То есть 100мс/100 колонок= 1мс — это не скорость чтения одной ячейки! На самом деле 2-х измерений будет недостаточно для расчета скорости чтения одной ячейки. Общая формула такова, где A — затраты на одну ячейку, B — на одну строчку, C — на колонку:
`Time(row, column) = A * row * column + B * row + C * column + Overhead`
Составим систему уравнений, учитывая имеющиеся значения и еще одно необходимое измерение:
```
Time(row, 100) = 100 * A * row + B * row + o = 100 * row + o.
Time(row, 50) = 50 * A * row + B * row + o = 60 * row + o.
Time(100, column) = 100 * B * column + C * column + o = 150 * column + o.
100 * A + B = 100.
50 * A + B = 55.
100 * B + C = 150.
```
Отсюда, получаем A = 0.9 мс, B = 10 мс, C = 50 мс.
Конечно, имея формулу на подобие ЛМНК для данного случая, все расчеты бы упростились и автоматизировались. В общем случае, к нам не применим общий ЛМНК, потому как функция, которая линейная по каждому из аргументов, отнюдь не многомерная линейная функция (гиперплоскость в N-1 пространстве). Возможно воспользоваться градиентным методом нахождения коэффициентов, но это уже не будет аналитический способ.
### Многопользовательские тесты и тесты многоядерных систем
##### Миф «throughput per core»
Одним из любимых занятий с performance тестами является экстраполяция. Особенно люди любят экстраполировать в ту область, для которых они не могут получить значений. К примеру, имея в системе 2 ядра или 1 ядро, хочется проэкстраполировать как бы система вела себя с 10 ядрами. И конечно же первое неверное допущение в том, что зависимость линейна. Для нормального определения линейной зависимости необходимо от 5 точек, что конечно же невозможно получить на 2х ядрах.
##### Закон Амдала
Одним из самых близких приближений является **[закон Амдала](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%90%D0%BC%D0%B4%D0%B0%D0%BB%D0%B0)**.
Он основан на расчете процента паралеллизируемого кода α ( вне блока синхронизации) и синхронизируемоего кода (1 — α). Если один процесс занимает время T на одном ядре, тогда при множественных запущенных задачах N время будет T' = T\*α + (1-α)\*N\*T. В среднем конечно же N/2, но Amdahl допускает N. Параллельное ускорение соответственно S = N\*T/T' = N / (α + (1-α)\*N)=1 / (α/N + (1- α)).
Конечно же, приведенный выше график, не настолько драматичен в реальности (там ведь логарифмическая шкала по X). Однако существенным недостатком блоков синхронизации, является асимптота. Условно говоря, не возможно наращивая мощность преодолеть предел ускорения lim S= 1 / (1- α). И этот предел достаточно жесткий, то есть для 10% синхронизированного кода, предел 10, для 5% (что очень хорошо) предел 20.
Функция имеет предел, но она постоянно растет, из этого возникает, странная на первый взгляд, задача: оценить какое hardware оптимально для нашего алгоритма. В реальности увеличить процент параллизированного бывает достаточно сложно. Вернемся к формуле T' = T\*α + (1-α)\*N\*T, оптимальным с точки зрения эффективности: если ядро будет простаивать, столько же времени сколько и будет работать. То есть T\*α=(1-α)\*N\*T, отсюда получаем N =
α/(1-α). Для 10% — 9 ядер, для 5% — 19 ядер.
##### Связь количества пользователей и количества ядер. Идеальный график.
Модель ускорения вычислений является теоретически возможной, но не всегда реальной. Рассмотрим ситуацию клиент-сервер, когда N клиентов постоянно запускают некоторую задачу на сервере, одной за одной, и мы не испытываем никаких затрат на синхронизацию результатов, так как клиенты полностью не зависимы! Ведение статистики к примеру вводит элемент синхронизации. Имея M-ядерную машину, мы ожидаем, что среднее время запроса T когда N < M одинаково, а когда N > M время запроса растет пропорционально количеству ядер и пользователей. Посчитаем throughput как количество запросов обрабатываемых в секунду и получим следующие «идеальный» график.
**Идеальные графики**
##### Экспериментальные измерения
Естественно идеальные графики достижимы, если мы имеем 0% synchronized блоков (критических секций). Ниже приведены реальные измерения одного алгоритма с разными значения параметра.
Мы можем рассчитать линейный коэффициент и построить график. Так же имея машину с 8 ядрами, можно провести серию экспериментов для 2, 4, 8 ядер. Из результатов тестов можно заметить, что система с 4 ядрами и 4 пользователями ведет себя точно так же как система с 8 ядрами и 4 пользователям. Конечно, это было ожидаемо, и дает нам возможность проводить только одну серию тестов для машины с максимальным количеством ядер.
**Экспериментальные измерения, используя линейный коэффициент**
Графики измерений близки по значениям к закону Амдала, но все-таки существенно отличается. Имея измерения для 1, 2, 4, 8 ядер, можно рассчитать количество непараллезируемоего кода по формуле
Где NP — количество ядер, SU = Throughpt NP core / Throughput 1 core. Согласно закону Амдала это число должно быть постоянным, но во всех измерениях это число падает, хотя и не значительно (91% — 85%).
График throughput per core не всегда представляет собой непрерывную линию. К примеру, при нехватке памяти или при работе GC отклонения в throughput могут быть очень значительными.
**Значительные колебания throughput при Full GC**
### Поведенческий тест
##### Throughput
При измерениях нагрузки многопользовательских систем мы ввели определение **Throughput = NumberOfConcurrentUsers / AverageTimeResponse**. Для интерпретации результатов Throughput — это пропускная способность системы, какое количество пользователей система может обслужить в момент времени, и это определение тесно связано с [теорией массового обслуживания](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BC%D0%B0%D1%81%D1%81%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D1%81%D0%BB%D1%83%D0%B6%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F). Сложность измерения throughput заключается в том, что значение зависит от входного потока. К примеру, в системах массового обслуживания, предполагается, что время ожидания ответа не зависит от того, сколько заявок находится в очереди. В простой программной реализации, без очереди заявок, время между всеми потоками будет делиться и соответственно система будет деградировать. Важно заметить, что не стоит доверять **JMeter** измерениям throughput, было замечено, что Jmeter усредняет throughput между всеми шагами теста, что является не правильным.
Рассмотрим, следующий случай: при нагрузке с 1 пользователем, система выдает Throughput = 10, при 2-х — Throughput=5. Такая ситуация вполне возможна, так как типичный график Throughput/User — эта функция которая имеет один локальный (и глобальный максимум).
Следовательно, при входящем потоке 1 пользователь каждые 125мс, система будет обрабатывать 8 пользователей в секунду (входной throughput).
При входящем потоке 2 пользователя каждые 125мс система начнет коллапсировать, так как 8 (входной throughput) > 5 (возможного throughput).
##### Коллапсирующая система
Рассмотрим пример коллапсирующей системы подробнее. После проведения теста Throughput/Users у нас есть следующие результаты.
Users — количество пользователей одновременных в системе, Progress per user — какое количество работы в процентах пользователь выполняет за одну секунду. Мысленно сэмулируем ситуацию, что каждую секунду приходит 10 пользователей и начинают выполнять одну и ту же операцию, вопрос, сможет ли система обслуживать данный поток.
За 1 секунду 10 пользователей в среднем выполнят только 20% своей работы, исходя из предположения, что в среднем они выполняют всю за 5. На 2-й секунде в системе уже будет 20 пользователей и они будут разделять ресурсы между 20 потоками, что еще уменьшит процент выполняемой работы. Продолжим ряд до того, момент когда первые 10 пользователей закончат работу (теоретически они ее должны закончить так как ряд 1/2 + 1/3 + 1/4… расходящийся).
Достаточно очевидно, что система сколлапсирует, так как через 80 секунд в системе будет 800 пользователей, а в этом момент смогут закончить только первые 10 пользователей.
Данный тест показывает, что при любом распределении входящего потока, если входящий throughput (математическое ожидание) больше максимального
измеряемого throughput для системы, система начнет деградировать и при постоянной нагрузке упадет. Но обратное неверно, в 1-м примере максимальный измеряемый throughput (=10) > входящего (8), но система также не сможет справиться.
##### Система в стационарном режиме
Интересным случаем является работоспособная система. Взяв за основу наши измерения, проведем тест, что каждые 1 секунду приходят 2 новых пользователя. Так как минимальное время ответа превышает секунду, то поначалу количество пользователей будет накапливаться.
Как мы видим система войдет в стационарный режим именно в той точке, графика когда измеряемый throughput совпадает с входным throughput. Количество пользователей в системе в среднем будет 10.
Из этого можно сделать вывод, что график Throughput/Users с одной стороны представляет количество обрабатываемых пользователей в секунду (throughput) и количество пользователей в системе (users). Падения графика справа от этой точки характеризует только стабильность системы в стрессовых ситуациях и зависимость от характера входящего распределения. В любом случае, проводя тесты Throughput/Users, будет совсем не лишним провести behavioral test с приблизительным характеристиками.
### Удивительное распределение
При проведении тестов производительности практически всегда есть измерения занимающие гораздо больше времени, чем ожидалось. Если время тестирования достаточно велико, то можно наблюдать следующую картину. Как из этих всех измерений выбрать одно число?
##### Выбор статистики
Самой простой статистикой является среднее, но по указанным выше причинам она не совсем стабильна, особенно для малого количества измерений. Для определения квантилей удобно воспользоваться графиком функции распределения. Благодаря замечательному [JMeter плагину](https://code.google.com/p/jmeter-plugins/) у нас есть такая возможность. После первых 10-15 измерений обычно картина недостаточно ясная, поэтому для детального изучения функции потребуется от 100 измерений.
**Первые измерения**
Получить N-квантиль из данного графика очень просто, достаточно взять значение функции в данной точки. Функция показывает достаточно странно поведение вокруг минимума, но дальше растет вполне стабильно и только возле 95% квантиля начинается резкий подъем.
##### Распределение?
Является ли данное распределение аналитическим или известным? Для этого можно построить график плотности распределения и попытаться посмотреть известные функции, к счастью их не так [много](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9).
Честно говоря этот метод не принес никаких результатов, на первый взгляд похожие функции распределения: Бета распределение, распределение Максквелла, оказались достаточно далеки от статистик.
##### Минимум и экспоненциальное распределение
Важно отметить, что область значений нашей случайной величины отнюдь не [0, +∞ [, а некоторое [Min, +∞[. Мы не можем ожидать, что программа может выполниться быстрее, чем теоретический минимум. Если предположить, что измеряемый минимум сходится к теоретическому и вычесть это число из всех статистик, то можно наблютать достаточно интересную закономерность.
Оказывается Minimum + StdDev = Mean (Average), причем это характерно для всех измерений. Есть одно известное распределение у которого, математические ожидание совпадает с дисперсией (variance), это экспоненциальное распределение. Хотя график плотности распределения отличается в начале области определения, основные квантили вполне совпадают. Вполне возможно случайная величина является суммой экспоненциального распределения и нормального, что вполне объясняет колебания вокруг точки теоретического минимума.
##### Дисперсия и среднее
К сожалению, мне не удалось найти теоретического обоснования, почему результаты тестов удовлетворяют экспоненциальному распределению. Чаще всего экспоненциальное распределение фигурирует в задачах времени отказа устройств и даже времени жизни человека. Неясно так же, является ли это спецификой платформы (Windows) или Java GC или каких-то физических процессов, происходящих в компьютере.
Однако, учитывая, что каждое экспоненциальное распределение задается 2 параметрами (дисперсией и математическим ожиданием) и функция распределения performance test экспоненциальная, можно считать, что для peformance теста, нам необходимо и достаточно только 2 показателей. Среднее — время выполнения теста, дисперсия — отклонение от этого времени. Естественно, чем меньше дисперсия, тем лучше, но однозначно сказать, что лучше уменьшить среднее или дисперсию, нельзя.
Если у кого-то есть теория, откуда берется дисперсия и как влияет тот или иной алгоритм на ее значение, прошу поделиться. От себя хочу заметить, что зависимости между временем выполнения теста и дисперсии, я не нашел. 2 теста выполняющиеся в среднем одинаковое время (без sleep), могут иметь разные порядки дисперсии. | https://habr.com/ru/post/171475/ | null | ru | null |
# VIM как IDE для разработки на Python
Данная статья будет посвящена настройке vim, в которой я поделюсь своим «скромным» пониманием того, каким должен быть текстовый редактор, чтобы в нем было удобно/приятно/легко (нужное подчеркнуть) писать код также, как это сейчас возможно во всевозможных IDE типа PyCharm, SublimeText и т.п.
Весь процесс постараюсь описать как можно более подробно, чтобы вопросов по мере чтения для начинающих осваивать vim возникало как можно меньше.
##### Предыстория
Сам я знаком с vim не очень продолжительное время, однако, к его изучению и желанию использовать привело:
* достаточное количество на хабре статей по vim
* большое количество существующих плагинов
* преимущественно, разработчики на Python занимаются написанием кода под Linux (хотя vim — кроссплатформенный)
* собственное любопытство
В настоящее время я использую весьма часто vim как основной инструмент для разработки на Python и нисколько об этом не жалею. Если чего-либо нехватает, то проблема решается гуглением в течении пару минут. Поверьте, vim действительно стоит тех затраченных сил на его изучения. Это достаточно быстро себя «окупает». Было бы только желание и немножечко терпения.
##### Подготовительный этап
Итак. Перейдем непосредственно к подготовительному этапу. Нам понадобится:
1. Vim версии 7.4 (получить нужное можно либо скачиванием из репозиториев, либо сборкой вручную)
2. Python 2.7 (с установленным pip)
3. Клиент для работы с git
После того, как вышеперечисленное у нас имеется, можно приступать непосредственно к настройке и «кастомизации».
##### Настройка
Самое первой проблемой для любого новичка, который решает обуздать vim, является vimscript. Vimscript — это скриптовый язык, предназначенный для vim. На нем мы будем описывать используемые плагины, горячие клавиши и все тому подобное, чтобы обеспечить себе простую и легкую работу в vim. Для ознакомления советую посетить вот [этот](http://learnvimscriptthehardway.stevelosh.com/) и [этот](http://linux.vsevteme.ru/2010/05/08/blog/vvedenie-v-vimscript) сайты. Там достаточно неплохо все описано, что, где, как, и почему.
Первым делом стоит рассказать о том, что конфигурационный файл vim находится в домашнем каталоге пользователя (~/) и называется .vimrc. В нем-то и будут расписываться моменты относительно того, какие шрифты, цветовая схема, хоткеи и т.п. будут использоваться.
Во-вторых, при настойке текстового редактора, иногда будет необходимо заходить в каталог .vim (это скрытый каталог, и он расположен также в домашнем каталоге юзера), в который будут помещен ряд необходимых файлов, рассортированных по каталогам.
Какие включает в себя подкаталоги исходный каталог .vim? Примерно такие:
.vim
|\_\_\_\_after
|\_\_\_\_autoload
|\_\_\_\_colors
|\_\_\_\_doc
|\_\_\_\_ftplugin
|\_\_\_\_indent
|\_\_\_\_plugin
|\_\_\_\_scripts
|\_\_\_\_syntax
Однако, из всех вышеперечисленных каталогов нам понадобится лишь несколько:
* colors — для цветовых схем/тем
* indent — сюда будет скидывать файлы для работы с тегами HTML/XML и т.п.
* scripts — для скриптов
* syntax — файлы синтаксиса
В эти каталоги помещаем соответствующие файлы, взяв их, например, [у меня](https://github.com/Relrin/dotfiles/tree/master/vim).
До начала установки и работа с менеджером пакетов пропишем в консоли:
```
pip install pyflakes pep8 pylint ipython
```
В дальнейшем, эти библиотеки нам пригодятся для того, чтобы отслеживать качество своего кода: ошибки, соответствие его PEP8 и т.п. Последняя же в этом списке библиотека/пакет — ipython нам будет удобна для настройки своего «дебаггера».
Также нам еще необходимо установить Exuberant ctags. Скачать его можно [отсюда](http://ctags.sourceforge.net/) либо поискать и установить через менеджер пакетов apt-get/aptitude/rmp/pacman/и т.п.
###### Менеджер плагинов
Для того, чтобы нам было проще с установкой и использованием плагином будем использовать Vundle. Vundle — это пакетный менеджер для Vim, способный:
* настраивать и устанавливать плагины, указанные в. vimrc
* обновлять плагины при необходимости
* удалять неиспользуемые плагины
Однако прежде чем приступать к описанию необходимого набора плагинов в конфигурационном файле, сначала необходимо установить сам Vundle. Для этого делаем следующее:
```
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim
```
После выполнение этой команды Vundle будет установлен в ~/.vim/bundle/Vundle.vim
Теперь добавим следующую часть в свой новосозданный .vimrc если его еще нет:
```
set nocompatible " be iMproved, required
filetype off " required
"=====================================================
" Vundle settings
"=====================================================
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
Plugin 'gmarik/Vundle.vim' " let Vundle manage Vundle, required
"---------=== Code/project navigation ===-------------
Plugin 'scrooloose/nerdtree' " Project and file navigation
Plugin 'majutsushi/tagbar' " Class/module browser
"------------------=== Other ===----------------------
Plugin 'bling/vim-airline' " Lean & mean status/tabline for vim
Plugin 'fisadev/FixedTaskList.vim' " Pending tasks list
Plugin 'rosenfeld/conque-term' " Consoles as buffers
Plugin 'tpope/vim-surround' " Parentheses, brackets, quotes, XML tags, and more
"--------------=== Snippets support ===---------------
Plugin 'garbas/vim-snipmate' " Snippets manager
Plugin 'MarcWeber/vim-addon-mw-utils' " dependencies #1
Plugin 'tomtom/tlib_vim' " dependencies #2
Plugin 'honza/vim-snippets' " snippets repo
"---------------=== Languages support ===-------------
" --- Python ---
Plugin 'klen/python-mode' " Python mode (docs, refactor, lints, highlighting, run and ipdb and more)
Plugin 'davidhalter/jedi-vim' " Jedi-vim autocomplete plugin
Plugin 'mitsuhiko/vim-jinja' " Jinja support for vim
Plugin 'mitsuhiko/vim-python-combined' " Combined Python 2/3 for Vim
call vundle#end() " required
filetype on
filetype plugin on
filetype plugin indent on
```
Как вы видите, места где указаны `Plugin 'ссылка_до_плагина'` представляет собой ссылки в интернете эти плагины, которые Vundle будет скачивать и в последствии устанавливать. Для себя, я разбивал эти плагины на «категории», но это уже дело вкуса. Сами плагины:
* NERDTree — навигация по файловой/директориям
* TagBar — навигация по классам/функциям/переменным
* vim-airline — строка статуса/состояния
* FixedTaskList — поиск в файле FIXME, TODO и т.п.
* conque-term — используем для вызова дебаггера
* vim-surround — автозакрытие тегов HML/XML/и т.п.
* vim-snipmate — сниппеты
* python-mode — рефакторинг, документация, дебаггер Python и т.п.
* jedi-vim — автодополнение для Python
* vim-jinja — поддержка синтаксиса шаблонов Jinja
В качестве руководства/гайда по использованию Vundle можно зайти [сюда](https://github.com/gmarik/Vundle.vim). Однако для наших целей будет предостаточно одной:
```
:PluginInstall
```
Эта команда сканирует файл .vimrc на наличие списка плагинов прописанных в виде `Plugin 'ссылка_до_плагина'`.
Для того, чтобы запустить установку набора плагинов, заходим в vim/gvim и прописываем `:PluginInstall`. Придется немного подождать, поскольку каждый плагин, указанный выше в конфиге, будет скачан с githuba либо еще откуда-то и настроен до установок «по умолчанию», подождите пару минут. Каждый выкачанный и настроенный плагин отмечается как "+". Как только увидите, что все из списка подсвечены "+" — значит, все готово. И для дальнейшего использования необходимо будет перезапустить vim. Однако на этом все еще не оканчивается статья — все необходимо «подкрутить», чтобы работать в vim'е было комфортно.
##### Общие настройки vim'а
Эти настройки для меня являются базовыми. Тут я указываю свои предпочтения относительно парочки плагинов, размера шрифтов, цветовой схемы, отображаемых элементов и т.п.
Добавьте эти строчки в конец своего .vimrc файла:
```
"=====================================================
" General settings
"=====================================================
set backspace=indent,eol,start
aunmenu Help.
aunmenu Window.
let no_buffers_menu=1
set mousemodel=popup
set ruler
set completeopt-=preview
set gcr=a:blinkon0
if has("gui_running")
set cursorline
endif
set ttyfast
" включить подсветку кода
syntax on
if has("gui_running")
" GUI? устаналиваем тему и размер окна
set lines=50 columns=125
colorscheme molokai
" раскомментируйте эти строки, если хотите, чтобы NERDTree/TagBar автоматически отображались при запуске vim
" autocmd vimenter * TagbarToggle
" autocmd vimenter * NERDTree
" autocmd vimenter * if !argc() | NERDTree | endif
" на маке vim?
if has("mac")
set guifont=Consolas:h13
set fuoptions=maxvert,maxhorz
else
" дефолтный GUI
set guifont=Ubuntu\ Mono\ derivative\ Powerline\ 10
endif
else
" терминал?
colorscheme myterm
endif
tab sball
set switchbuf=useopen
" отключаем пищалку и мигание
set visualbell t_vb=
set novisualbell
set enc=utf-8 " utf-8 по дефолту в файлах
set ls=2 " всегда показываем статусбар
set incsearch " инкреминтируемый поиск
set hlsearch " подсветка результатов поиска
set nu " показывать номера строк
set scrolloff=5 " 5 строк при скролле за раз
" отключаем бэкапы и своп-файлы
set nobackup " no backup files
set nowritebackup " only in case you don't want a backup file while editing
set noswapfile " no swap files
" прячем панельки
"set guioptions-=m " меню
set guioptions-=T " тулбар
"set guioptions-=r " скроллбары
" настройка на Tab
set smarttab
set tabstop=8
" при переходе за границу в 80 символов в Ruby/Python/js/C/C++ подсвечиваем на темном фоне текст
augroup vimrc_autocmds
autocmd!
autocmd FileType ruby,python,javascript,c,cpp highlight Excess ctermbg=DarkGrey guibg=Black
autocmd FileType ruby,python,javascript,c,cpp match Excess /\%80v.*/
autocmd FileType ruby,python,javascript,c,cpp set nowrap
augroup END
" указываем каталог с настройками SnipMate
let g:snippets_dir = "~/.vim/vim-snippets/snippets"
" настройки Vim-Airline
set laststatus=2
let g:airline_theme='badwolf'
let g:airline_powerline_fonts = 1
let g:airline#extensions#tabline#enabled = 1
let g:airline#extensions#tabline#formatter = 'unique_tail'
" TagBar настройки
map :TagbarToggle
let g:tagbar\_autofocus = 0 " автофокус на Tagbar при открытии
" NerdTree настройки
" показать NERDTree на F3
map :NERDTreeToggle
"игноррируемые файлы с расширениями
let NERDTreeIgnore=['\~$', '\.pyc$', '\.pyo$', '\.class$', 'pip-log\.txt$', '\.o$']
" TaskList настройки
map :TaskList " отобразить список тасков на F2
" Работа буфферами
map :bd " CTRL+Q - закрыть текущий буффер
```
##### Python-mode
Очень нравится этот плагинчик, который кстати, сделан [klen](https://habrahabr.ru/users/klen/). Предоставляет море возможностей при работе с кодом:
* рефакторинг
* автодополнение
* работа с дебаггером
* автофикс PEP8 ошибок
* и многое-многое другое...
Добавьте эти строчки в конец своего .vimrc файла:
```
"=====================================================
" Python-mode settings
"=====================================================
" отключаем автокомплит по коду (у нас вместо него используется jedi-vim)
let g:pymode_rope = 0
let g:pymode_rope_completion = 0
let g:pymode_rope_complete_on_dot = 0
" документация
let g:pymode_doc = 0
let g:pymode_doc_key = 'K'
" проверка кода
let g:pymode_lint = 1
let g:pymode_lint_checker = "pyflakes,pep8"
let g:pymode_lint_ignore="E501,W601,C0110"
" провека кода после сохранения
let g:pymode_lint_write = 1
" поддержка virtualenv
let g:pymode_virtualenv = 1
" установка breakpoints
let g:pymode_breakpoint = 1
let g:pymode_breakpoint_key = 'b'
" подстветка синтаксиса
let g:pymode\_syntax = 1
let g:pymode\_syntax\_all = 1
let g:pymode\_syntax\_indent\_errors = g:pymode\_syntax\_all
let g:pymode\_syntax\_space\_errors = g:pymode\_syntax\_all
" отключить autofold по коду
let g:pymode\_folding = 0
" возможность запускать код
let g:pymode\_run = 0
```
##### Jedi-vim
Очень полезный плагин, предоставляющий отличные возможности автокомплита, go to definition, и т.п.
В своем конфиге добавьте в конец этот фрагмент:
```
" Disable choose first function/method at autocomplete
let g:jedi#popup_select_first = 0
```
Этой строчкой я отрубаю в автокомплите выбор первой строки из списка выбора метода/библиотеки/класса автокомплита. Это связано с тем, что достаточно часто я выбираю не первую строку из нее, а автоматический выбор раздражает.
После настройки jedi-vim получаем отображение документации по функции
и добротный автокомплит по аргументам функций
##### Хоткеи
Тут сложно что-либо посоветовать. У всех различное понимание того, какие хоткеи нужны, а какие-нет. Могу лишь сказать, что для желающих, найти/написать необходимые кусочки vimscript, переопределяющих поведение стандартных горячих клавиш — очень много.
Добавьте этот фрагмент в конец конфига:
```
"=====================================================
" User hotkeys
"=====================================================
" ConqueTerm
" запуск интерпретатора на F5
nnoremap :ConqueTermSplit ipython
" а debug-mode на
nnoremap :exe "ConqueTermSplit ipython " . expand("%")
let g:ConqueTerm\_StartMessages = 0
let g:ConqueTerm\_CloseOnEnd = 0
" проверка кода в соответствии с PEP8 через 8
autocmd FileType python map 8 :PymodeLint
" автокомплит через
inoremap
" переключение между синтаксисами
nnoremap Th :set ft=htmljinja
nnoremap Tp :set ft=python
nnoremap Tj :set ft=javascript
nnoremap Tc :set ft=css
nnoremap Td :set ft=django
```
##### Отступы, табы, пробелы для разных языков
Это связано с тем, что в том же Python табы не рекомендуется к использованию. Поэтому будем заменять их на пробелы. Один таб = 4 пробелам. Плюс ко всему необходимо помнить, что всегда нужно сделать переход на следующую строку + отступ, чтобы было соответствие операторам for/if/while/и т.п.
Для других языков предостаточно будет указать размер Таба, и замены их на пробелы.
Добавьте этот фрагмент в конец своего конфига:
```
"=====================================================
" Languages support
"=====================================================
" --- Python ---
"autocmd FileType python set completeopt-=preview " раскомментируйте, в случае, если не надо, чтобы jedi-vim показывал документацию по методу/классу
autocmd FileType python setlocal expandtab shiftwidth=4 tabstop=8
\ formatoptions+=croq softtabstop=4 smartindent
\ cinwords=if,elif,else,for,while,try,except,finally,def,class,with
autocmd FileType pyrex setlocal expandtab shiftwidth=4 tabstop=8 softtabstop=4 smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class,with
" --- JavaScript ---
let javascript_enable_domhtmlcss=1
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd BufNewFile,BufRead *.json setlocal ft=javascript
" --- HTML ---
autocmd FileType html set omnifunc=htmlcomplete#CompleteTags
" --- template language support (SGML / XML too) ---
autocmd FileType html,xhtml,xml,htmldjango,htmljinja,eruby,mako setlocal expandtab shiftwidth=2 tabstop=2 softtabstop=2
autocmd bufnewfile,bufread *.rhtml setlocal ft=eruby
autocmd BufNewFile,BufRead *.mako setlocal ft=mako
autocmd BufNewFile,BufRead *.tmpl setlocal ft=htmljinja
autocmd BufNewFile,BufRead *.py_tmpl setlocal ft=python
let html_no_rendering=1
let g:closetag_default_xml=1
let g:sparkupNextMapping=''
autocmd FileType html,htmldjango,htmljinja,eruby,mako let b:closetag\_html\_style=1
autocmd FileType html,xhtml,xml,htmldjango,htmljinja,eruby,mako source ~/.vim/scripts/closetag.vim
" --- CSS ---
autocmd FileType css set omnifunc=csscomplete#CompleteCSS
autocmd FileType css setlocal expandtab shiftwidth=4 tabstop=4 softtabstop=4
```
##### Подведение итогов
После прохождения столь длительного процесса настройки у нас получился достаточно гибкий инструмент для работы с Python. При этом, последующая установка, на другие ПК будет представлять только доустановку необходимых библиотек, переноса соответствующего конфига и установку плагинов.
После настройки мы получим примерно такой vim:
В режиме работы с HTML/JavaScript/XML будет все выглядеть примерно так:
Если кому-либо нужен больший функционал (например поддержка автокомплита для любых иных языков), то могу посоветовать лишь поискать необходимые плагины на GitHub'е или на офицальном сайте сайте vim'a.
###### Полезные ссылки:
Раздел script сайта vim.org — [тут](http://www.vim.org/scripts/script_search_results.php?order_by=creation_date&direction=descending)
wikia по vim'у — [тут](http://vim.wikia.com/wiki/Vim_Tips_Wiki)
OpenVim: уроки по азам в vim — [тут](http://www.openvim.com/tutorial.html)
Шрифты для vim-airline — [тут](https://github.com/Lokaltog/powerline-fonts)
Мой конфиг для vim на [GitHub](https://github.com/Relrin/dotfiles/tree/master/vim) | https://habr.com/ru/post/224979/ | null | ru | null |
# Большой Калькулятор выходит из под контроля
Я хочу посвятить эту статью проблеме, о которой мало кто задумывается. Все шире и шире применяется моделирование различных процессов с помощью компьютера. Это замечательно, возможностью экономить время и материалы на бессмысленные химические, биологические, физические и прочие эксперименты. Обдув модели крыла на компьютере может в несколько раз сократить количество макетов, которое затем будет испытываться в реальной аэродинамической трубе. Численным экспериментам доверяют всё больше. Однако за торжеством численного моделирования никто не обращает внимания на рост сложности программ. В компьютере и к программам видят всего лишь инструмент для получения результата. Меня тревожит, что далеко не все знают и задумываются о том, что рост размера программы ведет к нелинейному росту числа ошибок. Опасно применять компьютер как просто большой калькулятор. Я и думаю, надо доносить эту мысль до других людей.
### Большой калькулятор
В начале, я хотел назвать эту статью приблизительно так «Если программистам нельзя изготавливать лекарства, то почему медикам можно программировать?». Абстрактному программисту нельзя заняться изобретением и изготовлением лекарств. Причина понятна — у него нет соответствующего образования. А вот с программированием не всё так просто. Кажется, что абстрактный медик, освоив программирование, автоматически принесёт пользу. Благо, научиться как-то программировать проще, чем разобраться в органической химии и принципах создания лекарств.
Здесь кроется подвох. Численный эксперимент требует не меньший аккуратности, чем реальный. Учат мыть пробирки после экспериментов и следят за их стерильностью. Но мало кто всерьез обеспокоен проблемой, что какой-то массив может случайно оказаться неинициализированным.
Программисты знают, что чем сложнее программное обеспечение, тем сложней и не очевидней в нём проявляются ошибки. Другими словами, я говорю о [нелинейном росте количества ошибок](http://www.viva64.com/ru/b/0158/) при росте размера кода. А ведь программы для химических и иных расчётов отнюдь не просты. Здесь и кроется беда. Не страшно, что медик-программист допускает ошибки. Их делает любой программист, независимо от профессионализма. Страшно, что таким результатам начинают всё больше доверять. Посчитали что-то и пошли дальше заниматься своими делами.
Те, чья основная деятельность программирование, знают опасность такого подхода. Они знают, что такое неопределенное поведение и как программа может делать вид, что выдает правильный результат. Есть статьи и книги, посвященные тому, как правильно писать юнит-тесты и как лучше проверить корректность расчетов.
Это мир программистов. В мире химиков/физиков/медиков, боюсь, дело обстоит не так. Они не пишут сложную программу. Вернее они не думают в этом направлении. Они просто используют компьютер как Большой Калькулятор. Такое сравнение привёл один из читателей. Я приведу его цитату здесь полностью, чтобы после перевода статьи, с ней могли познакомиться и англоязычные читатели.
*Имею кое-что сказать по этой теме исходя из личного опыта. Будучи профессиональным программистом, по образованию я — потомственный физик. Так уж вышло, что в тот момент, когда я выбирал ВУЗ, голос крови оказался сильнее, чем вера в светлое будущее IT. И я поступил в достаточно престижную по местным меркам физическую высшую школу, которая, по сути, является «детским садиком» при крупном НИИ в родном городе Нижнем Новгороде. Люди, знающие тему, узнают и НИИ, и название школы.
На протяжении учёбы вполне естественно оказалось, что по части программирования (и в том числе математических методов физического моделирования) я был одним из лучших. И там же выяснились следующие факты:
1. Физики рассматривают компьютер как большой многофункциональный калькулятор, позволяющий построить график зависимости Эта от Тэта при Гамма стремящемся в бесконечность. Причем, очевидным образом, для них цель — график, а вовсе не та программа, которая его рисует.
2. Как следствие из этого факта, программист — это не профессия. Программист — это просто тот человек, который умеет пользоваться Большим Калькулятором, чтобы построить означенный график. Каким способом график будет построен, не имеет значения. Совсем. Как-как вы сказали? Статический анализ? Контроль версий? Окститесь, родные! C++ — язык для программистов. Физики пишут на Фортране!
3. Как следствие из предыдущего пункта, человек, стремящийся посвятить свою жизнь написанию программ физ. моделирования, даже универсальных, даже очень и очень крутых — не более, чем приложение к калькулятору. Он и не человек вовсе, а так… И это, кстати, распространялось не только на меня (куда уж мне, убогому), а даже и на лучшего численника-расчётчика в НИИ, который преподавал у нас численные методы и который, когда я пришел к нему делать курсовую, сказал мне почти открытым текстом: «Вас будут презирать, приготовьтесь терпеть».
Терпеть мне не захотелось, и я после окончания ушел из моделирования в области, где программистов не считают людьми второго сорта. Надеюсь, этот пример объясняет, почему инициативы типа ввода статического анализа даже на сравнительно крупных (до 20-30 человек) проектах по математическому моделированию — гиблое дело. Там просто может не найтись человека, который знает, что это такое. А если такой человек и найдётся, его, скорее всего затопчут, потому что нафиг не нужны эти новомодные программистские прибамбасы. Сто лет без них жили — и дальше проживём.
И тем, кто не заскучал, второй пример. Мой отец, находясь в пенсионном возрасте, тем не менее работает в очень крупном оборонно-инженерном предприятии, здесь же, в Нижнем (самом крупном в городе и одном из крупнейших в стране — те, кто в теме опять же угадают ;) ). Он всю жизнь программировал на Фортране. Начинал еще с перфокарт. Я не виню его за то, что не учит C++. Ему это уже 10 лет назад было поздно — он еще неплохо держится. Но на предприятии, где 2/3 сотрудников что-то как-то программируют, приняты следующие меры безопасности:
1. Никакого интернета. Совсем. Нужна литература — иди в местную библиотеку. Stack Overflow? А что это? Даже если ты хочешь отправить письмо электронной почтой, ты должен написать заявление начальнику, где ты объяснишь, кому это письмо и для чего. Интернет «под расписку» есть только у избранных. Слава богу, хоть внутренняя сеть есть.
2. Никаких административных прав на рабочем компьютере. Возможно, это правило разумно для офисного планктона, но мне трудно себе представить программиста, которого бы оно устроило.
3. (не относится к делу, просто иллюстрация) Нельзя даже пронести телефон с камерой (а где вы теперь видели другие)?
В результате даже молодняк пишет на Фортране, причем реально грамотных в программировании — единицы. Знаю, потому что подтягивал по программированию одного парня лет 25, который был мне отцом зарекомендован как многообещающий.
Мой вердикт: там 80-е годы. Даже при том, что там неплохо платят, я не пойду туда ни за какие коврижки.
Вот такие два примера из жизни интеллектуальной элиты. Никого не хочу очернить — люди хорошо делают своё дело и так, но иногда смотря, с какими ветряными мельницами порой воюет отец, которого я недавно (слава богу!) смог-таки пересадить в git, сердце сжимается. Никакого ООП в проекте под миллион строк кода, никакого статического анализа.
Просто люди имеют свойство быть очень консервативными в областях, не являющихся их основным «коньком».*
(Илья Майзус. [Оригинал комментария](http://www.viva64.com/go.php?url=1297).)
Самое главное здесь, что компьютер это просто Большой Калькулятор. А раз так, то и знать о нём можно не больше чем заслуживает его младший родственник — «калькулятор карманный». Да, именно так его и используют. В разных областях. Давайте на секунду отвлечемся и заглянем в мир физики. Посмотрим, как находит подтверждение очередная теория. Для этого мне вновь придется привести большую цитату. Источником является книга Брайана Грина «Элегантная вселенная (суперструны, скрытые размерности и поиски окончательной теории)» [1]:
*Мы все сгрудились вокруг компьютера Моррисона, стоявшего в нашем кабинете. Аспинуолл объяснил Моррисону, как запустить программу и какой точный вид должны иметь вводимые в нее данные. Моррисон привел полученные ночью результаты к нужному виду, и теперь все было готово.*
*Расчет, который нужно было провести, грубо говоря, сводился к определению массы конкретной частицы, являющейся колебательной модой струны при ее движении во вселенной, компоненту КалабиЯу которой мы изучали всю осень. Мы надеялись, что в соответствии с выбранной нами стратегией масса окажется точно такой же, что и масса в случае многообразия КалабиЯу, возникшего после флопперестройки с разрывом пространства. Последнюю массу вычислить было легко, и мы сделали это несколькими неделями раньше. Ответ оказался равным 3 в определенной системе единиц, которой мы пользовались. А так как сейчас проводился численный расчет на компьютере, то ожидаемый результат должен был быть близким к числу 3, чтото вроде 3,000001 или 2,999999; отличие от точного ответа объяснялось бы ошибками округления.*
*Моррисон сел за компьютер. Его палец завис над клавишей «Enter». Напряжение нарастало. Моррисон выдохнул «поехали» и запустил программу. Через пару секунд компьютер выдал ответ: 8,999999. Мое сердце упало. Неужели действительно флопперестройки с разрывом пространства нарушают зеркальную симметрию, а значит, вряд ли существуют в реальности? Но в следующее же мгновение мы сообразили, что здесь какаято глупая ошибка. Если в массах частиц на двух многообразиях действительно есть отличие, почти невероятно, что компьютер выдал бы результат, столь близкий к целому числу. Если наши идеи неверны, то с тем же самым успехом компьютер мог бы выдать ответ, состоящий из совершенно случайных цифр. Мы получили неправильный ответ, но неправильность его была такого вида, из которого напрашивался вывод о том, что гдето мы допустили банальную ошибку. Аспинуолл и я подошли к доске, и моментально ошибка была найдена: мы забыли множитель 3 в «простом» вычислении несколько недель назад, так что правильный результат должен был равняться 9. Поэтому ответ компьютера — это как раз то, на что мы надеялись.*
*Конечно, совпадение результата после того, как найдена ошибка, является лишь наполовину убедительным. Если известен желаемый результат, очень легко найти способ его получить. Нам срочно требовался другой пример. Имея все необходимые программы, придумать его не представляло сложности. Мы вычислили массу еще одной частицы на верхнем многообразии КалабиЯу, на этот раз с особой тщательностью, чтобы избежать еще одной ошибки. Ответом было число 12. Мы снова окружили компьютер и запустили программу. Через несколько секунд был получен ответ 11,999999. Согласие. Мы доказали, что предполагаемое зеркальное пространство является зеркальным пространством, и флопперестройки с разрывами пространства являются частью теории струн.*
*Я вскочил со стула и, опьяненный победой, сделал круг по комнате. Моррисон, сияя, сидел за компьютером. И только реакция Аспинуолла была нестандартной. «Здорово. Я и не сомневался, что все так и будет, — спокойно сказал Аспинуолл. — А где мое пиво?»*
Я верю, что они гении. Но представим, что таким подходом вычислялось значение интеграла обыкновенными студентами. Не думаю, что тогда программисты посчитали бы такой подход серьезным. А если бы программа сразу выдала 3? Что тогда? Ошибка в программе посчиталась бы за доказательство? Думаю, потом бы ошибка всплыла при перепроверке ими же или другими учеными. Но все равно, «идеальный сферический программист в вакууме» испуган от такого подхода.
Вот такая вот она реальность. Именно так используются не только персональные компьютеры, но и кластерные системы в научных вычислениях. А самое главное, люди доверяют результатам работы программ. И чем дальше, тем больше таких вычислении будет. И тем больше будет опасность существования ошибок в их коде.
Быть может пора что-то менять?
Я имею права сам себе наклеить пластырь. Могу порекомендовать, что, по моему мнению, стоит выпить при простуде. Но не более. Я не могу сверлить зуб или выписать рецепт.
Быть может, когда ответственность создаваемой программной системы выходит за определённые рамки, её разработчики тоже должны подтверждать свою квалификацию?
Я знаю про различные сертификации. Но я говорю о другом. Сертификация направлена на то, чтобы код программ соответствовал определенным нормам. Косвенно, это частично защищает от халтуры. Однако, список сфер, где требуется сертификация достаточно узок. Он явно не покрывает весь спектр, где неаккуратное обращение с Большим Калькулятором может навредить.
### Пример опасности
Думаю, многим мои переживания кажутся слишком абстрактами. Поэтому, давайте рассмотрим что-то из практики. Есть открытый пакет [Trans-Proteomic Pipeline](http://www.viva64.com/go.php?url=895) (TPP), для решении задач в сфере биологии. Его явно используют. Используют его те, кто разрабатывает и возможно сторонние организации. Мне кажется, наличие любой в нем ошибки, уже потенциальная проблема. А есть ли в нём ошибки? Да есть. И появляются всё новые. Год назад, мы проверяли этот проект и написали заметку "[Проверка проекта Trans-Proteomic Pipeline (TPP)](http://www.viva64.com/ru/b/0156/)".
Изменилось что-то с тех пор? Ничего не изменилось. Проект продолжает развиваться и обрастать новыми ошибками. Большой Калькулятор победил. Разработчики не заняты написанием высококачественного проекта с минимально возможным количеством ошибок. Они просто решают задачи. Будь иначе, они бы как-то отреагировали на предыдущую статью и задумались над внедрением каких-то инструментов статического анализа. Я не имею в виду, что они были обязаны выбрать PVS-Studio. Есть много других статических анализаторов кода. Важно то, что в ответственном приложении продолжают появляться типичнейшие ошибки. Давайте посмотрим, что есть новенького.
#### 1. Какой-то неумеха продолжает писать неправильные циклы
В предыдущей статье, я уже писал про некорректные условия в циклах. Есть такие ошибки и новой версии пакета.
```
double SpectraSTPeakList::calcDot(SpectraSTPeakList* other) {
....
for (i = this->m_bins->begin(), j = other->m_bins->begin();
i != this->m_bins->end(), j != other->m_bins->end();
i++, j++) {
d = (*i) * (*j);
dot += d;
}
....
}
```
Диагностическое сообщение PVS-Studio: V521 Such expressions using the ',' operator are dangerous. Make sure the expression is correct. spectrastpeaklist.cpp 504
В проверке «i != this->m\_bins->end(), j != other->m\_bins->end()», выражение стоящее до запятой ничего не проверяет. Оператор запятая ',' используется для выполнения стоящих по обе стороны от него выражений в порядке слева направо и **возвращает значение правого выражения**. Корректная проверка должна выглядеть так:
```
i != this->m_bins->end() && j != other->m_bins->end()
```
Аналогичные ляпы можно увидеть здесь:* spectrastpeaklist.cpp 516
* spectrastpeaklist.cpp 529
* spectrastpeaklist.cpp 592
* spectrastpeaklist.cpp 608
* spectrastpeaklist.cpp 625
* spectrastpeaklist.cpp 696
#### 2. Разыменовывание нулевого указателя
Такая ошибка не приведет к неправильным результатам вычислений. Будет падание программы, что намного лучше. Однако, не написать про эти ошибки будет тоже странно.
```
void ASAPRatio_getDataStrctRatio(dataStrct *data, ....)
{
....
int *outliers, *pepIndx=NULL;
....
//pepIndx не изменяется
....
if(data->dataCnts[i] == 1 && pepIndx[i] == 0)
data->dataCnts[i] = 0;
....
}
```
Диагностическое сообщение PVS-Studio: V522 Dereferencing of the null pointer 'pepIndx' might take place. asapcgidisplay2main.cxx 534
Здесь также разыменовывается нулевой указатель:* Pointer 'peptides'. asapcgidisplay2main.cxx 556
* Pointer 'peptides'. asapcgidisplay2main.cxx 557
* Pointer 'peptides'. asapcgidisplay2main.cxx 558
* Pointer 'peptides'. asapcgidisplay2main.cxx 559
* Pointer 'peptides'. asapcgidisplay2main.cxx 560
* Pointer 'pepIndx'. asapcgidisplay2main.cxx 569
#### 3. Неочищенные массивы
```
static void clearTagNames() {
std::vectorptrs;
for (tagname\_set::iterator i = tagnames.begin();
i!=tagnames.end();i++) {
ptrs.push\_back(\*i);
}
for (tagname\_set::iterator j = attrnames.begin();
j!=attrnames.end();j++) {
ptrs.push\_back(\*j);
}
tagnames.empty();
attrnames.empty();
for (size\_t n=ptrs.size();n--;) {
delete [] (char \*)(ptrs[n]); // cast away const
}
}
```
Анализатор заметил здесь сразу два неочищенных массива:
V530 The return value of function 'empty' is required to be utilized. tag.cxx 72
V530 The return value of function 'empty' is required to be utilized. tag.cxx 73
Вместо функции empty() следует вызывать функцию clear().
#### 4. Неинициализированные объекты классов
```
class ExperimentCycleRecord {
public:
ExperimentCycleRecord() {
ExperimentCycleRecord(0,0,0,True,False);
}
ExperimentCycleRecord(long lExperiment, long lCycleStart,
long lCycleEnd, Boolean bSingleCycle,
Boolean bRangleCycle)
{
....
}
....
}
```
Диагностическое сообщение PVS-Studio: V603 The object was created but it is not being used. If you wish to call constructor, 'this->ExperimentCycleRecord::ExperimentCycleRecord(....)' should be used. mascotconverter.cxx 101
Конструктор ExperimentCycleRecord() не выполняет своего предназначения. Он ничего не инициализирует. Разработчик может быть хорошим химиком, но если он не знает, как работать с языком Си++, то грош цена вычислениям, в которых используется неинициализированная память. Это как взять грязную пробирку.
Строчка «ExperimentCycleRecord(0,0,0,True,False);» место вызова другого конструктора, создает временный объект, который будет разрушен. Подробнее этот паттерн ошибки я рассматривал в статье "[Не зная брода, не лезь в воду — часть первая](http://www.viva64.com/ru/b/0127/)".
Аналогичные неправильные конструкторы можно найти здесь:* asapratiopeptideparser.cxx 57
* asapratiopeptidecgidisplayparser.cxx 36
* cruxdiscrimfunction.cxx 36
* discrimvalmixturedistr.cxx 34
* mascotdiscrimfunction.cxx 47
* mascotscoreparser.cxx 37
* tandemdiscrimfunction.cxx 35
* tandemkscoredf.cxx 37
* tandemnativedf.cxx 37
#### 5. Комментарии, которые нарушили логику
```
int main(int argc, char** argv) {
....
if (getIsInteractiveMode())
//p->writePepSHTML();
//p->printResult();
// regression test?
if (testType!=NO_TEST) {
TagListComparator("InterProphetParser",testType,
outfilename,testFileName);
....
}
```
Диагностическое сообщение PVS-Studio: V628 It's possible that the line was commented out improperly, thus altering the program's operation logics. interprophetmain.cxx 175
После оператора 'if' были закомментированы строчки, выполняющие действия. В результате, логика работы программа изменилась не так, как планировал программист. Он хотел, чтобы при выполнении условия ничего не происходило. Вместо этого, оператор 'if' оказывает влияние на код, расположенный ниже. Результат — запуск тестов зависит теперь не только от условия «testType!=NO\_TEST», но и от условия «getIsInteractiveMode()». Тест может ничего не тестировать. [Крайне рекомендую](http://www.viva64.com/ru/a/0080/) не полагаться полностью на одну методологию тестирования (например, TDD).
#### 6. Опечатки
Опечатки есть везде и всегда. Не страшно, если из-за такой ошибки в игре у вас станет меньше жизней после взрыва, чем планировалось. А что означают неправильные данные при химических расчетах?
```
void ASAPRatio_getProDataStrct(proDataStrct *data, char **pepBofFiles)
{
....
if (data->indx == -1) {
data->ratio[0] = -2.;
data->ratio[0] = 0.;
data->inv_ratio[0] = -2.;
data->inv_ratio[1] = 0.;
return;
}
....
}
```
Диагностическое сообщение PVS-Studio: V519 The 'data->ratio[0]' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 130, 131. asapcgidisplay2main.cxx 131
Случайно два раза записали значения в одну и ту же переменную. Должно было быть:
```
data->ratio[0] = -2.;
data->ratio[1] = 0.;
```
А потом, ещё копировали этот фрагмент в другие местам программы:* asapcgidisplay2main.cxx 338
* asapcgidisplay2main.cxx 465
* asapratioproteincgidisplayparser.cxx 393
* asapratioproteincgidisplayparser.cxx 518
#### 7. Сравнение знаковых и беззнаковых чисел.
Сравнивать знаковые и беззнаковые числа надо уметь. В обыкновенных калькуляторах нет беззнаковых чисел. А в языке Си++ есть.
```
size_type size() const;
void computeDegenWts()
{
....
int have_cluster = 0;
....
if ( have_cluster > 0 && ppw_ref.size() - have_cluster > 0 )
....
}
```
Диагностическое сообщение PVS-Studio: V555 The expression 'ppw\_ref.size() — have\_cluster > 0' will work as 'ppw\_ref.size() != have\_cluster'. proteinprophet.cpp 6767
Хотелось выполнить проверку «ppw\_ref.size() > have\_cluster». Но получилось совсем иное.
Для простоты, пусть у нас тип 'size\_t' будет 32-битным. Предположим, функция «ppw\_ref.size()» вернёт число 10, а переменная have\_cluster равна 15. Функция ppw\_ref.size() возвращает беззнаковый тип 'size\_t'. По правилам языка Си++ перед вычитанием правый оператор в операции минус тоже станет иметь тип 'size\_t'. Пока всё хорошо. Слева у нас 10u, справа 15u.
Вычитаем:
10u — 15u
А вот здесь беда. Всё те же правил языка Си++ говорят, что результат вычитания двух переменных беззнакового типа, также будет иметь беззнаковый тип.
Это значит, что 10u — 15u = FFFFFFFBu. А, как известно, 4294967291 больше 0.
Бунт Большого Калькулятора удаётся. Мало написать правильный теоретический алгоритм. Надо ещё написать правильный код.
Схожая по духу ошибка присутствует здесь:
```
double SpectraSTPeakList::calcXCorr() {
....
for (int tau = -75; tau <= 75; tau++) {
float dot = 0.0;
for (unsigned int b = 0; b < numBins; b++) {
if (b + tau >= 0 && b + tau < (int)numBins) {
dot += (*m_bins)[b] * theoBins[b + tau] / 10000.0;
}
}
....
....
}
```
Диагностическое сообщение PVS-Studio: V547 Expression 'b + tau >= 0' is always true. Unsigned type value is always >= 0. spectrastpeaklist.cpp 2058
Как видно из кода, переменная 'tau' принимает значения в диапазоне [-75, 75]. Чтобы не выйти за границу массива имеется проверка: b + tau >= 0. Я думаю, вы уже поняли, что эта проверка не работает. Переменная 'b' имеет тип 'unsigned'. Это значит, что и выражение «b + tau» имеет тип unsigned. Значение типа unsigned всегда больше или равно 0.
#### 8. Странный цикл
```
const char* ResidueMass::getStdModResidues(....) {
....
for (rmap::const_iterator i = p.first; i != p.second; ++i) {
const cResidue &r = (*i).second;
if (r.m_masses[0].m_nterm) {
n_term_aa_mod = true;
} else if (r.m_masses[0].m_cterm) {
c_term_aa_mod = true;
}
return r.m_residue.c_str();
}
if(! strcmp(mod, "+N-formyl-met (Protein)")) {
return "n";
} if (! strcmp(mod, "13C6-15N2 (K)")) {
return "K";
} if (! strcmp(mod, "13C6-15N4 (R)")) {
return "R";
....
}
```
Предупреждение выданное PVS-Studio: V612 An unconditional 'return' within a loop. residuemass.cxx 1442
Внутри цикла есть оператор 'return', который вызывается в любом случае. Цикл может выполнить только одну итерацию, после чего функция завершится. Думаю, здесь или опечатка или не хватает условия перед оператором 'return'.
#### 9. Грубые вычисления
```
double RTCalculator::getUsedForGradientRate() {
if (rts_.size() > 0)
return used_count_ / rts_.size();
return 0.;
}
```
Предупреждение выданное PVS-Studio: V636 The 'used\_count\_ / rts\_.size()' expression was implicitly casted from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. rtcalculator.cxx 6406
Так как функция возвращает значения типа double, то разумно предположить следующее.
Если переменная 'used\_count\_' равна 5, а функция rts\_.size() вернет 7, то результат должен быть приблизительно равен 0,714. Вот только функция getUsedForGradientRate() в этом случае вернет 0.
Переменная 'used\_count\_' имеет тип int. Функция rts\_.size() тоже возвращает значение типа 'int'. Происходит целочисленное деление. Результат очевиден. Он равен нулю. Затем ноль неявно приводится к типу double. Но это уже не важно.
Чтобы исправить ситуацию, можно написать так:
```
return static_cast(used\_count\_) / rts\_.size();
```
Аналогичные недочеты:* cgi\_pep3d\_xml.cxx 3203
* cgi\_pep3d\_xml.cxx 3204
* asapratiopeptideparser.cxx 4108
#### 10. Великий и могучий Copy-Paste
Функция setPepMaxProb() содержит несколько больших однотипных блоков. Сразу чувствуется, что без методики Copy-Paste здесь не обошлось. А как результат, код содержит ошибку. Мне пришлось ОЧЕНЬ сильно сократить код примера. В сокращенном варианте ошибка легко видна. В коде программы, заметить её почти не реально. Да, это реклама инструментов статического анализа вообще, и [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) в частности.
```
void setPepMaxProb( bool use_nsp, bool use_fpkm,
bool use_joint_probs, bool compute_spectrum_cnts )
{
double prob = 0.0;
double max2 = 0.0;
double max3 = 0.0;
double max4 = 0.0;
double max5 = 0.0;
double max6 = 0.0;
double max7 = 0.0;
....
if ( pep3 ) { ... if ( use_joint_probs && prob > max3 ) ... }
....
if ( pep4 ) { ... if ( use_joint_probs && prob > max4 ) ... }
....
if ( pep5 ) { ... if ( use_joint_probs && prob > max5 ) ... }
....
if ( pep6 ) { ... if ( use_joint_probs && prob > max6 ) ... }
....
if ( pep7 ) { ... if ( use_joint_probs && prob > max6 ) ... }
....
}
```
V525 The code containing the collection of similar blocks. Check items 'max3', 'max4', 'max5', 'max6', 'max6' in lines 4664, 4690, 4716, 4743, 4770. proteinprophet.cpp 4664
Предупреждение выданное PVS-Studio: V525 The code containing the collection of similar blocks. Check items 'max3', 'max4', 'max5', 'max6', 'max6' in lines 4664, 4690, 4716, 4743, 4770. proteinprophet.cpp 4664
К сожалению диагностика V525 даёт много ложных срабатываний и отнесена к третьему уровню предупреждений. Но если не полениться их изучать, можно находить вот такие замечательные баги.
#### 11. Указатель не всегда инициализируется
```
int main(int argc, char** argv) {
....
ramp_fileoffset_t *pScanIndex;
....
if ( (pFI=rampOpenFile(mzXmlPath_.c_str()))==NULL) {
....
} else {
....
pScanIndex = readIndex(pFI, indexOffset, &iAnalysisLastScan);
....
}
....
if (pScanIndex != NULL)
free(pScanIndex);
return 0;
}
```
Предупреждение выданное PVS-Studio: V614 Potentially uninitialized pointer 'pScanIndex' used. sqt2xml.cxx 476
Эта программа может в конце аварийно завершиться, если функция rampOpenFile() вернёт NULL. Не критично, но неприятно.
Другая переменная, которая может оказаться не инициализированной, находится здесь:* Potentially uninitialized pointer 'fp\_' used. dta-xml.cpp 307
#### 12. Нет виртуального деструктора
```
class DiscriminantFunction {
public:
DiscriminantFunction(int charge);
virtual Boolean isComputable(SearchResult* result) = 0;
virtual double getDiscriminantScore(SearchResult* result) = 0;
virtual void error(int charge);
protected:
int charge_;
double const_;
}; // class
class CometDiscrimFunction : public DiscriminantFunction;
class CruxDiscrimFunction : public DiscriminantFunction;
class InspectDiscrimFunction : public DiscriminantFunction;
.....
class DiscrimValMixtureDistr : public MixtureDistr {
....
DiscriminantFunction* discrim_func_;
....
};
DiscrimValMixtureDistr::~DiscrimValMixtureDistr() {
delete[] posinit_;
delete[] neginit_;
delete discrim_func_;
}
```
Предупреждение выданное PVS-Studio: V599 The virtual destructor is not present, although the 'DiscriminantFunction' class contains virtual functions. discrimvalmixturedistr.cxx 206
От класса DiscriminantFunction наследуется множество классов. Например, наследником является класс DiscrimValMixtureDistr. Деструктор этого класса освобождает память, а, следовательно, очень желательно его вызывать. К сожалению, деструктор в классе DiscriminantFunction не объявлен виртуальным, со всеми вытекающими последствиями.
#### 13. Разное
Можно найти массу недочетов, которые не приведут к серьезным последствиям, но их присутствие в коде неприятно. Есть и просто подозрительные, но не обязательно ошибочные места. Вот одно из них:
```
Boolean MixtureModel::iterate(int counter) {
....
if (done_[charge] < 0) {
done_[charge];
}
else if (priors_[charge] > 0.0) {
done_[charge] += extraitrs_;
}
....
}
```
Предупреждение выданное PVS-Studio: V607 Ownerless expression 'done\_[charge]'. mixturemodel.cxx 1558
Что это? Недописанный код? Или хотели подчеркнуть, что не надо ничего делать, если выполнится условие «done\_[charge] < 0»?
А вот неправильное освобождение памяти. С большой вероятностью страшных последствий не будет, но этот код с запахом.
```
string Field::getText(....)
{
....
char* pepString = new char[peplen + 1];
....
delete pepString;
....
}
```
Предупреждение выданное PVS-Studio: V611 The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] pepString;'. pepxfield.cxx 1023
Здесь следовало написать «delete [] pepString». Такое место далеко не одно:* cruxdiscrimvalmixturedistr.cxx 705
* cruxdiscrimvalmixturedistr.cxx 715
* mascotdiscrimvalmixturedistr.cxx 426
* mascotdiscrimvalmixturedistr.cxx 550
* mascotdiscrimvalmixturedistr.cxx 624
* phenyxdiscrimvalmixturedistr.cxx 692
* probiddiscrimvalmixturedistr.cxx 487
* probiddiscrimvalmixturedistr.cxx 659
* tandemdiscrimvalmixturedistr.cxx 731
* tandemdiscrimvalmixturedistr.cxx 741
А вот реализация оператора "--". Видимо он не используется нигде. Иначе ошибка бы быстро выявилась.
```
CharIndexedVectorIterator operator++(int)
{ // postincrement
CharIndexedVectorIterator _Tmp = *this;
++m_itr;
return (_Tmp);
}
CharIndexedVectorIterator& operator--()
{ // predecrement
++m_itr;
return (*this);
}
```
Предупреждение выданное PVS-Studio: V524 It is odd that the body of '--' function is fully equivalent to the body of '++' function. charindexedvector.hpp 81
Операторы "--" и "++" реализованы одинаково. А дальше, наверное, скопировали:* charindexedvector.hpp 87
* charindexedvector.hpp 159
* charindexedvector.hpp 165
Продолжать дальше не буду. Это не так уж всё интересно, да и статья затянулась. Как всегда прошу разработчиков, не останавливаться на правке перечисленных недоработок. [Скачайте](http://www.viva64.com/ru/pvs-studio-download/) и проверьте самостоятельно проект с помощью PVS-Studio. Я мог пропустить многие ошибки. Мы готовы выделить бесплатный ключ на некоторое время.
### Резюмирую
К сожалению, статья получилась путанной. Так что же хотел сказать автор? Попробую совсем кратко повторить, какие мысли я хотел донести.1. Мы все больше используем и доверяем программам, выполняющим расчёты и моделирующие процессы.
2. Программы сильно усложняются. Профессиональным программистам очевидно, что нельзя создавать пакет численного моделирования так же, как использовать программируемый калькулятор. Рост сложности ведёт к экспоненциальному росту количества ошибок [[2](http://www.viva64.com/ru/b/0158/)].
3. Получается, что физики/биологи/медики уже не могут по-прежнему просто что-то посчитать. Нельзя игнорировать рост сложности программ и последствия неправильных вычислений в силу неполного владения языком программирования.
4. В статье я привел аргументы, что всё обстоит именно так. Первая цитата — люди используют компьютер, как калькулятор. Вторая цитата — да, именно как калькулятор. Примеры ошибок — да, и действительно допускают ошибок. Мои опасения обоснованы.
И что предлагается делать?
Для начала я хочу, чтобы люди начали осознавать эту проблему. И рассказывали знакомым из смежных областей о ней. Для программистов давно очевидно, что рост сложности и глупые ошибки в больших проектах, легко доводят до беды. Люди же, использующие программирование просто как инструмент, не знают про это и не задумываются. И им стоит подсказать обратить на это внимание.
Аналогия. Люди взяли в руку дубину и начали охотиться за зверьем. Пока они этим занимаются, оружие стремительно совершенствуется. Дубина в их руках превращается в каменный молоток, потом в меч, потом в ружьё. А они по прежнему стараются ей просто глушить зайцев по голове. Мало того, что это неэффективно, так ещё и стало намного опасней (можно в себя выстрелить или в коллегу). Охотники из племени «программистов» быстро приспосабливаются. А остальным некогда. Они заняты охотой за зайцами. Ведь смысл именно в зайцах. Надо подсказать этим людям, что хотят они того или нет, им надо учиться. Так только всем лучше будет. Нечего ружьем махать.
### Дополнительные ссылки
1. Брайан Грин «Элегантная вселенная (суперструны, скрытые размерности и поиски окончательной теории. ISBN 978-5-453-00011-1 (УРСС), ISBN 978-5-397-01575-2 (Книжный дом „ЛИБРОКОМ“)
2. Андрей Карпов. Ощущения, которые подтвердились числами. <http://www.viva64.com/ru/b/0158/> | https://habr.com/ru/post/192624/ | null | ru | null |
# Ruby on Rails: user friendly URLs
В данной статье будет показан пример как сделать красивые ссылки в Rails проекте. Ссылки вида `/posts/1/` будут преобразованы в `/posts/1-article-name/`
##### Подготовка
Начнем с того что поставим рельсы последней версии, выполнив в консоли `gem install rails -v=3.1.3`
После окончания процесса установки джема, создаем новый проект командой `rails new nice_urls`. В результате у нас новый чистый проект со всеми установленными джемами, благодаря тому, что в конце генерации проекта автоматически был запущен bundler.
##### Создание постов
Для демонстрации нам подойдет обычный скафолдинг. Давайте сгенерируем его для статей у которых будет название и текст:
`rails g scaffold Post title:string text:text`
Для внесения изменений в БД, выполним миграцию командой `rake db:migrate`. Теперь можно запускать сервер (команда `rails s`) и смотреть на то, что у нас сейчас есть по адресу `localhost:3000/posts`
Перед нами появится привычный интерфейс добавления постов:
##### Красивые ссылки
Идем в `app/views/posts/index.html.erb` и находим строчку, которая формирует ссылку на `show`:
`<%= link_to 'Show', post %>`
Здесь `post` является объектом, который используется при формировании пути. Его стоит заменить такой конструкцией:
`post_path(:id => "#{post.id}-#{post.title.parameterize}")`
Чтобы протестировать формирование ссылок на действие `show`, нужно добавить хотя бы одну статью, у которой будет задано название. Давайте воспользуемся интерфейсом для создания постов и назовем его «The test of nice urls». После создания в листинге постов ссылка должна вести уже не на `/posts/1`, а на `/posts/1-the-test-of-nice-urls`
##### Заключение
Конечно же, код на реальном проекте будет отличаться, оборачиваться в хелперы и вызываться в гораздо более удобной форме. Такое решение подойдет не везде и в некоторых ситуациях будет крайне неудобным. Здесь также не учтена вероятность использования кириллицы | https://habr.com/ru/post/133627/ | null | ru | null |
# Yii 2.0.12
Вышла версия 2.0.12 PHP фреймворка Yii. Инструкции по установке и обновлению ищите [здесь](http://www.yiiframework.com/download/).
Версия 2.0.12 является минорным релизом Yii 2.0. Она включает в себя [более сотни улучшений и исправлений](https://github.com/yiisoft/yii2/blob/2.0.12/framework/CHANGELOG.md).
В релиз вошли несколько изменений, которые могут повлиять на существующие приложения. Эти изменения описаны в [UPGRADE.md](https://github.com/yiisoft/yii2/blob/2.0.12/framework/UPGRADE.md).
Спасибо [сообществу Yii](https://github.com/yiisoft/yii2/graphs/contributors) за поддержку проекта!
За разработкой фреймворка можно следить поставив звёздочку [на GitHub](https://github.com/yiisoft/yii2). Также можно подписаться на [Twitter](https://twitter.com/yiiframework) и [Facebook](https://www.facebook.com/groups/yiitalk/).
Данный релиз задержался, потому как команда была занята другими вещами. Например, мы работаем над [новым сайтом](https://github.com/yiisoft-contrib/yiiframework.com) и [YiiConf
— конференции по Yii](https://yiiconf.ru/), которая пройдёт совсем скоро в Москве.
Так как [Yii 2.1 уже разрабатывается](https://github.com/yiisoft/yii2/tree/2.1), убедитесь, что версия в вашем `composer.json` прописана как `~2.0.12`, а не `>=` или `*`. Так, при релизе 2.1, ваш проект точно не сломается.
Ниже мы рассмотрим самые интересные изменения релиза. Полный список можно посмотреть в [CHANGELOG](https://github.com/yiisoft/yii2/blob/2.0.12/framework/CHANGELOG.md).
Тесты
-----
Покрытие тестами очень важно для своевременного обнаружения проблем. К релизу [@vladis84](https://github.com/vladis84), [@boboldehampsink](https://github.com/boboldehampsink), [@Kolyunya](https://github.com/Kolyunya) и другие члены сообщества Yii помогли нам расширить покрытие кода.
[@schmunk42](https://github.com/schmunk42) настроил дополнительное тестирование на базе docker и развернул его [в GitLab](https://gitlab.com/yiisoft/yii2/pipelines). Некоторые тесты там всё ещё падают. Главным образом, из за отличий в данных для интернационализации. Это будет исправлено немного позже.
Базы данных
-----------
Слой работы с базами получил несколько улучшений в работе с выражениями. Теперь их можно использовать в `\yii\db\QueryTrait::limit()`, `\yii\db\QueryTrait::offset()` и `\yii\data\Sort`.
MSSQL
-----
Поддержка MSSQL существенно улучшилась. Значительно возросла скорость чтения схемы и был реализован метод `yii\db\mssql\QueryBuilder::resetSequence()`.
Безопасность
------------
* `yii\base\Security::hkdf()` был улучшен. Теперь, если это возможно, используется `hash_hkdf()` из PHP >= 7.1.2.
* В `yii\captcha\CaptchaAction` теперь используется `mt_rand()` вместо `rand()` .
Юзабилити
---------
Шаблон миграций теперь по умолчанию использует `safeUp()` и `safeDown()`. В том случае, когда изменения схемы в транзакции не поддерживаются (например, MySQL), изменения применяются без транзакций.
Различные компоненты фреймворка обзавелись значениями по умолчанию:
* `\yii\data\SqlDataProvider` теперь считает записи самостоятельно в том случае, когда `totalCount` не указан.
* Провайдеры данных автоматически выставляют ID. Больше нет необходимости указывать его для случая, когда несколько провайдеров с постраничной разбивкой используется на одной странице.
* Фильтр для `yii\grid\DataColumn` автоматически генерится как выпадающий список в том случае, если `format` выставлен в `boolean`.
Команда `yii cache` начала предупреждать о том, что она не может очистить кеш APC из консоли.
`yii\filters\AccessRule` теперь позволяет передать параметры в функцию проверки роли.
Производительность
------------------
* В `yii\web\UrlManager` добавлена поддержка кеширования вызовов `yii\web\UrlRule::createUrl()` в случае использования правил с умолчаниями.
* В DB command Добавлена опция для отключения логирования и профайлинга.
* `yii\data\ActiveDataProvider` не делает запросы в том случае, когда количество моделей равно нулю.
Всякое
------
`StringHelper` научился работать с URL-безопасным base64 через методы `encode()`/`decode()`. Это может быть полезно для различных токенов.
`yii\helpers\Html::img()` теперь позволяет указать [`srcset`](https://css-tricks.com/responsive-images-youre-just-changing-resolutions-use-srcset/):
```
[php]
echo Html::img('/base-url', [
'srcset' => [
'100w' => '/example-100w',
'500w' => '/example-500w',
'1500w' => '/example-1500w',
],
]);
```
У `yii\widgets\LinkPager` можно рендерить кнопку текущей страницы как disabled. Для этого необходимо выставить `disableCurrentPageButton` в true.
Контроль доступа и валидаторы стали требовать меньше зависимостей:
* `yii\filters\AccessControl` теперь может использоваться без компонента `user`.
* Валидаторы больше не требуют `Yii::$app`. | https://habr.com/ru/post/330324/ | null | ru | null |
# Chrome в dev-версии получил поддержку WebRTC
Анонсированная в начале мая прошлого года технология Web Real-Time Communications (WebRTC) интегрирована в dev-версию Chrome и, по всей видимости, официально появится в одном из следующих релизов браузера.
[WebRTC](http://www.webrtc.org/home) представляет собой открытый фреймворк, попавший в ведение Google после покупки ей компании Global IP Solutions, и реализующий собой технологию передачи в реальном времени видео и аудио напрямую между браузерами. Фактически это означает, что Chrome сможет выполнять те же самые функции, которые сейчас выполняет Skype или другие подобные ему плагины (Google talk), причем с точки зрения разработчиков создание таких приложений будет представлять собой простое использование некоторого JavaScript-API, посмотреть которое можно [здесь](https://sites.google.com/site/webrtc/build). Интересно то, что Mozilla Foundation предлагает свой вклад в WebRTC — спецификацию **MediaStream Processing**, позволяющую программно смешивать аудио-потоки или отслеживать движение в передающемся онлайн видео.
Ключевым понятием в WebRTC API является объект *MediaStream*, который является общим JavaScript-интерфейсом для взаимодействия с аудио- и видео-потоками. Для того, что разработчик смог организовать взаимодействие с ними, он должен иметь инструмент доступа к микрофону и web-камере пользователя — для этой цели служит функция *getUserMedia*. В случае, если эта функция завершилась успешно и доступ к камере и микрофону был получен, разработчику возвращается экземпляр класса *MediaStream*, представляющий из себя, собственно, интерфейс для работы с мультимедиа-данными.
HTML-код страницы, иллюстрирующий работу с WebRTC API.
```
Тест WebRTC
Привет, Хабр!
-------------
video = document.getElementById("live")
navigator.webkitGetUserMedia("video",
function(stream) {
video.src = window.webkitURL.createObjectURL(stream)
},
function(err) {
console.log("Ошибка!")
}
)
```
В данном случае функция *webkitGetUserMedia* получает три параметра, смысл которых заключается в следующем: первый — это строка, определяющая, что мы хотим работать именно с видео, второй — callback-функция, вызываемая в случае успеха попытки доступа к web-камере и, наконец, третий — функция, которая будет вызвана, если получить доступ к оборудованию не удалось по каким-либо причинам.
Строка *window.webkitURL.createObjectURL(stream)* представляет собой получение [Blob URL](http://www.w3.org/TR/FileAPI/#ABNFForBlob) (элемент File API) видео-потока, после чего в объекте *video* и начнется отображение видео.
Согласно спецификациям WebRTC функция *GetUserMedia* должна поинтересоваться у пользователя не возражает ли он, что приложением будет получен доступ к его web-камере, приблизительно так же, как это делает Geolocation API.
[Источники: <[1](http://blog.chromium.org/2012/01/real-time-communications-in-chrome.html)>,<[2](http://arstechnica.com/business/news/2012/01/hands-on-building-an-html5-photo-booth-with-chromes-new-webcam-api.ars)> ] | https://habr.com/ru/post/136605/ | null | ru | null |
# Hyperapp для беженцев с React/Redux
[](https://habrahabr.ru/company/devexpress/blog/349810)
Я люблю Redux
=============
Именно благодаря Redux для меня началось путешествие в мир удивительного функционального программирования. И это первое из функциональщины, что я попробовал в production. Прошли те времена, когда я использовал DOM для хранения состояния и неуверенно манипулировал им с помощью jQuery.
Redux — это инструмент для управления состоянием приложения (state), который позволяет полностью отделить его от представления (view). Представление (view) становится производным состояния (state), которое предоставляет пользователю интерфейс для его изменения. Действия пользователя (actions) не изменяют состояние (state) напрямую. Вместо этого они попадают в редюсер (reducer). Это такая чистая функция, которая на основе предыдущего состояния (state) и действия (action) генерирует следующее состояние (state). Такой подход к обновлению данных во многом был вдохновлен архитектурой языка программирования [Elm](http://elm-lang.org) и концепцией однонаправленного потока данных [Flux](//github.com/facebook/flux). Это, возможно, самая популярная JavaScript-библиотека для иммутабельного изменения состояния из тех, что существуют сегодня. Авторы Redux сфокусировались на решении одной единственной проблемы — управление состоянием приложения (state), и сделали это хорошо. Redux получился достаточно модульным, чтобы работать с различными библиотеками для отображения представления (view).
React использует аналогичный сфокусированный подход для представления (view), имеет эффективный виртуальный DOM, который можно подключить к DOM браузера, нативным мобильным приложениям, VR и прочим платформам.
Что бы создавать надежные, функциональные и легко отлаживаемые web-приложения, можно использовать React и Redux. Правда, потребуются вспомогательные библиотеки вроде react-redux и куча boilerplate-кода. А можно попробовать [Hyperapp](//hyperapp.js.org/).
[Hyperapp](https://github.com/hyperapp/hyperapp) представляет собой единую библиотеку, которая обеспечивает управление состояним приложения (state) и иммутабельность, как в Redux/Elm, в сочетании с отображением представления (view) и Virtual DOM, как в React. [Hyperapp](https://github.com/hyperapp/hyperapp) использует подходы функционального программирования при управлении своим состоянием, но более гибко подходит к разрешению побочных эффектов (side effects), асинхронных действий и манипуляций с DOM. [Hyperapp](https://github.com/hyperapp/hyperapp) предоставляет мощную абстракцию для создания веб-приложений, но при этом дает вам полный доступ к нативным API, чтобы не ограничивать вас.
[](https://twitter.com/okwolf/status/961506418049343489)
Код скажет больше, чем тысяча слов
==================================
Простое приложение-счетчик на React + Redux против эквивалента на [Hyperapp](https://github.com/hyperapp/hyperapp):
Давайте пройдемся по каждому из пронумерованных блоков кода и разберемся, что к чему.
1. Состояние (state)
--------------------
В Redux состояние (state) может быть любого типа, хотя настоятельно рекомендуется выбирать такой тип данных, который легко сериализовать. Подавляющее большинство разработчиков в качестве начального состояния (state) для редюсера (reducer) использует пустой объект.
Не отражено в коде, но вызов `Redux.createStore` принимает в качестве необязательного аргумента начальное состояние (state). В [Hyperapp](https://github.com/hyperapp/hyperapp) состояние (state) всегда является объектом. Вместо двух разных способов инициализации состояния (state) здесь один.
2. Действия (actions)
---------------------
В Redux генераторы действий (action creators) — это функции, которые возвращают действия (actions), как объекты JavaScript. Обычно генераторы действий (action creators) подключаются к Redux хранилищу (store) с помощью `bindActionCreators`, либо автоматически, либо вручную, используя аргумент `mapDispatchToProps` для `ReactRedux.connect`. Действия (actions) обычно определяются как множественный экспорт из одного файла, который затем втягивается в одно пространство имен, используя `import * as actions from "./actions"` при использовании модулей ES6.
В [Hyperapp](https://github.com/hyperapp/hyperapp) — генераторы действий (action creators), редюсеры (reducer) и `bindActionCreators` не нужны. Действия (actions) это чистые функции, которые иммутабельно меняют состояние (state) и имеют все данные необходимые для этого.
3. Изменение состояния (state)
------------------------------
В Redux изменение состояния (state) происходит в редюсере (reducer), который является чистой функцией, принимает состояние (state) и действие (action), возвращая следующее состояние (state). Действие (action) может обновить state (состояние) в любом редюсере (reducer).
Функция изменения состояния (state) имеет следующий вид:
```
(state, action) => nextState
```
[Hyperapp](https://github.com/hyperapp/hyperapp) использует функцию изменения состояния (state) такого вида:
```
(action) => (state [, actions]) => nextState
```
Не отражено в коде, но [Hyperapp](https://github.com/hyperapp/hyperapp) выполняет слияние (merge) состояния. Поэтому вместо `Object.assign` или `{... state, key: "value"}` достаточно просто `return: {key: "value"}`.
4. Представление (view)
-----------------------
В Redux представление (view) должно быть вручную подключено к состоянию (state) и генераторам действий (action creators). Для этого приходится использовать функцию высшего порядка (HOC) `ReactRedux.connect`, которая обертывает ваш компонент для подключения его к Redux хранилищу (store). Чтобы это работало, вы также должны обернуть свое приложение в , что делает ваше хранилище (store) доступным для любых компонентов, которые хотят подключиться к нему.
В [Hyperapp](https://github.com/hyperapp/hyperapp) ваше состояние (state) и действия (actions) автоматически подключаются к вашему представлению (view), и только компоненты верхнего уровня имеют к ним доступ.
Slices
======
Redux и [Hyperapp](https://github.com/hyperapp/hyperapp) поддерживают состояние с вложенными пространствами имен, однако они делают это, используя несколько разные подходы. В [Hyperapp](https://github.com/hyperapp/hyperapp) это идет из коробки — в Redux требуется вручную использовать `combineReducers`.
Код с использованием Redux:
```
const potatoReducer = (potatoState = initialPotatoes, action) => {
switch (action.type) {
case FRY:
// ...
}
}
const tomatoReducer = (tomatoState = initialTomatoes, action) => {
switch (action.type) {
case GRILL:
// ...
}
}
const rootReducer = combineReducers({
potato: potatoReducer,
tomato: tomatoReducer
})
// This would produce the following state object
{
potato: {
// ...potatoes
// and other state managed by the potatoReducer...
},
tomato: {
// ...tomatoes
// and other state managed by the tomatoReducer...
// maybe some nice sauce?
}
}
```
Эквивалентный код с использованием [Hyperapp](https://github.com/hyperapp/hyperapp):
```
const rootState = {
potato: {
// ...just potato things
},
tomato: {
// ...just tomato things
// maybe some nice sauce?
}
}
const rootActions = {
potato: {
// these actions receive only
// the potato state slice and actions
},
tomato: {
// these actions receive only
// the tomato state slice and actions
}
}
```
Async Actions
=============
Пример организации асинхронных действий (acions)
```
const actions = {
upLater: value => (state, actions) => {
setTimeout(actions.up, 1000, value)
},
// Called one second after upLater
up: value => state => ({ count: state.count + value })
}
```
Effects
=======
[](https://github.com/okwolf/hyperapp-effects)
```
import { withEffects, http } from "hyperapp-effects"
const state = {
// ...
}
const actions = {
foo: () => http("/data", "dataFetched"),
dataFetched: data => {
// data will have the JSON-decoded response from /data
}
}
withEffects(app)(state, actions).foo()
```
Можно добавлять собственные эффекты.
Middleware
==========
Для расширения возможностей генераторов действий (action creators) Redux предполагает использование `applyMiddleware` на уровне создания хранилища (store).
[Hyperapp](https://github.com/hyperapp/hyperapp) предполагает ручную композицию actions (действий) и middleware.
```
// Manual composition
hoa3(hoa2(hoa1(app)))(state, actions, view, document.body)
// Or with a standard-issue compose function
compose(hoa3, hoa2, hoa1)(app)(state, actions, view, document.body)
// Compose plays nicely with using different HOAs per environment
const hoas = NODE_ENV === "production" ? productionHoas : devHoas
compose(...hoas)(app)(state, actions, view, document.body)
```
Простым примером middleware является [hyperapp-logger](https://github.com/hyperapp/logger), который выводит информацию на консоль при вызове любого из ваших действий (actions):
[](https://github.com/hyperapp/logger)
```
logger(options)(app)(state, actions, view, document.body)
```
Завершение
==========
[Hyperapp](https://github.com/hyperapp/hyperapp) воспринимает простоту так же серьезно, как и Redux. Сделать сложное простым, а большее меньшим возможно. Исходный код [Hyperapp](https://github.com/hyperapp/hyperapp) составляет ~300 строк кода, который я могу прочитать, когда у меня возникают вопросы, или при отладке, когда у меня есть проблемы. Размер библиотеки всего 1,4 кБ.
Я бегу от своей функциональной родины Redux не потому, что он мне не нравится, а из-за всей боли и страданий, которые вызывают у меня его соседи. Если вы любите Redux, как и я, и ищете лучшего баланса между простым функциональным миром преобразования данных и сложным внешним императивом миром, то я рекомендую вам дать шанс [Hyperapp](https://github.com/hyperapp/hyperapp). | https://habr.com/ru/post/349810/ | null | ru | null |
# «…Желают знать, что будет» или пишем гадальный шар в САПР NanoCAD на C# (MultiCAD .NET API)
Если верить одной старой [песне из советского кинофильма](https://www.youtube.com/watch?v=QgGZwy-CLb0), то люди всегда интересуются вопросами будущего в трудной ситуации. Кто-то подбрасывает монетку, кто-то мучает осьминога Пауля, а совсем уж зверски настроенные люди — ощипывают ромашки. Мы с вами поступим куда как гуманней и найдем для САПР NanoCAD, весьма нетрадиционное применение, а именно сделаем свой аналог гадального шара (почти как на картинке ниже).
В статье мы еще раз потренируемся создавать пользовательские примитивы NanoCAD с помощью MultiCAD.NET API, а также прикрутим к нашему объекту взаимодействие с Windows.Forms.
Код сегодня будет только на C#, писать его будем для платной версии (NC 8.5) и для бесплатной (NC 5.1), ну и естественно пользователи Linux смогут его собрать в Mono и запустить под Wine, поэтому милости прошу под кат…
Если вы раньше не сталкивались, со статьями из этого мини-цикла, то можно заглянуть под спойлер. В прошлых статьях мы рассмотрели разные вопросы от того, что такое NanoCAD, до попыток запустить наши проекты под Linux.
**Другие статьи цикла*** [«Лицо без шрама» или первые шаги в Multicad.NET API 7 (для Nanocad 8.1)](https://habrahabr.ru/post/342186/)
* [«Как баран на новые ворота» или пользовательские «псевдо-3D» объекты в NanoCAD с помощью MultiCAD.NET API](https://habrahabr.ru/post/342680/)
* [«Я слежу за тобой» или как из CADa сделать SCADA (MultiCAD.NET API)](https://habrahabr.ru/post/343772/)
* [«Истина в вине» или пробуем программировать NanoCAD под Linux (MultiCAD.NET API)](https://habrahabr.ru/post/344884/)
* [«Здравствуй елка — Новый Год!» или программируем NanoCAD с помощью Visual Basic .NET](https://habrahabr.ru/post/345834/)
Как всегда, напомню, что я не программист и поэтому **не все мои мысли** в данной статье могут быть корректными, а также что с разработчиками NanoCAD **я никак не ангажирован** . Хотя безусловно считаю нужным — сказать **спасибо** всему сообществу пользователей и разработчиков NanoCAD за их помощь на форуме.
Пусть вас не удивляет, что мы опять будем использовать САПР для создания объектов, никак не связанных с проектированием. Просто, мне надо было потренироваться «вставлять» Windows.Forms в пользовательские объекты NanoCAD, а поскольку учебных материалов по API для Нанокада – «кот наплакал», то я решил с вами поделиться своим простым и наглядным примером.
Статья будет короткая и можно было бы обойтись без содержания, но я на всякий случай его для удобства навигации оставлю.
Содержание:
[Часть I: введение](#I)
[Часть II: пишем код на C#](#II)
[Часть III: заключение](#III)
Надо сказать, что несмотря, на то, что учебных материалов меньше чем хотелось бы, при написании кода нам будет на что опираться.
В частности, про создание пользовательского примитива уже писали разработчики [в своем блоге на Хабре](https://habrahabr.ru/company/nanosoft/blog/184482/), ну и вопрос с интеллектуальными ручками, [тоже ранее ими разбирался](https://habrahabr.ru/company/nanosoft/blog/234181/). В принципе мы сегодня сильно за рамки этих двух статей не выйдем.
Обычно в начале статьи я пишу, как создать с нуля проект для NanoCAD, но в этот раз из-за наличия класса с оконной формой я решил выложить весь проект на [GitHub](https://github.com/bosonbeard/Funny-models-and-scripts/tree/master/2.ForNanoCAD/2.Some_simple_scripts/4.Fortuneteller), поэтому его можно просто скачать, подключить библиотеки и сразу начать экспериментировать.
Но если для вас разработка под Нанокад – в новинку, посмотрите вот этот кусочек прошлой статьи ([для NC 8.5](https://habrahabr.ru/post/342680/#II) и [для NC 5.1](https://habrahabr.ru/post/342680/#III) ).
Я решил на всякий случай не «обижать» разработчиков NanoCAD и не стал прикладывать к проекту необходимые библиотеки из пакета SDK. Данные библиотеки вы сможете найти либо в папке “bin”, установленной программы, либо получив пакет SDK. Для NC 8.5 и других версий необходимо зарегистрировать [в клубе разработчиков](http://developer.nanocad.ru/). На всякий случай напомню, что скачать любую доступную версию NC для целей разработки, участники клуба могут совершенно бесплатно. Ну а для бесплатного NC 5.1 — SDK вроде бы поставляется в комплекте с программой (если ничего не поменялось).
Итак, начнем разбирать код, я не буду прикладывать автоматически созданный код формы, а ограничусь только классом пользовательского примитива (собственно сам шар) и логикой формы.
Для начала спрячем под спойлером полный код для платной версии NanoCAD.
**Полный код для NC 8.5 на C#**
```
// Version 1.0
//Use Microsoft .NET Framework 4 and MultiCad.NET API 7.0
//Class for demonstrating the capabilities of MultiCad.NET
//Assembly for the Nanocad 8.5 SDK is recommended (however, it is may be possible in the all 8.Х family)
//Link imapimgd, mapimgd.dll and mapibasetypes.dll from SDK
//Link System.Windows.Forms and System.Drawing
//The commands: draws a fortune-teller ball
//This code in the part of non-infringing rights Nanosoft can be used and distributed in any accessible ways.
//For the consequences of the code application, the developer is not responsible.
//More detailed - https://habrahabr.ru/post/347720/
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
using Multicad.AplicationServices;
namespace Fortuneteller
{
[CustomEntity(typeof(Ball), "2e814ea6-f1f0-469d-9767-269fedb32226", "Ball", "Fortuneteller Ball for NC85 Entity")]
[Serializable]
public class Ball : McCustomBase
{
private Point3d _basePnt = new Point3d(0, 0, 0);
double _radius=300;
string _predText = "...";
public List predictions =
new List()
{"Act now!",
"Do not do this!",
"Maybe",
"I dont know",
"Everything is unclear",
"Yes!",
"No!",
"Take rest"
};
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
dc.Color = McDbEntity.ByObject;
dc.DrawCircle(\_basePnt, \_radius);
dc.DrawCircle(\_basePnt, \_radius/2.0);
dc.TextHeight = 31;
dc.DrawMText(\_basePnt, Vector3d.XAxis, \_predText, HorizTextAlign.Center, VertTextAlign.Center, \_radius / 2.05);
}
public override void OnTransform(Matrix3d tfm)
{
// To be able to cancel(Undo)
McUndoPoint undo = new McUndoPoint();
undo.Start();
// Get the coordinates of the base point and the rotation vector
this.TryModify();
this.\_basePnt = this.\_basePnt.TransformBy(tfm);
undo.Stop();
}
public override hresult OnEdit(Point3d pnt, EditFlags lInsertType)
{
CallForm();
return hresult.s\_Ok;
}
private void CallForm()
{
ListEditorForm frm = new ListEditorForm(this);
frm.Lpredictions.Items.AddRange(predictions.ToArray());
frm.ShowDialog();
}
[CommandMethod("DFTBall", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawBall ()
{
Ball ball = new Ball();
ball.PlaceObject();
McContext.ShowNotification("Use green grip or shake (move) ball to get prediction");
}
public override bool GetGripPoints(GripPointsInfo info)
{
//frist grip to move
info.AppendGrip(new McSmartGrip(\_basePnt+new Vector3d(0, \_radius,0), (obj, g, offset) => {
obj.TryModify();
obj.\_basePnt += offset;
obj.TryModify();
obj.ShakePredict();
}));
//command grip
var ctxGrip = new McSmartGrip(McBaseGrip.GripType.PopupMenu, 2, \_basePnt - 1.0 \* new Vector3d(\_radius, 0, 0),
McBaseGrip.GripAppearance.PopupMenu, 0, "Select menu", Color.Lime);
ctxGrip.GetContextMenu = (obj, items) =>
{
items.Add(new ContextMenuItem("Get prediction", "none", 1));
items.Add(new ContextMenuItem("Edit predictions", "none", 2));
};
ctxGrip.OnCommand = (obj, commandId, grip) =>
{
if (grip.Id == 2)
{
switch (commandId)
{
case 1:
{
ShakePredict();
break;
}
case 2:
{
CallForm();
break;
}
}
}
};
info.AppendGrip(ctxGrip);
return true;
}
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select center point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e\_Fail;
\_basePnt = res.Point;
// Add the object to the database
DbEntity.AddToCurrentDocument();
return hresult.s\_Ok;
}
private void ShakePredict()
{
Random rand = new Random();
int val = rand.Next(0, predictions.Count);
this.TryModify();
\_predText = predictions[val];
}
}
}
```
Теперь разберем ключевые моменты по частям.
```
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
using Multicad.AplicationServices;
namespace Fortuneteller
{
[CustomEntity(typeof(Ball), "2e814ea6-f1f0-469d-9767-269fedb32226", "Ball", "Fortuneteller Ball for NC85 Entity")]
[Serializable]
public class Ball : McCustomBase
{
```
Подключаем пространства имен, создаем класс пользовательского объекта, присвоим ему какой-нибудь случайно сгенерированный GUID, наследуем наш класс от McCustomBase.
```
private Point3d _basePnt = new Point3d(0, 0, 0);
double _radius=300;
string _predText = "...";
public List predictions =
new List()
{"Act now!",
"Do not do this!",
"Maybe",
"I dont know",
"Everything is unclear",
"Yes!",
"No!",
"Take rest"
};
```
Задаём основные переменные для нашего гадального шара: точку центра геометрии, радиус, текст в окошке предсказания и список вариантов предсказания.
```
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
dc.Color = McDbEntity.ByObject;
dc.DrawCircle(_basePnt, _radius);
dc.DrawCircle(_basePnt, _radius/2.0);
dc.TextHeight = 31;
dc.DrawMText(_basePnt, Vector3d.XAxis, _predText, HorizTextAlign.Center, VertTextAlign.Center, _radius / 2.05);
}
```
Метод отвечает за отрисовку объекта. Чертим два круга и объект многострочного текста.
```
public override void OnTransform(Matrix3d tfm)
{
// To be able to cancel(Undo)
McUndoPoint undo = new McUndoPoint();
undo.Start();
// Get the coordinates of the base point and the rotation vector
this.TryModify();
this._basePnt = this._basePnt.TransformBy(tfm);
undo.Stop();
}
```
Метод вызывается при изменении объекта, не на 100% понимаю, как он работает, но он будет нужен для того, чтобы корректно перемещать объект.
```
public override hresult OnEdit(Point3d pnt, EditFlags lInsertType)
{
CallForm();
return hresult.s_Ok;
}
```
Метод будет вызывать нашу форму (см. картинку в конце статьи) в момент, когда мы сделаем двойной клик по шару.
```
private void CallForm()
{
ListEditorForm frm = new ListEditorForm(this);
frm.Lpredictions.Items.AddRange(predictions.ToArray());
frm.ShowDialog();
}
```
Непосредственно вызов формы. Форма нам нужна для того, чтобы добавить или удалить варианты предсказаний, которые выпадают в шаре.
Мы заранее создали класс формы ListEditorForm и теперь при необходимости создаем объект, передав ему ссылку на наш шар (нужно для обратной связи), перед тем как вызвать форму заполняем её ListBox текущим списком предсказаний.
```
[CommandMethod("DFTBall", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawBall()
{
Ball ball = new Ball();
ball.PlaceObject();
McContext.ShowNotification("Use green grip or shake (move) ball to get prediction");
}
```
Команда, с помощью которой мы и будем создавать наш гадальный шар.
В самом простом случае в консоли NanoCAD надо будет ввести DFTBall и он вызовет наш метод DrawBall (не забудьте при необходимости загрузить библиотеку командой Netload).
```
public override bool GetGripPoints(GripPointsInfo info)
{
//first grip to move
info.AppendGrip(new McSmartGrip(\_basePnt+new Vector3d(0, \_radius,0), (obj, g, offset) => {
obj.TryModify();
obj.\_basePnt += offset;
obj.TryModify();
obj.ShakePredict();
}));
//command grip
var ctxGrip = new McSmartGrip(McBaseGrip.GripType.PopupMenu, 2, \_basePnt - 1.0 \* new Vector3d(\_radius, 0, 0),
McBaseGrip.GripAppearance.PopupMenu, 0, "Select menu", Color.Lime);
ctxGrip.GetContextMenu = (obj, items) =>
{
items.Add(new ContextMenuItem("Get prediction", "none", 1));
items.Add(new ContextMenuItem("Edit predictions", "none", 2));
};
ctxGrip.OnCommand = (obj, commandId, grip) =>
{
if (grip.Id == 2)
{
switch (commandId)
{
case 1:
{
ShakePredict();
break;
}
case 2:
{
CallForm();
break;
}
}
}
};
info.AppendGrip(ctxGrip);
return true;
}
```
Здесь мы задаем ручки объекта — синюю и зеленую.
Первая — синяя ручка нужна для перемещения объекта. Перетаскивая шар за синюю ручку его можно потрясти и вы увидите, как меняется строка предсказаний.
Вторая — зеленая ручка (секция //command grip), нужна нам для того, чтобы вывести окошко с двумя командами. Первая генерирует новое предсказание, вторая вызывает редактор списка предсказаний.
```
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select center point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e_Fail;
_basePnt = res.Point;
// Add the object to the database
DbEntity.AddToCurrentDocument();
return hresult.s_Ok;
}
```
Этот код вызывается для размещения объекта в пространстве модели. Вначале мы создаем объект InputJig, через него запрашиваем точку вставки, изменяем координаты нашей точки геометрического центра шара и добавляем объект в документ.
```
private void ShakePredict()
{
Random rand = new Random();
int val = rand.Next(0, predictions.Count);
this.TryModify();
_predText = predictions[val];
}
```
Ну а тут с помощью простейшего генератора случайных чисел мы возвращаем какое-нибудь предсказание из общего списка.
Мы не будем разбирать подробно логику работы формы, полный код я спрячу под спойлер
**код класса ListEditorForm**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace Fortuneteller
{
public partial class ListEditorForm : Form
{
private Ball ball;
public ListEditorForm()
{
InitializeComponent();
}
public ListEditorForm(Ball ball)
{
this.ball = ball;
InitializeComponent();
}
private void listView1_SelectedIndexChanged(object sender, EventArgs e)
{
}
private void DelBtn_Click(object sender, EventArgs e)
{
if (Lpredictions.SelectedItem !=null)
{
Lpredictions.Items.Remove(Lpredictions.SelectedItem);
}
}
private void AdBtn_Click(object sender, EventArgs e)
{
if (textBox.Text!="" | textBox.Text != " ")
{
Lpredictions.Items.Add(textBox.Text);
}
}
private void SaceBtn_Click(object sender, EventArgs e)
{
ball.predictions = Lpredictions.Items.OfType().ToList();
this.Close();
}
}
}
```
Пожалуй, единственное, что хоть как-то тут связанно с NanoCAD это обработчик события кнопки «сохранить и закрыть».
```
private void SaceBtn_Click(object sender, EventArgs e)
{
ball.predictions = Lpredictions.Items.OfType().ToList();
this.Close();
}
```
Помните мы раньше передавали форме ссылку на наш шар? Теперь мы, обращаясь к нему записываем в список предсказаний все значения нашего ListBox и закрываем форму, после этого шар начнет выдавать обновленные предсказания. Если форму закрыть, нажав на «крестик», то результат не сохранится.
Код для старого — бесплатного Нанокада, сильно отличатся не будет.
**код для NanoCAD 5.1**
```
// Version 1.0
//Use Microsoft .NET Framework 3.5 and MultiCad.NET API
//Class for demonstrating the capabilities of MultiCad.NET
//Assembly for the Nanocad 5.1 SDK is recommended
//Link mapimgd.dll and hostmgd.dll from SDK
//Link System.Windows.Forms and System.Drawing
//The commands: draws a fortune-teller ball
//This code in the part of non-infringing rights Nanosoft can be used and distributed in any accessible ways.
//For the consequences of the code application, the developer is not responsible.
//More detailed - https://habrahabr.ru/post/347720/
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using Multicad.Runtime;
using Multicad.DatabaseServices;
using Multicad.Geometry;
using Multicad.CustomObjectBase;
using Multicad;
using HostMgd.ApplicationServices;
using HostMgd.EditorInput;
namespace Fortuneteller
{
[CustomEntity(typeof(Ball), "2e814ea6-f1f0-469d-9767-269fedb32195", "Ball", "Fortuneteller Ball for NC51 Entity")]
[Serializable]
public class Ball : McCustomBase
{
private Point3d _basePnt = new Point3d(0, 0, 0);
double _radius=300;
string _predText = "...";
public List predictions =
new List()
{"Act now!",
"Do not do this!",
"Maybe",
"I dont know",
"Everything is unclear",
"Yes!",
"No!",
"Take rest"
};
public override void OnDraw(GeometryBuilder dc)
{
dc.Clear();
dc.Color = McDbEntity.ByObject;
dc.DrawCircle(\_basePnt, \_radius);
dc.DrawCircle(\_basePnt, \_radius/2.0);
dc.TextHeight = 31;
dc.DrawMText(\_basePnt, Vector3d.XAxis, \_predText, HorizTextAlign.Center, VertTextAlign.Center, \_radius / 2.05);
}
public override void OnTransform(Matrix3d tfm)
{
// To be able to cancel(Undo)
McUndoPoint undo = new McUndoPoint();
undo.Start();
// Get the coordinates of the base point and the rotation vector
this.TryModify();
this.\_basePnt = this.\_basePnt.TransformBy(tfm);
undo.Stop();
}
public override hresult OnEdit(Point3d pnt, EditFlags lInsertType)
{
CallForm();
return hresult.s\_Ok;
}
private void CallForm()
{
ListEditorForm frm = new ListEditorForm(this);
frm.Lpredictions.Items.AddRange(predictions.ToArray());
frm.ShowDialog();
}
[CommandMethod("DFTBall", CommandFlags.NoCheck | CommandFlags.NoPrefix)]
public void DrawBall()
{
Ball ball = new Ball();
ball.PlaceObject();
DocumentCollection dm = HostMgd.ApplicationServices.Application.DocumentManager;
Editor ed = dm.MdiActiveDocument.Editor;
ed.WriteMessage("Use green grip or shake (move) ball to get prediction");
}
public override bool GetGripPoints(GripPointsInfo info)
{
//frist grip to move
info.AppendGrip(new McSmartGrip(\_basePnt+new Vector3d(0, \_radius,0), (obj, g, offset) => {
obj.TryModify();
obj.\_basePnt += offset;
obj.TryModify();
obj.ShakePredict();
}));
//command grip
var ctxGrip = new McSmartGrip(McBaseGrip.GripType.PopupMenu, 2, \_basePnt - 1.0 \* new Vector3d(\_radius, 0, 0),
McBaseGrip.GripAppearance.PopupMenu, 0, "Select menu", Color.Lime);
ctxGrip.GetContextMenu = (obj, items) =>
{
items.Add(new ContextMenuItem("Get prediction", "none", 1));
items.Add(new ContextMenuItem("Edit predictions", "none", 2));
};
ctxGrip.OnCommand = (obj, commandId, grip) =>
{
if (grip.Id == 2)
{
switch (commandId)
{
case 1:
{
ShakePredict();
break;
}
case 2:
{
CallForm();
break;
}
}
}
};
info.AppendGrip(ctxGrip);
return true;
}
public override hresult PlaceObject(PlaceFlags lInsertType)
{
InputJig jig = new InputJig();
// Get the first box point from the jig
InputResult res = jig.GetPoint("Select center point:");
if (res.Result != InputResult.ResultCode.Normal)
return hresult.e\_Fail;
\_basePnt = res.Point;
// Add the object to the database
DbEntity.AddToCurrentDocument();
return hresult.s\_Ok;
}
private void ShakePredict()
{
Random rand = new Random();
int val = rand.Next(0, predictions.Count);
this.TryModify();
\_predText = predictions[val];
}
}
}
```
Вся разница по сути только в следующем: из-за того, что *McContext.ShowNotification(«Use green grip or shake (move) ball to get prediction»)* еще не реализован в старой версии MultiCAD.NET API, мы его заменили на аналог из простого .NET API.
```
DocumentCollection dm = HostMgd.ApplicationServices.Application.DocumentManager;
Editor ed = dm.MdiActiveDocument.Editor;
ed.WriteMessage("Use green grip or shake (move) ball to get prediction");
```
Итак, в итоге мы получили шар, который может выдавать предсказания, если его перетаскивать за синюю ручку или по команде спрятанной в зеленой ручке.
Также мы рассмотрели, простейший пример взаимодействия графической формы и объекта, реализовав редактирование переменной содержащей список предсказаний. Напомню, что вызов формы производится по двойному щелчку на объект или через зеленую ручку.
Вот что получили в итоге
Nanocad 8.5
Nanocad 5.1 Free
Понятно, что данный пример — шуточный и практической пользы не имеет, но надеюсь, что он все же кому-нибудь пригодится.
Всем удачного дня!
*P.S. На всякий случай предупрежу, что последнее обновление Windows 10 немного ломает x64 версию NanoCAD 8, поэтому весь код тестировался в x86 версиях.* | https://habr.com/ru/post/347720/ | null | ru | null |
# Конфигурация Salt
После успешной установки необходимых пакетов SaltStack приступаем к настройке.
Установка описана [здесь](https://habrahabr.ru/post/315054/).
### Конфигурация Salt
Конфигурация Salt очень проста. Дефолтная конфигурация Мастера будет работать в большинстве установок и единственное требование для настройки Миньона установить местоположение Мастера в конфигурационном файле.
Конфигурационные файлы будут установлены в **/etc/salt** и названы в честь соответствующих компонент, **/etc/salt/master** и **/etc/salt/minion**.
### Конфигурация Мастера
По умолчанию Мастер слушает порты **4505** и **4506** на всех интерфейсах (0.0.0.0). Для связки Salt с конкретным IP переопределите параметр **“interface”** в **/etc/salt/master**
```
- #interface: 0.0.0.0
+ interface: 10.0.0.1
```
После правки перезапустите сервис **salt-master**. Подробнее смотрите [справочник по настройке Мастера](https://docs.saltstack.com/en/latest/ref/configuration/master.html).
### Конфигурация Миньона
Хотя и существует много параметров конфигурации, настройка Salt Minion очень проста. По умолчанию пробует подключиться по DNS имени **“salt”**.
Если Миньон может корректно разрешить имя, то никакой настройки не требуется. Если Миньон не может корректно разрешить имя, то переопределите параметр **“master”** в конфигурационном файле **/etc/salt/minion**:
```
- #master: salt
+ master: 10.0.0.1
```
После правки перезапустите сервис **salt-minion**.
### Запуск Salt
Мастер может быть запущен в фоновом режиме через командную строку как демон:
```
# salt-master -d
```
Мастер может быть также запущен в **debug** режиме, таким образом значительно увеличивая вывод команд:
```
# salt-master -l debug
# salt-master --log-level=debug
```
**Запуск от непривилегированого пользователя**
Для запуска Salt от другого пользователя, установите параметр **user** в **/etc/salt/master**.
Дополнительно, необходимо установить владельца и права так, чтобы нужный пользователь имел права на чтение/запись на след. каталоги (и их подкаталоги, где применимо):
```
/etc/salt
/var/cache/salt
/var/log/salt
/var/run/salt
```
```
# chown -R user /etc/salt /var/cache/salt /var/log/salt /var/run/salt
```
### Проверка подлинности ключа
Salt обеспечивает команды для проверки подлинности Вашего Salt Master и Salt-Minion перед началом обмена ключами. Проверка ключа помогает избежать непреднамеренного подключения к неверному Salt Master и помогает предотвратить потенциальные **MiTM** атаки при установлении начального соединения.
### Отпечаток ключа Мастера
Напечатайте отпечаток ключа Мастера запустив следующую команду на Salt Master:
```
# salt-key -F master
Local Keys:
master.pem: 6c:a0:e8:b0:84:36:59:86:b6:49:c3:fb:87:a4:c4:e9
master.pub: d9:c6:e0:42:76:e5:82:f7:13:6a:65:ee:cb:f3:2e:aa
```
Скопируйте **master.pu**b отпечаток из секции **Local Keys** и установите в качестве параметра **master\_finger** в конфигурационном файле Миньона. Сохраните и перезапустите сервис **salt-minion**.
### Отпечаток ключа Миньона
Запустите следующую команду на каждом Salt minion, чтобы вывести отпечаток ключа миньона:
```
# salt-call --local key.finger
```
Сравните это значение с значением, которое выводится когда запускаешь команду на Salt Master
```
# salt-key --finger
```
### Управление ключами
Salt использует **AES** шифрование для всех коммуникаций между Мастером и Миньоном. Это гарантирует что команды отправляемые Миньонам могут быть подделаны и что связь между Мастером и Миньоном подтверждается доверенными принятыми ключами.
Прежде чем команды могут быть отправлены Миньону, его ключ должен быть принят на Мастере. Запустите **salt-key** команду, чтобы вывести список ключей известных Мастеру:
```
# salt-key -L
Accepted Keys:
salt01.local
Denied Keys:
Unaccepted Keys:
Rejected Keys:
```
Команда **salt-key** позволяет принимать ключи как поштучно, так и разом.
Чтобы принять все ключи, которые находяться в ожидании:
```
# salt-key -A
```
Чтобы принять конкретный ключ:
```
# salt-key -a minion01.local
```
→ [man по salt-key](https://docs.saltstack.com/en/latest/ref/cli/salt-key.html)
### Отправка команд
Связь между Мастером и Миньоном можно проверить запустив команду **test.ping**:
```
# salt alpha test.ping
alpha:
True
```
Связь между Мастером и всеми Миньонами можно проверить запустив команду
```
# salt '*' test.ping
alpha:
True
bravo:
True
charlie:
True
delta:
True
```
Каждый Миньон должен послать ответ **True**, как показано выше.
→ [Источник](https://docs.saltstack.com/en/latest/ref/configuration/index.html) | https://habr.com/ru/post/315056/ | null | ru | null |
# Ansible-vault decrypt: обходимся без Ansible
Исходные данные
---------------
**Дано**:
* конвейер CI/CD, реализованный, к примеру, в GitLab. Для корректной работы ему требуются, как это очень часто бывает, некие секреты - API-токены, пары логи/пароль, приватные SSH-ключи - да всё, о чём только можно подумать;
* работает этот сборочный конвейер, как это тоже часто бывает, на базе контейнеров. Соответственно, чем меньше по размеру образы - тем лучше, чем меньше в них всякой всячины - тем лучше.
**Требуется** консольная утилита, которая:
* занимает минимум места;
* умеет расшифровывать секреты, зашифрованные `ansible-vault`;
* не требует никаких внешних зависимостей;
* умеет читать ключ из файла.
Я думаю, что люди, причастные к созданию сборочных конвейеров, по достоинству смогут оценить каждое из этих требований. Ну а что у меня получилось в результате - читайте далее.
На всякий случай сразу напоминаю, что по действующему законодательству разработка средств криптографической защиты информации в РФ - [лицензируемая деятельность](http://clsz.fsb.ru/clsz/license.htm). Иначе говоря, без наличия лицензии вы не можете просто так взять и продавать получившееся решение.
По поводу допустимости полных текстов расшифровщиков в статьях вроде этой - надеюсь, что компетентные в этом вопросе читатели смогут внести свои уточнения в комментариях.
Начнём сначала
--------------
Итак, предположим, что у нас на Linux-хосте с CentOS 7 уже установлен Ansible, к примеру, версии 2.9 для Python версии 3.6. Установлен, конечно же, с помощью `virtualenv` в каталог "`/opt/ansible`". Дальше для целей удовлетворения чистого научного любопытства возьмём какой-нибудь YaML-файл, и зашифруем его с помощью утилиты `ansible-vault`:
```
ansible-vault encrypt vaulted.yml --vault-password-file=.password
```
Этот вызов, как можно догадаться, зашифрует файл `vaulted.yml` с помощью пароля, который хранится в файле `.password`.
Итак, что получается после зашифровывания файла с помощью утилиты `ansible-vault`? На первый взгляд - белиберда какая-то, поэтому спрячу её под спойлер:
Содержимое файла vaulted.yml
```
$ANSIBLE_VAULT;1.1;AES256
61373536353963313739366536643661313861663266373130373730666634343337356536333664
3365393033623439356364663537353365386464623836640a356464633264626330383232353362
63613135373638393665663962303530323061376432333931306161303966633338303565666337
6465393837636665300a633732313730626265636538363339383237306264633830653665343639
30353863633137313866393566643661323536633666343837623130363966613363373962343630
34386234633236363363326436666630643937313630346230386538613735366431363934316364
37346337323833333165386534353432386663343465333836643131643237313262386634396534
38316630356530626430316238383364376561393637363262613666373836346262666536613164
66316638343162626631623535323666643863303231396432666365626536393062386531623165
63613934323836303536613532623864303839313038336232616134626433353166383837643165
643439363835643731316238316439633039
```
Ну а как именно эта белиберда работает "под капотом" - давайте разбираться.
Открываем файл `/opt/ansible/lib/python3.6/site-packages/ansible/parsing/vault/__init__.py`, и в коде метода `encrypt` класса `VaultLib` видим следующий вызов:
VaultLib.encrypt
```
...
b_ciphertext = this_cipher.encrypt(b_plaintext, secret)
...
```
То есть результирующее содержимое нашего файла будет создано в результате вызова метода `encrypt` некоторого класса. Какого именно - в общем-то, невелика загадка, ниже по файлу есть всего один класс с именем `VaultAES256`.
Смотрим в его метод `encrypt`:
VaultAES256.encrypt
```
@classmethod
def encrypt(cls, b_plaintext, secret):
if secret is None:
raise AnsibleVaultError('The secret passed to encrypt() was None')
b_salt = os.urandom(32)
b_password = secret.bytes
b_key1, b_key2, b_iv = cls._gen_key_initctr(b_password, b_salt)
if HAS_CRYPTOGRAPHY:
b_hmac, b_ciphertext = cls._encrypt_cryptography(b_plaintext, b_key1, b_key2, b_iv)
elif HAS_PYCRYPTO:
b_hmac, b_ciphertext = cls._encrypt_pycrypto(b_plaintext, b_key1, b_key2, b_iv)
else:
raise AnsibleError(NEED_CRYPTO_LIBRARY + '(Detected in encrypt)')
b_vaulttext = b'\n'.join([hexlify(b_salt), b_hmac, b_ciphertext])
# Unnecessary but getting rid of it is a backwards incompatible vault
# format change
b_vaulttext = hexlify(b_vaulttext)
return b_vaulttext
```
То есть перво-наперво генерируется "соль" длиной 32 байта. Затем из побайтного представления пароля и "соли" вызовом `_gen_key_initctr` генерируется пара ключей (`b_key1`, `b_key2`) и вектор инициализации (`b_iv`).
Генерация ключей
----------------
Что же происходит в `_gen_key_initctr`?
\_gen\_key\_initctr:
```
@classmethod
def _gen_key_initctr(cls, b_password, b_salt):
# 16 for AES 128, 32 for AES256
key_length = 32
if HAS_CRYPTOGRAPHY:
# AES is a 128-bit block cipher, so IVs and counter nonces are 16 bytes
iv_length = algorithms.AES.block_size // 8
b_derivedkey = cls._create_key_cryptography(b_password, b_salt, key_length, iv_length)
b_iv = b_derivedkey[(key_length * 2):(key_length * 2) + iv_length]
elif HAS_PYCRYPTO:
# match the size used for counter.new to avoid extra work
iv_length = 16
b_derivedkey = cls._create_key_pycrypto(b_password, b_salt, key_length, iv_length)
b_iv = hexlify(b_derivedkey[(key_length * 2):(key_length * 2) + iv_length])
else:
raise AnsibleError(NEED_CRYPTO_LIBRARY + '(Detected in initctr)')
b_key1 = b_derivedkey[:key_length]
b_key2 = b_derivedkey[key_length:(key_length * 2)]
return b_key1, b_key2, b_iv
```
Если по сути, то внутри этого метода вызов `_create_key_cryptography` на основе пароля, "соли", длины ключа и длины вектора инициализации генерирует некий производный ключ (строка 10 приведённого фрагмента). Далее этот производный ключ разбивается на части, и получаются те самые `b_key1`, `b_key2` и `b_iv`.
Следуем по кроличьей норе дальше. Что внутри `_create_key_cryptography`*?*
\_create\_key\_cryptography:
```
@staticmethod
def _create_key_cryptography(b_password, b_salt, key_length, iv_length):
kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=2 * key_length + iv_length,
salt=b_salt,
iterations=10000,
backend=CRYPTOGRAPHY_BACKEND)
b_derivedkey = kdf.derive(b_password)
return b_derivedkey
```
Ничего особенного. Если оставить в стороне всю мишуру, то в итоге вызывается функция библиотеки OpenSSL под названием `PBKDF2HMAC` с нужными параметрами. Можете, кстати, самолично в этом убедиться, открыв файл `/opt/ansible/lib/python3.6/site-packages/cryptography/hazmat/backends/openssl/backend.py.`
Кстати, длина производного ключа, как видите, специально выбирается таким образом, чтобы хватило и на `b_key1`, и на `b_key2`, и на `b_iv`.
Собственно шифрование
---------------------
Движемся дальше. Здесь нас встречает вызов `_encrypt_cryptography` с параметрами в виде открытого текста, обоих ключей и вектора инициализации:
\_encrypt\_cryptography
```
@staticmethod
def _encrypt_cryptography(b_plaintext, b_key1, b_key2, b_iv):
cipher = C_Cipher(algorithms.AES(b_key1), modes.CTR(b_iv), CRYPTOGRAPHY_BACKEND)
encryptor = cipher.encryptor()
padder = padding.PKCS7(algorithms.AES.block_size).padder()
b_ciphertext = encryptor.update(padder.update(b_plaintext) + padder.finalize())
b_ciphertext += encryptor.finalize()
# COMBINE SALT, DIGEST AND DATA
hmac = HMAC(b_key2, hashes.SHA256(), CRYPTOGRAPHY_BACKEND)
hmac.update(b_ciphertext)
b_hmac = hmac.finalize()
return to_bytes(hexlify(b_hmac), errors='surrogate_or_strict'), hexlify(b_ciphertext)
```
В принципе, тут нет ничего особенного: шифр инициализируется из вектора `b_iv`, затем первым ключом `b_key1` шифруется исходный текст, а результат этого шифрования хэшируется с помощью второго ключа `b_key2`.
Полученные в итоге байты подписи и шифртекста преобразуются в строки своих шестнадцатеричных представлений через `hexlify`. (см. строка 14 фрагмента выше)
Окончательное оформление файла
------------------------------
Возвращаемся к строкам 16-20 фрагмента [VaultAES256.encrypt:](http://vaultencrypt) три строки, содержащие "соль", подпись и шифртекст, склеиваются вместе, после чего снова преобразуются в шестнадцатеричное представление (комментарий прямо подсказывает, что это - для обратной совместимости).
Дальше дописывается заголовок (помните, тот самый - `$ANSIBLE_VAULT;1.1;AES256)`, ну и, в общем-то, всё.
Обратный процесс
----------------
После того, как мы разобрались в прямом процессе, реализовать обратный будет не слишком сложно - по крайней мере, если выбрать правильный инструмент.
Понятно, что Python нам не подходит, иначе можно было и огород не городить: ansible-vault одинаково хорошо работает в обе стороны. С другой стороны, никто не мешает на базе библиотек Ansible написать что-либо своё - в качестве разминки перед "подходом к снаряду" я так и сделал, и о результате напишу отдельную статью.
Тем не менее, для написания предмета статьи я воспользовался FreePascal. Ввиду того, что языковой холивар темой статьи не является, буду краток: выбрал этот язык, во-первых, потому что могу, а во-вторых - потому что получаемый бинарник удовлетворяет заданным требованиям.
Итак, нам понадобятся: FreePascal версии 3.0.4 (эта версия в виде готовых пакетов - самая свежая, нормально устанавливающаяся в CentOS 7), и библиотека DCPCrypt версии 2.1 ([на GitHub](https://github.com/StephenGenusa/DCPCrypt)). Интересно, что прямо вместе с компилятором (`fpc`) и обширным набором библиотек в rpm-пакете поставляется консольная среда разработки `fp`.
К сожалению, "искаропки" модули этой библиотеки не собираются компилятором `fpc` - в них нужны минимальные правки. С другой стороны, я предполагаю, что без этих правок предмет статьи перестаёт относиться к лицензируемым видам деятельности и начинает представлять чисто академический интерес - именно поэтому выкладываю статью без них.
Часть кода, относящуюся к генерированию производного ключа (реализацию той самой функции PBKDF2), я нашёл [в](https://keit.co/p/dcpcrypt-hmac-rfc2104/) [интернете](http://keit.co/p/dcpcrypt-hmac-rfc2104/), и поместил в отдельный модуль под названием "kdf".
Вот этот модуль собственной персоной:
kdf.pas
```
{$MODE OBJFPC}
// ALL CREDITS FOR THIS CODE TO https://keit.co/p/dcpcrypt-hmac-rfc2104/
unit kdf;
interface
uses dcpcrypt2,math;
function PBKDF2(pass, salt: ansistring; count, kLen: Integer; hash: TDCP_hashclass): ansistring;
function CalcHMAC(message, key: string; hash: TDCP_hashclass): string;
implementation
function RPad(x: string; c: Char; s: Integer): string;
var
i: Integer;
begin
Result := x;
if Length(x) < s then
for i := 1 to s-Length(x) do
Result := Result + c;
end;
function XorBlock(s, x: ansistring): ansistring; inline;
var
i: Integer;
begin
SetLength(Result, Length(s));
for i := 1 to Length(s) do
Result[i] := Char(Byte(s[i]) xor Byte(x[i]));
end;
function CalcDigest(text: string; dig: TDCP_hashclass): string;
var
x: TDCP_hash;
begin
x := dig.Create(nil);
try
x.Init;
x.UpdateStr(text);
SetLength(Result, x.GetHashSize div 8);
x.Final(Result[1]);
finally
x.Free;
end;
end;
function CalcHMAC(message, key: string; hash: TDCP_hashclass): string;
const
blocksize = 64;
begin
// Definition RFC 2104
if Length(key) > blocksize then
key := CalcDigest(key, hash);
key := RPad(key, #0, blocksize);
Result := CalcDigest(XorBlock(key, RPad('', #$36, blocksize)) + message, hash);
Result := CalcDigest(XorBlock(key, RPad('', #$5c, blocksize)) + result, hash);
end;
function PBKDF1(pass, salt: ansistring; count: Integer; hash: TDCP_hashclass): ansistring;
var
i: Integer;
begin
Result := pass+salt;
for i := 0 to count-1 do
Result := CalcDigest(Result, hash);
end;
function PBKDF2(pass, salt: ansistring; count, kLen: Integer; hash: TDCP_hashclass): ansistring;
function IntX(i: Integer): ansistring; inline;
begin
Result := Char(i shr 24) + Char(i shr 16) + Char(i shr 8) + Char(i);
end;
var
D, I, J: Integer;
T, F, U: ansistring;
begin
T := '';
D := Ceil(kLen / (hash.GetHashSize div 8));
for i := 1 to D do
begin
F := CalcHMAC(salt + IntX(i), pass, hash);
U := F;
for j := 2 to count do
begin
U := CalcHMAC(U, pass, hash);
F := XorBlock(F, U);
end;
T := T + F;
end;
Result := Copy(T, 1, kLen);
end;
end.
```
Из бросающегося в глаза - обратите внимание, что в Pascal и его потомках отсутствует классическое разделение на заголовочные файлы и файлы собственно с кодом, в этом смысле модульная организация роднит его с Python, и отличает от C.
Однако от питонячьего модуля паскалевский отличается ещё и тем, что "снаружи" доступны только те функции/переменные, которые объявлены в секции `interface`. То есть по умолчанию внутри модуля ты можешь хоть "на ушах стоять" - снаружи никто не сможет вызвать твои внутренние API. Так устроен язык, а хорошо это или плохо - вопрос вкуса, поэтому оценки оставим в стороне (питонистам передают привет функции/методы, начинающиеся на "\_" и "\_\_").
Заголовочная часть
------------------
Код, как обычно, под спойлером.
Заголовочная часть ("шапка", header)
```
program devault;
uses
math, sysutils, strutils, getopts, DCPcrypt2, DCPsha256, DCPrijndael, kdf;
```
Далее нам понадобится пара функций - `hexlify` и `unhexlify` (набросаны, конечно, "на скорую руку"). Они являются аналогами соответствующих функций Python - вторая возвращает строку из шестнадцатеричных представлений байтов входного аргумента, а первая - наоборот, переводит строку шестнадцатеричных кодов обратно в байты.
hexlify/unhexlify
```
function unhexlify(s:AnsiString):AnsiString;
var i:integer;
tmpstr:AnsiString;
begin
tmpstr:='';
for i:=0 to (length(s) div 2)-1 do
tmpstr:=tmpstr+char(Hex2Dec(Copy(s,i*2+1,2)));
unhexlify:=tmpstr;
end;
function hexlify(s:AnsiString):AnsiString;
var i:integer;
tmpstr:AnsiString;
begin
tmpstr:='';
for i:=1 to (length(s)) do
tmpstr:=tmpstr+IntToHex(ord(s[i]),2);
hexlify:=tmpstr;
end;
```
Назначение функций `showbanner()`, `showlicense()` и `showhelp()` очевидно из названий, поэтому я просто приведу их без комментариев.
showbanner() / showlicense() / showhelp()showbanner()
```
procedure showbanner();
begin
WriteLn(stderr, 'DeVault v1.0');
Writeln(stderr, '(C) 2021, Sergey Pechenko. All rights reserved');
Writeln(stderr, 'Run with "-l" option to see license');
end;
```
showlicense()
```
procedure showlicense();
begin
WriteLn(stderr,'Redistribution and use in source and binary forms, with or without modification,');
WriteLn(stderr,'are permitted provided that the following conditions are met:');
WriteLn(stderr,'* Redistributions of source code must retain the above copyright notice, this');
WriteLn(stderr,' list of conditions and the following disclaimer;');
WriteLn(stderr,'* Redistributions in binary form must reproduce the above copyright notice, ');
WriteLn(stderr,' this list of conditions and the following disclaimer in the documentation');
WriteLn(stderr,' and/or other materials provided with the distribution.');
WriteLn(stderr,'* Sergey Pechenko''s name may not be used to endorse or promote products');
WriteLn(stderr,' derived from this software without specific prior written permission.');
WriteLn(stderr,'THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"');
WriteLn(stderr,'AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,');
WriteLn(stderr,'THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE');
WriteLn(stderr,'ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE');
WriteLn(stderr,'FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES');
WriteLn(stderr,'(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;');
WriteLn(stderr,'LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON');
WriteLn(stderr,'ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT');
WriteLn(stderr,'(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,');
WriteLn(stderr,'EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.');
WriteLn(stderr,'Commercial license can be obtained from author');
end;
```
showhelp()
```
procedure showhelp();
begin
WriteLn(stderr,'Usage:');
WriteLn(stderr,Format('%s <-p password | -w vault_password_file> [-f secret_file]',[ParamStr(0)]));
WriteLn(stderr,#09'"password" is a text string which was used to encrypt your secured content');
WriteLn(stderr,#09'"vault_password_file" is a file with password');
WriteLn(stderr,#09'"secret_file" is a file with encrypted content');
WriteLn(stderr,'When "-f" argument is absent, stdin is read by default');
end;
```
Дальше объявляем переменные и константы, которые будут использоваться в коде. Привожу их здесь только для полноты текста, потому что комментировать тут особо нечего.
Переменные и константы
```
var secretfile, passwordfile, pass, salt, b_derived_key, b_key1, b_key2, b_iv,
hmac_new, cphrtxt, fullfile, header, tmpstr, hmac:Ansistring;
Cipher: TDCP_rijndael;
key, vector, data, crypt: RawByteString;
fulllist: TStringArray;
F: Text;
c: char;
opt_idx: LongInt;
options: array of TOption;
const KEYLENGTH=32; // for AES256
const IV_LENGTH=128 div 8;
const CONST_HEADER='$ANSIBLE_VAULT;1.1;AES256';
```
Код
---
Ну, почти код - всё ещё вспомогательная функция, которая в рантайме готовит массив записей для разбора параметров командной строки. Почему она здесь - потому что работает с переменными, объявленными в секции `vars` выше.
preparecliparams()
```
procedure preparecliparams();
begin
SetLength(options, 6);
with options[1] do
begin
name:='password';
has_arg:=Required_Argument;
flag:=nil;
value:=#0;
end;
with options[2] do
begin
name:='file';
has_arg:=Required_Argument;
flag:=nil;
value:=#0;
end;
with options[3] do
begin
name:='passwordfile';
has_arg:=Required_Argument;
flag:=nil;
value:=#0;
end;
with options[4] do
begin
name:='version';
has_arg:=No_Argument;
flag:=nil;
value:=#0;
end;
with options[5] do
begin
name:='license';
has_arg:=No_Argument;
flag:=nil;
value:=#0;
end;
with options[6] do
begin
name:='help';
has_arg:=No_Argument;
flag:=nil;
value:=#0;
end;
end;
```
А вот теперь точно код самой утилиты:
Весь остальной код
```
begin
repeat
c:=getlongopts('p:f:w:lh?',@options[1],opt_idx);
case c of
'h','?' : begin showhelp(); halt(0); end;
'p' : pass:=optarg;
'f' : secretfile:=optarg;
'w' : passwordfile:=optarg;
'v' : begin showbanner(); halt(0); end;
'l' : begin showlicense(); halt(0); end;
':' : writeln ('Error with opt : ',optopt); // not a mistake - defined in getops unit
end;
until c=endofoptions;
if pass = '' then // option -p not set
if passwordfile <> '' then
try
Assign(F,passwordfile);
Reset(F);
Readln(F,pass);
Close(F);
except
on E: EInOutError do
begin
Close(F);
writeln(stderr, 'Password not set and password file cannot be read, exiting');
halt(1);
end;
end
else
begin // options -p and -w are both not set
writeln(stderr, 'Password not set, password file not set, exiting');
showhelp();
halt(1);
end;
try
Assign(F,secretfile);
Reset(F);
except
on E: EInOutError do
begin
writeln(stderr, Format('File %s not found, exiting',[secretfile]));
halt(1);
end;
end;
readln(F,header);
if header<>CONST_HEADER then
begin
writeln(stderr, 'Header mismatch');
halt(1);
end;
fullfile:='';
while not EOF(F) do
begin
Readln(F,tmpstr);
fullfile:=fullfile+tmpstr;
end;
Close(F);
fulllist:=unhexlify(fullfile).Split([#10],3);
salt:=fulllist[0];
hmac:=fulllist[1];
cphrtxt:=fulllist[2];
salt:=unhexlify(salt);
cphrtxt:=unhexlify(cphrtxt);
b_derived_key:=PBKDF2(pass, salt, 10000, 2*32+16, TDCP_sha256);
b_key1:=Copy(b_derived_key,1,KEYLENGTH);
b_key2:=Copy(b_derived_key,KEYLENGTH+1,KEYLENGTH);
b_iv:=Copy(b_derived_key,KEYLENGTH*2+1,IV_LENGTH);
hmac_new:=lowercase(hexlify(CalcHMAC(cphrtxt, b_key2, TDCP_sha256)));
if hmac_new<>hmac then
begin
writeln(stderr, 'Digest mismatch - file has been tampered with, or an error has occured');
Halt(1);
end;
SetLength(data, Length(crypt));
Cipher := TDCP_rijndael.Create(nil);
try
Cipher.Init(b_key1[1], 256, @b_iv[1]);
Cipher.DecryptCTR(cphrtxt[1], data[1], Length(data));
Cipher.Burn;
finally
Cipher.Free;
end;
Writeln(data);
end.
```
Дальше будет странная таблица, но, кажется, это - самый удобный способ рассказа об исходном коде.
| | | |
| --- | --- | --- |
| Стр. | Назначение | |
| 2-13 | разбор параметров командной строки с отображением нужных сообщений; | |
| 14-34 | проверка наличия пароля в параметрах, при отсутствии - попытка прочесть пароль из файла, при невозможности - останавливаем работу; | |
| 35-44 | попытка прочесть зашифрованный файл, указанный в параметрах; | Небольшой чит: по умолчанию имя файла (переменная secretfile) равно пустой строке; в этом случае вызов `Assign(F, secretfile)` в строке 36 свяжет переменную F с `stdin` |
| 45-50 | проверка наличия в файле того самого заголовка `$ANSIBLE_VAULT;1.1;AES256`; | |
| 51-57 | читаем всё содержимое зашифрованного файла и закрываем его; | |
| 58-63 | разбираем файл на части: "соль", дайджест, шифртекст - всё отдельно; при этом все три части нужно будет ещё раз прогнать через unhexlify (помните примечание в [VaultAES256.encrypt](#vaultencrypt)?) | |
| 64-73 | вычисление производного ключевого материала; разбиение его на части; расчёт дайджеста; проверка зашифрованного файла на корректность дайждеста; | |
| 74-83 | подготовка буфера для расшифрованного текста; расшифровка; затирание ключей в памяти случайными данными; вывод расшифрованного содержимого в поток stdout | |
Интересная информация для питонистовКстати, вы же слышали, что в Python 3.10 наконец-то завезли [оператор case](https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching) (PEP-634)? Интересно, что его ввёл сам BDFL, и произошло это примерно через 14 лет после того, как по результатам опроса на PyCon 2007 первоначальный [PEP-3103](https://www.python.org/dev/peps/pep-3103/) был отвергнут.
Собственно, теперь всё на месте, осталось собрать:
`[root@ansible devault]# time fpc devault.pas -Fudcpcrypt_2.1:dcpcrypt_2.1/Ciphers:dcpcrypt_2.1/Hashes -MOBJFPC`
Здесь имейте в виду, что форматирование Хабра играет злую шутку - никакого разрыва строки после первого минуса нет.
Вывод компилятора
```
Free Pascal Compiler version 3.0.4 [2017/10/02] for x86_64
Copyright (c) 1993-2017 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling devault.pas
Compiling ./dcpcrypt_2.1/DCPcrypt2.pas
Compiling ./dcpcrypt_2.1/DCPbase64.pas
Compiling ./dcpcrypt_2.1/Hashes/DCPsha256.pas
Compiling ./dcpcrypt_2.1/DCPconst.pas
Compiling ./dcpcrypt_2.1/Ciphers/DCPrijndael.pas
Compiling ./dcpcrypt_2.1/DCPblockciphers.pas
Compiling kdf.pas
Linking devault
/usr/bin/ld: warning: link.res contains output sections; did you forget -T?
3784 lines compiled, 0.5 sec
real 0m0.543s
user 0m0.457s
sys 0m0.084s
```
Вроде неплохо: 3,8 тысячи строк кода собраны до исполняемого файла за 0.6 сек. На выходе - статически связанный бинарник, которому для работы от системы требуется только ядро. Ну то есть для запуска достаточно просто скопировать этот бинарник в файловую систему - и всё. Кстати, я забыл указать его размер: 875К. Никаких зависимостей, компиляций по несколько минут и т.д.
Ах да, чуть не забыл самое интересное! Запускаем, предварительно сложив пароль в файл ".password":
```
[root@ansible devault]# ./devault -w .password -f vaulted.yml
---
collections:
- name: community.general
scm: git
src: https://github.com/ansible-collections/community.general.git
version: 1.0.0
```
Вот такой нехитрый YaML я использовал в самом начале статьи для создания зашифрованного файла.
Исходный код для самостоятельного изучения можно [взять здесь](https://github.com/tnt4brain/devault).
Хотите ещё Ansible? (осторожно, денежные вопросы!)Теперь у вас есть возможность [сделать пожертвование автору статьи](https://www.raiffeisen.ru/c2c/to/tnt4brain) - оно дополнительно замотивирует меня чаще выбираться на прогулку с чашкой кофе и булкой с корицей, чтобы отдохнуть перед написанием следующей статьи и обдумать её содержание.
Если же хотите систематизировать и углубить свои знания Ansible - я провожу тренинги по Ansible, пишите [мне в Telegram](https://t.me/tnt4brain). | https://habr.com/ru/post/554148/ | null | ru | null |
# Мошенничество при покупке б/у Macbook Pro
Сегодня ко мне обратилась знакомая с просьбой помочь купить б/у Macbook Pro. Я сразу предупредил, что квалификация у меня близка к нулю, но чем могу — помогу. С PC плотно не работаю уже много лет, а Mac владею на верхне-чайниковом уровне. Беглый поиск по фразе «как проверить macbook pro» сразу же привел к исчерпывающей публикации [rule](https://geektimes.ru/users/rule/) на заданную тему: «Осторожно при покупке MacBook. Высокотехнологический способ мошенничества в оффлайне» [geektimes.ru/post/157969](http://geektimes.ru/post/157969/) Но неопытноcть меня все же подвела.
Объявление:
То есть в объявлении предлагается топовая модель MacBook Pro «Core i7» 2.9 13" Mid-2012 (MD102). Реально это оказался MacBook Pro «Core 2 Duo» 2.66 13" Mid-2010 (MC375) — 4 GB RAM, 500 GB HDD. Блок питания был новый.
Мы встретились с продавцом в ТЦ, специально около розетки, чтобы можно было прогнать Apple Hardware Test. На ноутбуке была установлена Mac OS X 10.9.5. Имейте в виду, что для полноценной проверки может потребоваться интернет.
Что хочу добавить к замечательному посту [rule](https://geektimes.ru/users/rule/) выше:
1. Проверка по серийному номеру, указанному в свойствах системы (потому что на корпусе серийника не оказалось), показала, что это действительно модель mid 2012
Дома, после переустановки ОС в свойствах системы стал отображаться иной серийный номер и тут оказалось:
При этом в разделе «О Mac» все равно было обозначено «середина 2012 г.» — то есть над ноутбуком нормально похимичили перед продажей.
Важное: если внимательно посмотреть инструкцию Apple [support.apple.com/ru-ru/HT204347](https://support.apple.com/ru-ru/HT204347) то отсутствие серийника на корпусе должно было насторожить. У модели mid 2012 серийник есть на корпусе.
UPD. Оказалось, что дно ноутбука было очень аккуратно заклеено самокеющейся пленкой «под алюминий» поэтому я не увидел серийника.
2. Я не придал значения следующей фразе автора: «на этом скриншоте видно, что в детальной информации отсутствует информация о процессоре, памяти и дисках. Я на это не обратил внимание — это моя ошибка номер 1». Это действительно так, первейший и вернейший признак обмана.
3. Для проверки жесткого диска я попытался запустить Disk utility, но не смог. Зайдя в папку с программами я увидел, что Disk utility перечеркнута и при запуске выдает сообщение о невозможности работы — то есть придется переустанавливать операционную систему. Надо было просто в Finder сходить в самый корень и посмотреть свойства диска, а я не сообразил это сделать. Метка тома была HDD 750 GB и это сбивало с толку. В свойствах диска оказалось 500 GB.
4. Автор указывает на ошибки консольной команды «system\_profiler», но на своем экземпляре ноутбука я подобных ошибок не заметил. Или может не там смотрел.
5. Одна из главных засад — Apple Hardware Test не работает по нажатию D при включении аппарата. Я оказался совершенно не готов к такому раскладу, при этом я не знал другие основные сочетания клавиш для управления компьютером до загрузки ОС. Позже я попробовал на своем домашнем iMac mid 2010 — то же самое, при нажатии D просто ничего не происходит. Будучи уже дома, я воспользовался вариантом Apple Hardware Test через интернет — для этого нужно после включения зажать Alt+D. Но этот вариант тоже может не сработать. Например, на моем домашнем интернете интернет-тест выдает ошибку 3404D и на ноутбуке и на iMac. Судя по документации [support.apple.com/en-us/HT201257](https://support.apple.com/en-us/HT201257) нужно предусмотрительно захватить с собой Applications Install Disc 2 или USB-флешку с MacBook Air Software Reinstall Drive и загружать Apple Hardware Test с них.
Apple Hardware Test можно скачать тут [github.com/upekkha/AppleHardwareTest](https://github.com/upekkha/AppleHardwareTest)
Там же инструкция как сделать USB флешку. Этот вариант существенно быстрее по трудозатратам, чем создание загрузочной флешки с OS X, но менее универсальный. Если использовать тест не от той модели, то при запуске он выдаст ошибку, что данный компьютер не поддерживается.
А с загрузочной флешкой с OS X прогнав system\_profiler можно точно узнать какая именно модель перед тобой.
Для себя я выработал следующий рецепт:
* Заранее подготовить USB флешку (SD-карту) с инсталлятором OS X [support.apple.com/ru-ru/HT201372](https://support.apple.com/ru-ru/HT201372) Или использовать загрузочный DVD с Mac OS X.
* Вставляем флешку в ноутбук и перезагружаемся, жмем Alt для выбора варианта загрузки и загружаемся с флешки.
* Мы попадаем в OS X Utilities. В меню Utilities нужно выбрать Terminal.
* Далее используем команду «system\_profiler». Работа команды system\_profiler происходит некоторое время, не торопитесь. На выходе получается портянка текста, в которой можно найти нужную информацию. По команде «system\_profiler -listDataTypes» можно увидеть названия отдельных разделов информации. Если использовать команду «system\_profiler» с этими ключами, можно во-первых существенно сократить количество выводимой информации, во-вторых это ускорит работу утилиты.
Даже самый простой вариант позволяет сразу же обнаружить обман
`system_profiler SPHardwareDataType`
Если добавить разделы про память и диски, то получится исчерпывающе
`system_profiler SPHardwareDataType SPMemoryDataType SPSerialATADataType`
6. Если вариант с переустановкой операционной системы будет уместен для всех сторон (все же это ощутимое время), то кроме варианта переустановки через интернет есть еще вариант установки с USB-флэшки. Удобно в случае, если нет подходящего интернет-канала. Естественно подготовкой такой флешки нужно озаботиться заранее.
История пока что не закончена. На звонок и SMS продавец не ответил. Если завтра утром ситуация не изменится — будем писать заявление в полицию.
На Avito я видел еще несколько схожих по стилю объявлений, так что явление это, судя по всему, весьма распространенное. Будьте осторожны!
**Памятка:**
История «успеха» с указанием основных моментов [geektimes.ru/post/157969](http://geektimes.ru/post/157969/)
Как использовать Apple Hardware Test [support.apple.com/ru-ru/HT201257](https://support.apple.com/ru-ru/HT201257)
Горячие клавиши перед загрузкой ОС [support.apple.com/ru-ru/HT201255](https://support.apple.com/ru-ru/HT201255)
Apple Hardware Test можно скачать тут [github.com/upekkha/AppleHardwareTest](https://github.com/upekkha/AppleHardwareTest)
Как узнать серийный номер [support.apple.com/ru-ru/HT204347](https://support.apple.com/ru-ru/HT204347)
Проверка серийного номера [checkcoverage.apple.com/ru/ru](https://checkcoverage.apple.com/ru/ru/)
Подробные спецификации всех устройств Apple [www.everymac.com/systems/apple/index-apple-specs-applespec.html](http://www.everymac.com/systems/apple/index-apple-specs-applespec.html)
Определение количества циклов зарядки аккумуляторов ноутбуков Apple [support.apple.com/ru-ru/HT201585](https://support.apple.com/ru-ru/HT201585)
Создание загружаемого установщика для ОС OS X (как сделать USB флешку с инсталлятором OS X) [support.apple.com/ru-ru/HT201372](https://support.apple.com/ru-ru/HT201372)
Описание команды SYSTEM\_PROFILER [developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man8/system\_profiler.8.html](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man8/system_profiler.8.html) | https://habr.com/ru/post/388815/ | null | ru | null |
# Новое в CSS 3: анимация, трансформация, переменные.
Что-то мне кажется, что в этот раз с идеями внедерения новых правил разработчики перестарались…
Dave Hyatt, Dean Jackson и Chris Marrin (все трое работают в Apple) предложили внедрить в CSS 3 поддержку создания анимации, трансформацию объектов, их изменение с течением времени и ввести css-переменные.
О причине реализации возможности **создания анимации** они пишут:
> На сегодняшний день создание анимации поддерживается лишь на языке SVG, но нет ни одной системы, котрая бы поддерживала создание анимации с помощью CSS. Поэтому наша цель — решить эту задачу внедрением особых CSS свойств, которые будут иметь значения, отвечающие за создание анимации и управление ею.
Эти значения будут описываться в селекторе **keyframe**:
> `@keyframes 'wobble' {
>
> 0 {
>
> left: 100px;
>
> }
>
>
>
> 40% {
>
> left: 150px;
>
> }
>
>
>
> 60% {
>
> left: 75px;
>
> }
>
>
>
> 100% {
>
> left: 100px;
>
> }
>
> }`
где «wobble» — название анимации, а соответствующие значения 0, 40%, 60% и 100% — определяют момент времени от общего временного интервала.
На рисунке выше приведен пример анимации элемента за 10 секунд.
Еще один вариант реализации - задание для каждого фрагмента определенной функции, управляющей отрисовкой:
> `@keyframes 'bounce' {
>
> from {
>
> top: 100px;
>
> animation-timing-function: ease-out;
>
> }
>
>
>
> 25% {
>
> top: 50px;
>
> animation-timing-function: ease-in;
>
> }
>
>
>
> 50% {
>
> top: 100px;
>
> animation-timing-function: ease-out;
>
> }
>
>
>
> 75% {
>
> top: 75px;
>
> animation-timing-function: ease-in;
>
> }
>
>
>
> to {
>
> top: 100px;
>
> }
>
> }`
В этом примере мы создаем анимацию с именем «bounce», имеющую 4 кадра, каждый из которых занимает 25% общего времени анимации. При этом, каждому фрагменту задана функция «ease-in» либо «easy-out». Первая отвечает за изменение отрисовки элемента внтури какой-либо области, а вторая за ее пределами. Все эти свойства управления созданием анимации исходят из идеи внедрения [управления элементом во времени](http://webkit.org/specs/CSSVisualEffects/CSSTransitions.html).
> Подробней о новом свойстве создания анимации можно узнать [здесь](http://webkit.org/specs/CSSVisualEffects/CSSAnimation.html)
>
>
Вторая идея, мне кажется, более обоснована — это **управление положением элемента на плоскости**. Вот пара примеров реализации:
>
> ```
> div { transform: translate(100px, 100px); }
> ```
>
Такой код приведет к следующей трансформации элемента:
Или вот, более наглядное описание возможностей:
> `div {
>
> height: 100px; width: 100px;
>
> transform: translate(80px, 80px) scale(1.5, 1.5) rotate(45deg);
>
> }`
Таким свойством я бы с удовольствием воспользовалась.
> Подробно о свойствах трансформации можно прочесть [здесь](http://webkit.org/specs/CSSVisualEffects/CSSTransforms.html)
И последняя фантазия разработчиков уж точно кажется немного безумной — **введение css-переменных**. Неужели CSS превратится в полноценный язык программирования и управления html элементами?
Примеры использования:
> `@variables {
>
> CorporateLogoBGColor: #fe8d12;
>
> }
>
>
>
> div.logoContainer {
>
> background-color: var(CorporateLogoBGColor);
>
> }
>
>
>
> @variables {
>
> myMargin1: 2em;
>
> }
>
>
>
> @variables print {
>
> myMargin1: 2em;
>
> }
>
>
>
> .data, div.entry {
>
> margin-left: 30px;
>
> margin-left: var(myMargin1);
>
> }`
Смысл этого кода таков: селектор variables определяет имя и значение переменной, которое можно в дальнейшем приписать к любому элементу. Идея все же не проработана. Зачем определять для цвета переменную, если его можно просто указать?
> Прочесть [подробнее о css-переменных](http://disruptive-innovations.com/zoo/cssvariables/#mozTocId866469)
От себя лишь хочу добавить, что, на мой взгляд, создание новых свойств CSS 3 должно быть основано, прежде всего, на запросах вебмастеров, а не только на идеях супер-специалистов из крупных компаний. Может создать кампанию: «Вебмастер, даешь идеи для СSS 3» ?
Кросс-пост: [Блог для вебмастеров](http://www.getincss.ru/2008/04/11/novoe-v-css-3-animaciya-transformaciya-peremennye/) | https://habr.com/ru/post/23356/ | null | ru | null |
# Вся правда о UTF-8 флаге
Распространённое заблуждение состоит в том, что строки символов, в отличие от строк байтов, имеют UTF-8 флаг установленным.
Многие догадываются, что если данные являются ASCII-7-bit, то UTF-8 флаг просто не важен.
Однако, на самом деле, он может быть установлен или сброшен, как и у символов, так и абсолютно произвольных бинарных данных.
Широко известный в Perl комьюнити автор *Marc Lehmann* делает об этом замечание в документации к модулю [JSON::XS](http://search.cpan.org/~mlehmann/JSON-XS-2.34/XS.pm#A_FEW_NOTES_ON_UNICODE_AND_PERL)
> You can have Unicode strings with that flag set, with that flag clear, and you can have binary data with that flag set and that flag clear. Other possibilities exist, too.
>
>
##### Рассмотрим случай, когда ASCII-7bit данные имеют UTF-8 флаг установленным.
```
use utf8;
use strict;
use warnings;
my $u = "тест"; # unicode строка
my $ascii = "x"; # обычный ASCII символ
my ($ascii_u, undef) = split(/ /, "$ascii $u");
die unless $ascii_u eq "x"; # тот же ASCII символ
print "UTF-8 flag set!" if utf8::is_utf8($ascii_u); # но теперь у него установлен UTF-8 флаг
```
Этот код выводит «UTF-8 flag set!». То есть ASCII-7bit строка получила этот флаг, после того, как операция split разделила Unicode строку (с UTF-8 флагом) на части. Можно сказать, что программист не контролирует будет ли у его ASCII данных UTF-8 флаг или нет, это зависит от того, откуда и как получены данные, и от того, какие данные были рядом с ними.
Тот же эффект получается, если декодировать ASCII-7bit байты в ASCII-7bit символы с помощью [Encode::decode()](http://search.cpan.org/~dankogai/Encode-2.52/Encode.pm#decode)
```
use strict;
use warnings;
use Encode;
my $ascii = 'x'; # ASCII символ
my $ascii_u = decode("UTF-8", encode("UTF-8", "$ascii"));
die unless $ascii_u eq "x"; # тот же ASCII символ
print "UTF-8 flag set!" if utf8::is_utf8($ascii_u); # но теперь у него установлен UTF-8 флаг
```
Т.е. перекодировка туда-обратно не меняет данные (это ожидаемо), но устанавливает UTF-8 флаг.
(впрочем, такое поведение decode() [противоречит](https://rt.cpan.org/Public/Bug/Display.html?id=34259) его собственной [документации](http://search.cpan.org/~dankogai/Encode-2.52/Encode.pm#The_UTF8_flag), которая, в свою очередь, противоречит идее, что никакой документации и гарантий относительно utf-8 флага в ASCII данных быть не должно)
Объяснить же причины появление UTF-8 флага можно соображениями эффективности. Слишком накладно после split анализировать строку, чтобы понять, состоит ли она только из ASCII символов, и можно ли сбросить флаг.
Такое поведение UTF-8 флага похоже на вирус — он заражает все данные с которыми соприкасается.
##### Рассмотрим случай, когда не-ASCII, Unicode символы не имеют UTF-8 флага.
```
use strict;
use warnings;
use Digest::SHA qw/sha1_hex/;
use utf8;
my $s = "µ";
my $s1 = $s;
my $s2 = $s;
my $digest = sha1_hex($s2); # попробуйте закомментировать эту строчку
print "utf-8 bit ON (s1)\n" if utf8::is_utf8($s1);
print "utf-8 bit ON (s2)\n" if utf8::is_utf8($s2);
print "s1 and s2 are equal\n" if $s1 eq $s2;
```
печатает:
```
utf-8 bit ON (s1)
s1 and s2 are equal
```
То есть вызов функции стороннего модуля сбросил UTF-8 флаг. При этом, строки с флагом и без, оказались полностью идентичными.
Такое может случится только с символами > 127 и <=255 (т.е. Latin-1).
На самом деле, со строкой $s2 произошла операция **utf8::downgrade**
Эта функция описана в [документации](http://search.cpan.org/perldoc?utf8), как меняющая внутреннее представление строки:
> Converts in-place the internal representation of the string from UTF-X to the equivalent octet sequence in the native encoding (Latin-1 or EBCDIC). The logical character sequence itself is unchanged.
>
>
В принципе модуль Digest::SHA документирует такое своё поведение, хотя не обязан:
> Be aware that the digest routines silently convert UTF-8 input into its
>
> equivalent byte sequence in the native encoding (cf. utf8::downgrade). This
>
> side effect influences only the way Perl stores the data internally, but
>
> otherwise leaves the actual value of the data intact.
>
>
В общем случае любая 3-rd party функция может сделать downgrade строки, не сообщая в этом в документации (или, например, делать его только иногда).
##### Рассмотрим случай, когда абсолютно произвольные, бинарные данные имеют UTF-8 флаг.
```
use utf8;
use strict;
use warnings;
# нам нужен bytes::length для отладки, ставим '()' чтобы bytes не влияло на ход программы
use bytes ();
my $u = "тест"; # не ASCII строка
# байты, не символы
my $bin = "\xf1\xf2\xf3";
## опять получает ASCII строку с UTF-8 флагом
my $ascii = "x"; # обычный ASCII симовл
my ($ascii_u, undef) = split(/ /, "$ascii $u");
die unless $ascii_u eq "x"; # тот же ASCII символ
die unless utf8::is_utf8($ascii_u); # но теперь у него установлен UTF-8 флаг
## //
print "original bin length:\t";
print length($bin) . "\t" . bytes::length($bin) ."\n";
my $bin_a = $bin.$ascii; # соединяем бинарные данные, с ASCII данными
print "bin_a length:\t";
print length($bin_a) . "\t" . bytes::length($bin_a) ."\n";
my $bin_u = $bin.$ascii_u; # опять соединяем бинарные данные, с ASCII данными
print "bin_u length:\t";
print length($bin_u) . "\t" . bytes::length($bin_u) ."\n";
print "bin_a and bin_u are equal!\n" if $bin_a eq $bin_u;
open my $f, ">", "file_a.tmp";
binmode $f;
print $f $bin_a;
close $f;
open $f, ">", "file_u.tmp";
binmode $f;
print $f $bin_u;
close $f;
system("md5sum file_?.tmp"); # md5sum - команда linux
```
выдаёт:
```
original bin length: 3 3
bin_a length: 4 4
bin_u length: 4 7
bin_a and bin_u are equal!
33818f4b23aa74cddb8eb625845a459a file_a.tmp
33818f4b23aa74cddb8eb625845a459a file_u.tmp
```
В результате получается, что бинарные данные, после конкатенации с ASCII строкой, увеличили свой внутренний размер в байтах (но не в символах) с 4 до 7, но только в случае, если, ничего не значащий, UTF-8 флаг у ASCII был установлен.
Однако, при сравнении этих данных между собой, они идентичны, также, при выводе в файл обоих строк, даже без указания кодировки, файлы оказались тоже идентичными.
Таким образом, бинарные данные могут увеличиться в размере и получить UTF-8 флаг, при этом никакого бага нет, все встроенные функции Perl обрабатывают их точно так же, как если бы флага не было (если и есть исключения, то баг в них).
Любой другой perl код тоже должен обрабатывать такие данные без ошибок (если он не пытается анализировать внутреннюю струкутуру строки, или хотя бы анализирует её правильно)
На самом деле то, что случилось с бинарными данными, является аналогом операции **utf8::upgrade**. Данные были интерпретированы как Latin-1, конвертированны в UTF-8, и установлен UTF-8 флаг. Это операция противоположна **utf8::downgrade**, описанной выше. **utf8::downgrade** может производиться только с Latin-1 символами. А **utf8::upgrade** может производиться
с любыми байтами (т.к. любому байту соответствует символ из Latin-1).
Это может быть важно, если у вас в памяти большой объём бинарных данных. Совсем не здорово, если 400 мегабайтный блоб, вдруг превращается в 700 мегабайтный, только потому, что вы добавили туда один ASCII-7bit байт с UTF-8 флагом. Хороший выход из ситуации здесь — unit тесты или runtime [assertions](http://en.wikipedia.org/wiki/Assertion_%28software_development%29) с проверкой UTF-8 флага.
##### В общем случае, невозможно отличить байты от символов
Рассмотрим задачу: написать функцию, на вход которой будет подаваться XML, если XML является байтами, посмотреть кодировку в теге «xml» и перекодировать их в символы. Если она уже является символами, ничего не делать.
Такую функцию реализовать не получится. Например, для строки символов «Hello, München», функция не сможет
отличить символы это, или байты в кодировке CP1251, или в KOI8-R (в случае если строка окажется downgraded, а это программист в общем случае не контролирует).
Для символов > 255, UTF-8 флаг всегда установлен (с ними нельзя сделать **utf8::downgrade**). Для символов с кодом <= 127 UTF-8 бит не важен, в том плане, что их можно рассматривать и как бинарные данные, и как символы. Для символов Latin1 — отличить от байтов не возможно.
Отличить байты от символов в Perl — это всё равно что отличить имя файла от email и от имени человека. Иногда возможно, но в общем случае — нет. Сам программист должен помнить в какой переменной что у него находится.
Это есть в документации:
[perldoc.perl.org/perlunifaq.html](http://perldoc.perl.org/perlunifaq.html)
> How can I determine if a string is a text string or a binary string?
>
>
>
> You can't. Some use the UTF8 flag for this, but that's misuse, and makes well behaved modules like Data::Dumper look bad. The flag is useless for this purpose, because it's off when an 8 bit encoding (by default ISO-8859-1) is used to store the string.
>
>
>
> This is something you, the programmer, has to keep track of; sorry. You could consider adopting a kind of «Hungarian notation» to help with this.
>
>
Если вам всё же нужно это сделать, можно создать свой класс, который будет содержать строку байтов или символов, и флаг, показывающий что это (тот же трюк подойдёт для email vs имя файла vs имя человека).
##### Wide characters не выдаётся для символов из Latin-1
Слудеющий пример выдаёт warning *Wide characters in print* только если мы печатает $s2
```
use strict;
use warnings;
use utf8;
my $s1 = "ß";
my $s2 = "тест";
my $s = $ARGV[0] ? $s1 : $s2;
print $s;
```
Если мы печатем $s1, Perl конвертирует Unicde символ µ (U+00DF, UTF-8 \xC3xF9) в байт \xDF и пытается вывести его на экран.
Такое же поведение справедливо для всех функций, которые принимают байты, а не символы (print, syswrite без указания кодировки, контрольные суммы SHA, MD5, CRC32, MIME::Base64).
##### Вирусный downgrade
В начале статьи было описано «вирусное» поведение UTF-8 бита у ASCII символов (вирусный **utf8::upgrade**). Теперь рассмотрим «вирусный» сброс UTF-8 бита у Latin-1 символов **(utf8::downgrade**).
Представим, что мы пишем функцию, которая определена только над байтами, а не над символами, хорошим примером являются hash-функции, шифрование, архивирование, Mime::Base64 и т.д.
1. Раз невозможно отличить бинарные данные от символов, вы должны рассматривать входные данные как байты.
2. Байты могут иметь **upgrade** форму (т.к. с UTF-8 флагом). Результат должен быть такой же как у **downgrade** формы.
Следовательно нужно сделать **utf8::downgrade** и выдать ошибку, если это не получится.
Для алгоритмов, типа хэш-функций, характерна забота о производительности. Делать вторую копию данных в памяти не эффективно, так что, в большинстве случаев, функция модифицирует передаваемый ей параметр.
Как, наверное, многие знают, в Perl все параметры передаются по ссылке, но обычно используются по значению.
```
sub mycode
{
$_[0] = "X"; # модифицировали первый фактической параметр, не зависимо от воли вызывающего
}
```
```
sub mycode
{
my ($arg1) = @_; # типичный способ работы с аргументами функции
$arg1 = "X"; # теперь параметр доступен по значению, фактический параметр не модифицируется
}
```
Таким образом, при создании кода, который работает точно в соответствие со спецификацией Perl, создаётся код, незаметно делающий **utf8::downgrade** над фактическими параметрами, не зависимо от воли вызывающего, тем самым, возможно, создав баг в каком-то другом месте, которое неправильно обрабатывало строки, и до этого момента работало хорошо.
##### Для имён файлов всё это не работает
Функции, которые принимают имена файлов как аргументы (**open**, файловые тесты **-X**), а так же, которые возвращают имена файлов (**readdir**), не подчиняются этим правилам (это [отмечено](http://perldoc.perl.org/perlunicode.html#When-Unicode-Does-Not-Happen) в документации).
Они просто интерпретируют имя файла, как оно есть в памяти.
Алгоритм их работы можно описать следующим образом:
```
sub open {
my ( ... $filename) = @_;
utf8::_utf8_off($filename); # теперь это двоичные данные
_open($filename);
```
Для этого есть несколько причин:
1. Во многих POSIX системах ( Linux / \*BSD ), на многих файловых системах, именем файла может являться произвольная последовательность байтов, не обязательно являющаяся последовательностью символов в какой-либо кодировке.
2. Нет переносимого способа определить кодировку файловой системы.
3. На машине может быть несколько файловых систем с разной кодировкой
4. Нельзя опираться на предположение, что кодировка имён файлов совпадёт с кодировкой локали.
5. Должна быть совместимость со старым кодом.
В итоге программист должен сам определять кодировку и сообщать её интерпретатору, но API для этого ещё не сделали.
Модифицируем наш пример, где мы «случайно» наткнулись на downgrade строки символов.
```
use strict;
use warnings;
use Digest::SHA qw/sha1_hex/;
use utf8;
my $s = "µ";
my $s1 = $s;
my $s2 = $s;
my $digest = sha1_hex($s2); # попробуйте закомментировать эту строчку
print STDERR "s1 and s2 are equal\n" if $s1 eq $s2;
open my $f, ">", "$s1.tmp" or die "s1 failed: $!";
print $f "test";
close $f;
open $f, "<", "$s2.tmp" or die "s2 failed: $!";
print STDERR "Done\n";
```
Результат работы:
```
s1 and s2 are equal
s2 failed: No such file or directory
```
т.е. строки s1 и s2 совпадают, но указывают на разные файлы, если вывоз **sha1\_hex** убрать, то на одинаковые файлы.
На эти же грабли можно наткнуться, обращаясь к любым модулям, работающим с файлами (например **File::Find**)
##### Когда ещё это не работает
В модуле Encode Есть функция [decode\_utf8](http://search.cpan.org/~dankogai/Encode-2.52/Encode.pm#decode_utf8)
документирована как:
> Equivalent to $string = decode(«utf8», $octets [, CHECK])
>
>
Но на самом деле, если у $octets установлен флаг UTF-8, функция просто возвращает их неизменными (хотя должна попытаться сделать **utf8::downgrade** и работать с ними, как с бинарными данными, а если **downgrade** не получится, выдать ошибку *Wide characters*).
Этот баг был замечен ( [RT#61671](https://rt.cpan.org/Public/Bug/Display.html?id=61671) [RT#87267](https://rt.cpan.org/Public/Bug/Display.html?id=87267) ) сразу как появился — в 2010 году.
Но майнтайнер отвергает все подобные багрепорты. При этом суть репортов, даже не в том чтобы функция вела себя правильно (в соответствии с идеей Perl), и даже не в том, чтобы к ней была документация, описывающая это поведение, а в том, что, хотя бы, это поведение не должно противоречить существующей документации. Майнтайнер же считает, что функции документированы как эквивалентные, а это не значит идентичные (хотя помоему эквивалентность может рассматриваться и как похожесть, и как идентичность). Возможно в математике эквивалентность не содержит даже намёка на идентичность… Если кто-то сможет разгадать эту загадку, буду очень благодарен.
##### The Unicode Bug
В **downgraded** форме Latin-1 нельзя отличить от байтов, следовательно, в этой форме, плохо работают некоторые метасимволы в регулярных выражениях, функции **uc**, **lc**, **quotemeta**.
Воркэраунд — **utf8::upgrade**, либо, в новых версиях Perl — некоторые директивы, которые позволяют сделать это поведение консистентным.
Подробное описание в [документации Perl](http://perldoc.perl.org/perlunicode.html#The-%22Unicode-Bug%22)
##### Что же делать со всем этим?
1. Не пользуйтесь (если вы точно не знаете, что делаете) следующими функциями: **utf8::is\_utf8**, **Encode::\_utf8\_on**, **Encode::\_utf8\_off**, и всеми функциями из модуля **bytes** (документация ко всем этим функциям не рекомендует их использование, кроме как для отладки)
2. Пользуйтесь **utf8::upgrade**, **utf8::downgrade**, всякий раз, когда этого требует спецификация Perl
3. Для конвертации из символов в байты пользуйтесь **Encode::encode**, **Encode::decode**
3. Если используете чужой код, нарушающий эти правила, проверьте его на наличие багов, применяйте workaroundы.
4. При работе с именами файлов, либо придётся использовать wrapper над всеми функциями, либо, с помощью тестов убедиться, что внутреннее представление имён файлов не меняется в процессе работы кода.
Есть несколько примеров, когда нарушение этих правил мне показалось оправданным.
```
Encode::_utf8_off($_[0]) if utf8::is_utf8($_[0]) && (bytes::length($_[0]) == length($_[0]));
```
(сбрасывет UTF-8 флаг для ASCII-7bit текста (тем самым удаётся достичь 30% увеличения производительности регэкспов, во всех Perl, кроме 5.19)
```
defined($_[0]) && utf8::is_utf8($_[0]) && (bytes::length($_[0]) != length($_[0]))
```
(Возвращает TRUE, если у строки установлен UTF-8 флаг, и при этом она не является ASCII-7bit. Может использоваться в unit тестах, чтобы убедиться, что ваши 400 мегабайт бинарных данных не превращаются в 700)
Есть ещё вариант ничего не делать. Честно говоря, пройдёт довольно много времени, прежде чем вы наткнётесь на какой-либо баг (но, к тому моменту будет уже поздно). Этот вариант крайне не рекомендуется для разработчиков библиотек. | https://habr.com/ru/post/190584/ | null | ru | null |
# Часть. 2. Создание аналога Moodle. Реализация API для прототипа SPA. Межсайтовые запросы. Первые проблемы архитектуры
В [первой части я рассказал](https://habr.com/ru/post/590605/) про то, почему я пришел к необходимости создания собственной СДО. Итак, на текущий момент имеем: сайт, работающий на самописном PHP frameworke, отдельные скрипты JS, подключаемые на определённых страницах с соответствующим типом задания (тест, квест). Тип задания и необходимость загрузки скриптов определяется выполнением кода PHP на конкретной странице. JS работает локально (база данных используется только PHP).
Появилась задача взаимодействия JS с базой данных для расширения функционала интерактивных возможностей СДО. Так как ранее я работал с PHP, было принято решение передавать сведения, полученных PHP из базы данных в JS. Для хранения массивов в SQL сначала я использовал сериализацию и base64, но быстро отказался от такого подхода ввиду сложности понимания структуры данных, хранящихся в базе.
Я был нацелен на достижение скорейшего результата в виде работающего приложения, поэтому было принято решение хранить объекты JS и массивы PHP в виде JSON строки в обычном поле формата text. Да, спустя время я понимаю, что можно было рассмотреть возможность использования нереляционных (NoSQL-систем) баз данных типа MongoDb (впоследствии, я возможность перехода протестировал, но значимых плюсов не нашел для решения конкретных задач, в первую очередь потому, что приходится в основном работать с отношениями «многие ко многим»).
Следует сказать о 2 типах информации, которую было необходимо сохранить в базе данных. Первый – это обычные массивы PHP и объекты JS (по сути, ассоциативные массивы PHP). С этим форматом особых сложностей не было. Гораздо большую сложность представлял формат хранения слайдов.
Что представлял собой **слайд**. Это некая область в дереве DOM, сформированная с помощью JS и содержащая избыточную информацию о, элементах, расположенных в ней:
1. Фоновое изображение.
2. Информация о расположении иконок на слайде (позиционирование было абсолютным и достигалось путем Drag and Drop из библиотеки JQuery UI, расположенной справа).
3. CSS стили оформления, пути к изображениям элементов и т.д.
4. Каждая иконка имела соответствующий вид, тип и событие, которое наступало при клике на ней.
5. Слайд содержал информацию об анимации перехода, является ли он начальным или финальным.
Информация о каждом слайде хранилась в объекте JS в виде массива объектов, каждый из которых имел ключ – номер слайда и значение – html сущность в виде строки (чуть позднее использовался MAP). Для сохранения квеста, содержащего множество слайдов в SQL отправлялся ajax POST запрос, содержащий информацию о названии, категории, авторе и html коде 2 блоков страницы (навигация и рабочая область). Библиотека в базе не сохранялась.
Страшно сейчас представить, что хранилось в базе данных и как постоянно я боролся с ошибками кириллицы, валидности html и json при постоянном обмене между JS и PHP.
Часть примера POST.
С целью более упорядоченной работы с квестами и учитывая, что уже получался вполне самодостаточный проект, было решено вынести его в отдельный поддомен и связывать с основным СДО в будущем с помощью базы данных и межсайтовыми запросами. Сайты были разделены.
Итак, имеются уже 2 сайта, сделанные на самописном frameworke.
1. Главный сайт, реализующий следующий функционал: регистрация пользователей, возможность создания категорий (дисциплин) и заданий. Из сделанных заданий были: тестирование на статических файлах JS и проверка преподавателем ответов, присылаемых студентами. Сводная таблица содержала данные по оценкам, выставленным преподавателем исходя из ручной проверки решений заданий, вставляемых студентами в «textarea» и отправляемых с помощью формы POST запросом на сервер.
2. Квестовая подсистема (на поддомене), позволяющая реализовать простые пошаговые переходы между слайдами путем клика на соответствующие иконки. По сути, происходила полная замена html содержимого блока с помощью Jquery на другой код html, содержащийся в значении ключа слайда объекта и сохраненный туда ранее.
Желая максимально ускорить работу сайтов, я старался минимизировать количество запросов к базе данных. Доходило даже **до крайностей**: к примеру, данные авторизованного пользователя хранились в Cookie (id, ФИО, роль) в открытом виде. Это впоследствии привело к ряду проблем, что желая изменить ФИО пользователя или его роль, мне приходилось вручную просить людей выйти из системы, а потом снова войти, чтобы заново поставить куки, так как будучи «очень продвинутым» я сразу ставил время жизни куки – 5 лет. Логика рассуждений была проста – зачем пользователю постоянно логиниться, ведь что может поменяться? Я был неправ и не только в этом.
**Как я пришел к API.** Необходимость загружать мультимедийный контент в виде видеофайлов для демонстрации пользователям на страницах заданий предопределило необходимость поиска оптимального хранилища для этого. Варианты загрузки файлов на YouTube, другие ресурсы и дальнейшая вставка на сайт не рассматривались. Пришлось думать над созданием собственного сервера. Почему-то в тот момент не подумал о поднятии сайта сразу на своем сервере.
Готовые серверы рассматривать не стал, но выдвигалось пара требований – пассивный блок питания и минимальный размер. Был приобретен mini-itx корпус (5х20х20см.) с блоком питания PSU (внешний блок без вентиляторов на 90 ватт) как у ноутбуков. Установлен SSD на 240 Gb, 12 Гб оперативной памяти (думал с запасом для запуска виртуальных машин). Процессор Intel G4600 (2 ядра, 4 потока) на сокете LGA 1151. Материнская плата оборудована Wi-fi.
У провайдера была подключена услуга статического белого IP адреса, поднят OpenServer на Windows машине.
Маршрутизатор с прошивкой Padavan. Прошивка неплохая за исключением того, что умеет работать только с SMB версии 1, которая в Windows уже отключена по причине безопасности. На роутере был настроен проброс 8080 порта на адрес локальной машины, привязанной статическим адресом через MAC-адрес (чтобы dhcp не давало другие IP адреса после перезагрузки).
Установив сервер и настроив A-запись созданного поддомена api.\*\*\*.ru на хостинге через несколько часов получил доступ из сети Интернет на apache сервер OpenServera. Также был настроен alias для направления запросу на внутреннюю папку с доменом.
API захотелось написать самостоятельно (думаю, можно было использовать для этих целей SlimPhp 4 или Lumen).
API представляло собой небольшой framework, имеющий единую точку входа. Классы подключались автолоадером composer. Дальнейшая маршрутизация осуществлялась с проверкой метода и параметров query запроса:
```
$items = explode("/", $_GET['query']);
$endpoint = $items['0'];
$params = $items['1'];
Нужный файл подключался путем:
require_once('api/1.0/' . $endpoint . '.php');
Так как payload запроса был в формате JSON, я преобразовал его так (для дальнейшей работы нужны были оба формата):
$POST_JSON = json_decode(file_get_contents('php://input'), true);
$POST = file_get_contents('php://input');
```
Ядро системы составлял файл Db с подключением к базе данных (шаблон - синглтон), а также содержащий основные методы работы на низком уровне PDO. Абстрактный класс модели содержал высокоуровневые запросы типа findOne (поиск по id), findLike, count и т.д. Также были созданы 2 класса моделей, наследующих (расширяющих основной класс модели): (пользователи, квесты), отдельный файл вспомогательных функций (helpers), а также 3 файла основного API – library (библиотека), quests (квесты) и users (пользователи). Была создана примитивная защита от CSRF атак, представляющая собой передачу на сервер 2 полей, в одном из которых хранился цифровой код, генерируемый рандомно, а во втором ответ. Смысл проверки был в математическом преобразовании первого поля по заранее известному алгоритму, описанному в коде, чтобы получить второе значение.
Немного забегая вперед (когда я отошел от сохранения в базе html кода и стал использовать в полном объеме реляционность базы данных) приведу подход, вызванный ленью для вставки или обновления базы. Приведенная функция позволяла автоматически формировать запрос SQL (уж очень не хотелось копировать каждый раз поля):
```
//------------------------ДЛЯ INSERT UPDATE PDO
function pdoSet($source = array())
{
$fields = array_keys($source);
$set = '';
$values = array();
foreach ($fields as $field) {
if (isset($source[$field]) and $field !== 'id') {
$set .= "`" . str_replace("`", "``", $field) . "`" . "=:$field, ";
$values[$field] = $source[$field];
}
}
return substr($set, 0, -2);
}
В модели функция применялась так:
public function saveIcon($icon)
{
$sql = "INSERT INTO icons SET " . pdoSet($icon) . " ON DUPLICATE KEY UPDATE " . pdoSet($icon);
return $this->pdo->save($sql, $icon);
}
```
Не преследуя цели детального технического описания работы системы, остановлюсь на ряде трудностей, с которыми пришлось столкнуться в тот момент.
**Как передавать файлы.** У меня было на рассмотрении 2 варианта – передача сразу напрямую в бинарном формате (либо base64, так как файлы были небольшими) на сервер, либо загрузка файлов на хостинг, а потом копирование file\_get\_contents сервером к себе. И я выбрал сложный вариант – не знаю почему (нет, знаю – в интернете были такие примеры): сначала файлы заливались на хостинг, а потом я их копировал на сервер. С именами и местом расположения файлов были отдельные сложности, так как я хотел расположить файлы в папке с именем/логином пользователя, а логином был адрес электронной почты. Наличие точек в имени папки в отдельных случаях вводило в ступор скрипты php. Думаю, что подробности не будут так интересны широкой массе, но хлопот мне это доставило. Решение: замена спецсимволов и точек (я заменил на дефис, хотя для JS это не очень хорошо, но как есть).
**Сложности единой авторизации на 2 сайтах под одной учетной записью.** На первых этапах решалось это путем передачи GET параметров в адресной строке. Подход, конечно, не эффективный и очень небезопасный, но рабочий. Стал искать решение, оказалось, что можно передавать через кроссдоменные запросы Coockie, дополнять и возвращать на сайт. Coockie, прилетевшая с API содержала в себе заголовок, который видоизменял Coockie в браузере пользователя и авторизовывал его. За это отвечает атрибут SameSite. В 2019 году такую возможность в целях безопасности усложнили, поэтому у меня все перестало работать. Вчера работало, а сегодня уже нет (вышло обновление браузера). Пришло искать причину. Решением проблемы оказался переход на https (о нем ниже) и явное указание в заголовках «SameSite=None, Secure». Конечно, можно было использовать OAuth, но…знал бы прикуп…
**Протокол http.** Сайты изначально работали на протоколе http, уже тестировал сокеты (о них далее), и тут думаю, что же все с замком в адресной строке, а я в каменном веке. Сделал себе на хостинге Let’s Encrypt сертификат и активировал. Проведя немного тестов, понял, что сокеты не работают и надо (смешанное содержимое – mixed content) откатился назад. SSL и https отключил. О настройках .htaccess рассказывать не буду, но нервы мне это помотало (оказалось, что задержка хостинга была несколько десятков минут при изменении параметров). Я и многие пользователи столкнулись с проблемой появления предупреждения браузера, что, конечно, было неприятно. Объяснять пользователям как указать браузеру заходить по http, когда он уже удачно 1 раз по https мне оказалось не под силу. Решено – переходим на https снова.
**Адаптивность.** Несмотря на то, что я как «современный веб-мастер» использовал адаптивную верстку, предоставляемую Bootstrap проблема была в абсолютном позиционировании элементов. Основная рабочая область («div» с размером 1200 на 800 пикселей) была рассчитана под экраны компьютера с разрешением fullHD, пока о телефонах речи не шло. Оказалось, что такие экраны есть далеко не у всех и верстка слетала. Да, можно было поправить сжатие области (фон также уменьшался в размерах) путем задания процентных соотношений ширины 100%, однако элементы и иконки, имеющие абсолютное позиционирование, не хотели сами следить за фоном и образовывали хаос. Меня посетила мысль перебирать в цикле позиционирование элементов и выставлять новые значения исходя из размера рабочей области, однако надо было переделывать и добавление иконок с корректным сохранением их в базе данных, масштаб текста и т.д. В тот момент я отказался от такого подхода (сейчас все делают Хуки React для всех разрешений и динамическом изменении размера, к примеру – поворот мобильного устройства, за что отдельное спасибо разработчикам).
Пример как это **неудачно выглядело** на небольших экранах.
**Взаимная интеграция.** Были сложности с взаимным обменом данных между сайтами. Изначально я рассчитывал осуществлять обмен с помощью базы данных SQL, однако каждый из сайтов изначально работал со своей базой, расположенной на своем localhost, поэтому на сервере была сделана еще одна база, доступ к которой был открыт удаленно. Получилось много баз с разными полями, иногда повторяющими друг друга. Работать с хранимыми процедурами, а также использовать FEDERATED Storage Engine я не потянул, поэтому получились сложные и часто однотипные запросы к разным базам для выборки типа JOIN. И тут же столкнулся с проблемами: разработка приложения требовала активную работу с БД и пришлось менять во всех местах аналогичные части кода. Бывало, и 4 места, содержащих почти одинаковый код. Сделал урок для себя: дублирование кода очень – весомая ошибка при проектировании программ.
**Нагромождение кода приложения.** Квестовая система, позволяющая осуществлять переход по ссылкам и заменить содержимое DOM-дерева вроде работала, но я подумал – а где же сами квесты? Где диалоги, вопросы, пароли для прохождения в секретные зоны и т.д. Решено – будем делать. Начал я с простого – создал новый тип иконок (первый вид – просто переход по слайдам), который отвечал за открытие модального окна Bootstrap и демонстрации текста и фото. Смысл этого окна был в показе детального описания и фото предмета, находящегося в рабочей зоне слайда. Потом ~~Остапа понесло~~ пришла мысль: а как же диалоги – какой квест без диалогов? Сделано. А где же тесты – это ведь СДО – пришлось интегрировать, а точнее заново написать систему тестирования. Далее – хочешь пройти в какую-то локацию – назови пароль (ответь на вопрос). Итог: сделано окно с вопросом и проверкой ответа.
**Как итог:** скрипты сильно разрослись в размере, стало сложно что-то понимать через пару дней. Так как все работало в процедурном стиле на асинхронных функциях, то было все очень запутанно и вообще… слов нет от такого бардака. Работа с кодом велась в большей степени с помощью replace строковых данных на новые id и замене data-атрибутов.
Пример функции активации перетаскивания иконки:
```
//==========АКТИВАЦИЯ ПЕРЕТАСКИВАНИЕ=======
function activeDrop() {
console.log('сработала: activeDrop');
$(".drop-td").droppable({
accept: '.item_library, .clone',
// hoverClass: "bg-info",
drop: function (event, ui) {
if (ui.draggable.hasClass('fon')) {
$.ajax({
url: '= TEMPLATE ?/ajax/ajaxCopyImage',
dataType: 'text',
type: 'post',
data: {type: $(ui.draggable).attr('data-type'), name: $(ui.draggable).attr('data-img'), path: $(ui.draggable).attr('data-path')},
success: function () {
number_slide = $("#work_zone").attr('data-slideWork');
img = $(ui.draggable).attr('data-img');
$("#table_zone").css("background-image", "url(../public/LIBRARY/USE_CONTENT/= EMAIL ? EMAIL : '' ?/backgrounds/" + img + ")");
$.when(screenshot()).then(function (data) {
refresh_arrays();
}).then(function () {
ajaxSaveSlide();
});
}
});
return false;
} else if (ui.draggable.hasClass('clone')) {
pos_Y = $(ui.draggable).position().top;
pos_X = $(ui.draggable).position().left;
$(ui.draggable).css({'position': 'absolute', 'left': pos_X, 'top': pos_Y});
$.when(screenshot()).then(function (data) {
refresh_arrays();
});
return false;
} else if (ui.draggable.hasClass('item_library')) {
clone = ui.draggable.clone();
var parentOffset = jQuery('.drop-td').offset();
$(this).append(clone.removeClass("ui-draggable item_library").addClass('clone').css({'position': 'absolute', 'left': (ui.position.left - parentOffset.left) + 'px', 'top': (ui.position.top - parentOffset.top) + 'px'}));
// -----------------
// clone = ui.draggable.clone();
// $(this).append(clone.removeClass("ui-draggable item_library").addClass('clone').css('position', 'relative'));
// pos_Y = $(clone).position().top;
// pos_X = $(clone).position().left;
// $(clone).css({'position': 'absolute', 'left': pos_X, 'top': pos_Y});
// ------------------
if ($(clone).is('[src]')) {
$.ajax({
url: '= TEMPLATE ?/ajax/ajaxCopyImage',
dataType: 'text',
type: 'post',
data: {type: $(ui.draggable).attr('data-type'), name: $(ui.draggable).attr('data-img'), path: $(ui.draggable).attr('data-path')},
success: function () {
src = $(clone).attr('src');
if ($(ui.draggable).attr('data-path') == 'system') {
src_new = src.replace("LIBRARY", "LIBRARY/USE_CONTENT/= EMAIL ?");
} else {
src_new = src.replace("USERS", "USE_CONTENT");
}
$(clone).attr('src', src_new);
}
});
}
$.when(screenshot()).then(function (data) {
refresh_arrays();
}).then(function () {
ajaxSaveSlide();
});
}
$(".clone").draggable({
revert: "invalid",
distance: 10
});
}
});
```
Пару слов о создании скриншотов, расположенных слева от рабочей области. Был создан наблюдатель, который все изменения фиксировал путем:
```
$(function () {
var target = document.getElementById('work_zone');
var observer = new MutationObserver(function (mutations) {
mutations.forEach(function (mutation) {
// refresh_arrays();
});
});
var config = {attributes: true, childList: true, characterData: true, subtree: true};
//var config = {attributes: true, childList: true};
observer.observe(target, config);
});
refresh_arrays() вызывала скриншот.
//========================СКРИНШОТ
function screenshot() {
console.log('сработала: screenshot');
number_slide = get_number_slide();
// html2canvas(document.querySelector("body")).then(function (canvas) {
// document.body.appendChild(canvas);
// });
scrollTop = 0 - window.pageYOffset;
return html2canvas(document.querySelector("#table_zone"), {logging: false, scrollY: scrollTop})
.then(canvas => {
// document.body.appendChild(canvas);
dataURL = canvas.toDataURL();
old = $("[data-slide=" + number_slide + "] [data-fonSlide='']").css('background-image');
old = old.slice(4, -1).replace(/"/g, "");
})
.then(function () {
return $.ajax({
url: '= TEMPLATE ?/ajax/ajaxLibraryAddSlide',
dataType: 'text',
type: 'post',
data: {base_64: dataURL, old: old},
success: function (data) {
$("[data-slide=" + number_slide + "] [data-fonSlide='']").css("background-image", 'url(' + data + ')');
}
});
}).then(function () {
});
}
```
В какой-то момент я понял – так жить нельзя, учитывая, что это всего лишь малая часть задуманного мною приложения, а я уже запутался и сам иногда не разберусь в своем же коде. Если с PHP ситуация проще – там ООП, то здесь – тушите свет. Писать в стиле ООП JS я не умел, а признаться честно, и сейчас не умею – пробовал, но понял, что смысла для решаемых мною задач особо нет, но этом далее.
**Какие выводы можно сделать?** Архитектуру приложения надо продумывать с точки зрения трудозатрат, да и временных рамок более серьезно, чем писать код – это я еще не раз пойму дальше.
**Конец 2 части.**
[Часть 1. Аналог Moodle или как преподаватель-юрист создавал собственную систему дистанционного обучения. Часть 1. Начало](https://habr.com/ru/post/590605/)
[Часть 2. Создание аналога Moodle. Реализация API для прототипа SPA. Межсайтовые запросы. Первые проблемы архитектуры](https://habr.com/ru/post/590881/)
[Часть 3. Выявление технических методов повышения уникальности текста с помощью PHP (в рамках создания собственной СДО)](https://habr.com/ru/post/591457/)
[Часть 4. Выбор фреймворка и переход на Laravel в рамках создания собственной СДО](https://habr.com/ru/post/592521/)
Часть 5. Переход на ReactJs, внедрение flux, SOLID и интеграция в Laravel.
Часть 6. Внедрение нейронных сетей в работу СДО. | https://habr.com/ru/post/590881/ | null | ru | null |
# Создание карт из функций шума
Одна из самых популярных статей на моём сайте посвящена [генерации полигональных карт](http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/) ([перевод](https://habr.com/post/322504/) на Хабре). Создание таких карт требует много усилий. Но начинал я не с этого, а с *гораздо* более простой задачи, которую опишу здесь. Эта простая техника позволяет создавать подобные карты меньше чем в 50 строках кода:
Я не буду объяснять, как *отрисовывать* такие карты: это зависит от языка, графической библиотеки, платформы и т.д. Я просто объясню, как *заполнить массив* данными карты.
Шум
---
Стандартный способ генерации 2D-карт заключается в использовании в качестве строительного блока функции шума с ограниченной полосой частот, например шума Перлина или симплексного шума. Вот, как выглядит функция шума:
Мы присваиваем каждой точке карты число от 0.0 до 1.0. В этом изображении 0.0 — это чёрный цвет, а 1.0 — белый. Вот как задать цвет каждой точке сетки в синтаксисе похожего на C языка:
```
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
double nx = x/width - 0.5, ny = y/height - 0.5;
value[y][x] = noise(nx, ny);
}
}
```
Цикл будет работать одинаково в Javascript, Python, Haxe, C++, C#, Java и большинстве других популярных языков, поэтому я покажу его в C-подобном синтаксисе, чтобы вы могли преобразовать его в нужный вам язык. В оставшейся части туториала я покажу, как изменяется тело цикла (строка `value[y][x]=…`) при добавлении новых функций. В демо будет показан полный пример.
В некоторых библиотеках необходимо будет сдвигать или умножать получаемые значения, чтобы возвратить их в интервал от 0.0 до 1.0.
Высота
------
Сам по себе шум — это просто набор чисел. Нам нужно наделить его *смыслом*. Первое, о чём можно подумать — привязать значение шума к высоте (это называется «картой высот»). Давайте возьмём показанный выше шум и отрисуем его как высоты:
Код остался почти таким же, за исключением внутреннего цикла. Теперь он выглядит так:
```
elevation[y][x] = noise(nx, ny);
```
Да, и это всё. Данные карты остались такими же, но теперь я буду называть их `elevation` (высотой), а не `value`.
У нас получилось много холмов, но ничего больше. Что не так?
### Частота
Шум может генерироваться при любой *частоте*. Пока я выбирал только одну частоту. Давайте посмотрим, как она влияет.
**Попробуйте изменять значение ползунком** (в оригинале статьи) и посмотрите, что происходит при разных частотах:
Здесь просто меняется масштаб. Сначала это кажется не очень полезным, но это не так. У меня есть ещё один [туториал](https://www.redblobgames.com/articles/noise/introduction.html) ([перевод](https://habr.com/post/321874/) на Хабре), в котором объясняется *теория*: такие понятия, как частота, амплитуда, октавы, розовый и синий шум, и так далее.
```
elevation[y][x] = noise(freq * nx, freq * ny);
```
Также иногда полезно вспомнить о *длине волны*, являющейся обратной частоте величиной. При удвоении частоты размер всего вдвое уменьшается. Удвоение длины волны всё вдвое увеличивается. Длина волны — это расстояние, измеряемое в пикселях/тайлах/метрах или любых других единицах, которые вы выбрали для карт. Она связана с частотой: `wavelength = map_size / frequency`.
### Октавы
Чтобы сделать карту высот интереснее, мы *добавим шум с разными частотами*:
```
elevation[y][x] = 1 * noise(1 * nx, 1 * ny);
+ 0.5 * noise(2 * nx, 2 * ny);
+ 0.25 * noise(4 * nx, 2 * ny);
```
Давайте смешаем в одной карте большие низкочастотные холмы с мелкими высокочастотными холмами. **Перемещайте ползунок** (в оригинале статьи), чтобы добавлять в смешение мелкие холмы:
Теперь это гораздо больше походит на нужный нам фрактальный рельеф! Мы можем получить холмы и неровные горы, но у нас по-прежнему нет плоских равнин. Для этого нужно что-то ещё.
### Перераспределение
Функция шума даёт нам значения в интервале от 0 и 1 (или от -1 до +1, в зависимости от библиотеки). Чтобы создать плоские равнины, мы можем *возвести высоту в степень*. **Перемещайте ползунок** (в оригинале статьи), чтобы получать разные степени.
```
e = 1 * noise(1 * nx, 1 * ny);
+ 0.5 * noise(2 * nx, 2 * ny);
+ 0.25 * noise(4 * nx, 4 * ny);
elevation[y][x] = Math.pow(e, exponent);
```
Высокие значения *опускают средние высоты в равнины*, а низкие значения поднимают средние высоты в сторону горных пиков. Нам нужно опустить их. Я использую степенные функции, потому что они проще, но вы можете использовать любую кривую; у меня есть более сложное [демо](https://www.redblobgames.com/articles/noise/2d/#spectrum).
Теперь, когда у нас есть реалистичная карта высот, давайте добавим биомы!
Биомы
-----
Шум даёт числа, но нам нужна карта с лесами, пустынями и океанами. Первое, что можно сделать — превратить малые высоты в воду:
```
function biome(e) {
if (e < waterlevel) return WATER;
else return LAND;
}
```
Ого, это уже становится похоже на процедурно сгенерированный мир! У нас есть вода, трава и снег. Но что, если нам понадобится больше? Давайте сделаем последовательность из воды, песка, травы, леса, саванны, пустыни и снега:
*Рельеф на основании высоты*
```
function biome(e) {
if (e < 0.1) return WATER;
else if (e < 0.2) return BEACH;
else if (e < 0.3) return FOREST;
else if (e < 0.5) return JUNGLE;
else if (e < 0.7) return SAVANNAH;
else if (e < 0.9) return DESERT;
else return SNOW;
}
```
Ух ты, выглядит здорово! Для своей игры можете поменять значения и биомы. В Crysis будет намного больше джунглей; в Skyrim намного больше льда и снега. Но как бы вы ни меняли числа, такой подход довольно ограничен. Типы рельефа соответствуют высотам, поэтому формируют полосы. Чтобы сделать их интереснее, нам нужно выбирать биомы на основе чего-то другого. Давайте создадим *вторую* карту шума для влажности.
*Сверху — шум высот; снизу — шум влажности*
Теперь давайте используем высоту и влажность *вместе*. На первом показанном ниже изображении ось y — это высота (взятая из изображения выше), а ось x — влажность (второе изображение выше). Это даёт нам убедительную карту:
*Рельеф на основании двух значений шума*
Малые высоты — это океаны и побережья. Большие высоты каменистые и заснеженные. В промежутке между ними мы получаем широкий диапазон биомов. Код выглядит так:
```
function biome(e, m) {
if (e < 0.1) return OCEAN;
if (e < 0.12) return BEACH;
if (e > 0.8) {
if (m < 0.1) return SCORCHED;
if (m < 0.2) return BARE;
if (m < 0.5) return TUNDRA;
return SNOW;
}
if (e > 0.6) {
if (m < 0.33) return TEMPERATE_DESERT;
if (m < 0.66) return SHRUBLAND;
return TAIGA;
}
if (e > 0.3) {
if (m < 0.16) return TEMPERATE_DESERT;
if (m < 0.50) return GRASSLAND;
if (m < 0.83) return TEMPERATE_DECIDUOUS_FOREST;
return TEMPERATE_RAIN_FOREST;
}
if (m < 0.16) return SUBTROPICAL_DESERT;
if (m < 0.33) return GRASSLAND;
if (m < 0.66) return TROPICAL_SEASONAL_FOREST;
return TROPICAL_RAIN_FOREST;
}
```
При необходимости можете изменять все эти значения в соответствии с требованиями своей игры.
Если же нам не нужны биомы, то плавные градиенты (см. [эту статью](http://www.shadedrelief.com/hypso/hypso.html)) могут создавать цвета:
И для биомов, и для градиентов одно значение шума не обеспечивает достаточной вариативности, но двух вполне достаточно.
Климат
------
В предыдущем разделе я использовал *высоту* как замену *температуры*. Чем больше высота, тем ниже температуры. Однако на температуры также влияет географическая широта. Давайте используем для контроля температуры и высоту, и широту:
Рядом с полюсами (большие широты) климат холоднее, а на вершинах гор (большие высоты) климат тоже холоднее. Пока я проработал это не очень сильно: для правильного подхода к этим параметрам нужно множество тонких настроек.
Также существует *сезонное* изменение климата. Летом и зимой северное и южное полушарие становятся теплее и холоднее, но на экваторе ситуация особо не меняется. Здесь тоже можно сделать многое, например, можно смоделировать преобладающие ветра и океанские течения, влияние биомов на климат и усредняющее влияние океанов на температуры.
Острова
-------
В некоторых проектах мне было нужно, чтобы границы карты были водой. Это превращает мир в один или несколько островов. Существует множество способов сделать это, но в своём генераторе полигональных карт я использовал довольно простое решение: я изменял высоту как `e = e + a - b*d^c`, где `d` — расстояние от центра (в масштабе 0-1). Ещё один вариант заключается в изменении `e = (e + a) * (1 - b*d^c)`. Константа `a` поднимает всё вверх, `b` опускает края вниз, а `c` управляет скоростью снижения.
*Я не совсем доволен этим* и ещё многое предстоит исследовать. Должно ли это быть манхэттанское или эвклидово расстояние? Должно ли оно зависеть от расстояния до центра или от расстояния до края? Должно ли расстояние возводиться в квадрат, или быть линейным, или иметь какую-то другую степень? Должно ли это быть сложение/вычитание, или умножение/деление, или что-то ещё? В оригинале статьи **попробуйте** Add, a = 0.1, b = 0.3, c = 2.0 или **попробуйте** Multiply, a = 0.05, b = 1.00, c = 1.5. Подходящие вам параметры зависят от вашего проекта.
Зачем вообще придерживаться стандартных математических функций? Как я рассказал в своей [статье об уроне в RPG](https://www.redblobgames.com/articles/probability/damage-rolls.html#nonparametric) ([перевод](https://habr.com/post/335840/) на Хабре), все (в том числе и я) пользуются математическими функциями, такими как многочлены, показательные распределения и т.п., но на компьютере мы можем ими не ограничиваться. Мы можем взять *любую* функцию формирования и использовать её здесь, воспользовавшись таблицей поиска `e = e + height_adjust[d]`. Пока этот вопрос я не изучал.
Остроконечный шум
-----------------
Вместо возведения высоты в степень, мы можем использовать абсолютное значение, чтобы создать острые пики:
```
function ridgenoise(nx, ny) {
return 2 * (0.5 - abs(0.5 - noise(nx, ny)));
}
```
Чтобы добавить октавы, мы можем варьировать амплитуды больших частот, чтобы добавленный шум получали только горы:
```
e0 = 1 * ridgenoise(1 * nx, 1 * ny);
e1 = 0.5 * ridgenoise(2 * nx, 2 * ny) * e0;
e2 = 0.25 * ridgenoise(4 * nx, 4 * ny) * (e0+e1);
e = e0 + e1 + e2;
elevation[y][x] = Math.pow(e, exponent);
```
У меня не такой большой опыт работы с этой техникой, поэтому мне нужно поэкспериментировать, чтобы научиться хорошо ею пользоваться. Возможно, будет интересно также смешать остроконечный низкочастотный шум с неостроконечным высокочастотным.
Террасы
-------
Если мы округлим высоту до ближайших n уровней, мы получим террасы:
Это результат применения функции перераспределения высот в виде `e = f(e)`. Выше мы использовали `e = Math.pow(e, exponent)`, чтобы сделать резче горные пики; здесь мы используем `e = Math.round(e * n) / n` для создания террас. Если использовать не ступенчатую функцию, то террасы могут быть округлей или возникать только на некоторых высотах.
Размещение деревьев
-------------------
Обычно мы использовали фрактальный шум для высоты и влажности, но его можно применять и для размещения неравномерно расставленных объектов, таких как деревья и камни. Для высоты мы используем высокие амплитуры с низкими частотами («красный шум»). Для размещения объектов нужно использовать высокие амплитуды с высокими частотами («синий шум»). Слева показан паттерн синего шума; справа показаны места, где шум больше соседних значений:
```
for (int yc = 0; yc < height; yc++) {
for (int xc = 0; xc < width; xc++) {
double max = 0;
// существуют более эффективные алгоритмы
for (int yn = yc - R; yn <= yc + R; yn++) {
for (int xn = xc - R; xn <= xc + R; xn++) {
double e = value[yn][xn];
if (e > max) { max = e; }
}
}
if (value[yc][xc] == max) {
// размещаем дерево в xc,yc
}
}
}
```
Выбирая для каждого биома разные R, мы можем получить переменную плотность деревьев:
Здорово, что такой шум можно использовать для размещения деревьев, но часто более эффективны и создают более равномерное распределение другие алгоритмы: пятна Пуассона, плитки Вана или графический дизеринг.
В бесконечность и дальше
------------------------
Вычисления биома в позиции (x,y) не зависят от вычислений всех других позиций. Это **локальное вычисление** обладает двумя удобными свойствами: его можно вычислять параллельно, и его можно использовать для бесконечного рельефа. **Поместите курсор мыши на миникарту** (в оригинале статьи) слева, чтобы сгенерировать карту справа. Можно генерировать любую часть карты без генерации (и даже без хранения) всей карты.
Реализация
----------
Использование шума для генерации рельефа — популярное решение, и в Интернете можно найти туториалы для множества разных языков и платформ. Код генерации карты на разных языках примерно одинаков. Вот простейший цикл на трёх разных языках:
* **Javascript:**
```
let gen = new SimplexNoise();
function noise(nx, ny) {
// Rescale from -1.0:+1.0 to 0.0:1.0
return gen.noise2D(nx, ny) / 2 + 0.5;
}
let value = [];
for (let y = 0; y < height; y++) {
value[y] = [];
for (let x = 0; x < width; x++) {
let nx = x/width - 0.5, ny = y/height - 0.5;
value[y][x] = noise(nx, ny);
}
}
```
* **C++:**
```
module::Perlin gen;
double noise(double nx, double ny) {
// Rescale from -1.0:+1.0 to 0.0:1.0
return gen.GetValue(nx, ny, 0) / 2.0 + 0.5;
}
double value[height][width];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
double nx = x/width - 0.5,
ny = y/height - 0.5;
value[y][x] = noise(nx, ny);
}
}
```
* **Python:**
```
from opensimplex import OpenSimplex
gen = OpenSimplex()
def noise(nx, ny):
# Rescale from -1.0:+1.0 to 0.0:1.0
return gen.noise2d(nx, ny) / 2.0 + 0.5
value = []
for y in range(height):
value.append([0] * width)
for x in range(width):
nx = x/width - 0.5
ny = y/height - 0.5
value[y][x] = noise(nx, ny)
```
Все библиотеки шума довольно похожи друг на друга. Попробуйте [opensimplex для Python](https://pypi.python.org/pypi/opensimplex/), или [libnoise для C++](http://libnoise.sourceforge.net/docs/), или [simplex-noise](https://www.npmjs.com/package/simplex-noise) для Javascript. Для большинства популярных языков существует множество библиотек шума. Или же вы можете изучить, как работает шум Перлина или реализовать шум самостоятельно. *Я этого не делал.*
В разных библиотеках шума для вашего языка подробности применения могут слегка различаться (некоторые возвращают числа в интервале от 0.0 до 1.0, другие — в интервале от -1.0 до +1.0), но основная идея одинакова. Для реального проекта вам может потребоваться обернуть функцию `noise` и объект `gen` в класс, но эти подробности не относятся к делу, поэтому я сделал их глобальными.
Для такого простого проекта не важно, какой шум вы используете: шум Перлина, симплексный шум, шум OpenSimplex, value noise, смещение средних точек, алгоритм diamond или обратное преобразование Фурье. У каждого из них есть свои плюсы и минусы, но для подобного генератора карт все они создают более-менее одинаковые выходные значения.
*Отрисовка* карты зависит от платформы и игры, поэтому её я не реализовал; этот код нужен только для генерации высот и биомов, отрисовка которых зависит от использованного в игре стиля. Можете копировать, портировать и использовать его в своих проектах.
Эксперименты
------------
Я рассмотрел смешивание октав, возведение высоты в степень и комбинирование высоты с влажностью для получения биома. [Здесь](https://www.redblobgames.com/maps/terrain-from-noise/#demo) можно изучить интерактивный график, позволяющий поэкспериментировать со всеми этими параметрами, который показывает, из чего состоит код:
Вот пример кода:
```
var rng1 = PM_PRNG.create(seed1);
var rng2 = PM_PRNG.create(seed2);
var gen1 = new SimplexNoise(rng1.nextDouble.bind(rng1));
var gen2 = new SimplexNoise(rng2.nextDouble.bind(rng2));
function noise1(nx, ny) { return gen1.noise2D(nx, ny)/2 + 0.5; }
function noise2(nx, ny) { return gen2.noise2D(nx, ny)/2 + 0.5; }
for (var y = 0; y < height; y++) {
for (var x = 0; x < width; x++) {
var nx = x/width - 0.5, ny = y/height - 0.5;
var e = (1.00 * noise1( 1 * nx, 1 * ny)
+ 0.50 * noise1( 2 * nx, 2 * ny)
+ 0.25 * noise1( 4 * nx, 4 * ny)
+ 0.13 * noise1( 8 * nx, 8 * ny)
+ 0.06 * noise1(16 * nx, 16 * ny)
+ 0.03 * noise1(32 * nx, 32 * ny));
e /= (1.00+0.50+0.25+0.13+0.06+0.03);
e = Math.pow(e, 5.00);
var m = (1.00 * noise2( 1 * nx, 1 * ny)
+ 0.75 * noise2( 2 * nx, 2 * ny)
+ 0.33 * noise2( 4 * nx, 4 * ny)
+ 0.33 * noise2( 8 * nx, 8 * ny)
+ 0.33 * noise2(16 * nx, 16 * ny)
+ 0.50 * noise2(32 * nx, 32 * ny));
m /= (1.00+0.75+0.33+0.33+0.33+0.50);
/* draw biome(e, m) at x,y */
}
}
```
Здесь есть сложность: для шума высот и влажности необходимо использовать разный seed, в противном случае они окажутся одинаковыми, и карты будут выглядеть не так интересно. В Javascript я использую [библиотеку prng-parkmiller](https://www.npmjs.com/package/prng-parkmiller-js); в C++ можно использовать два отдельных [объекта linear\_congruential\_engine](http://www.cplusplus.com/reference/random/linear_congruential_engine/linear_congruential_engine/); в Python можно создать два отдельных экземпляра [random.Random class](https://docs.python.org/3/library/random.html).
Мысли
-----
Этот подход к генерации карт мне нравится своей **простотой**. Он быстр и требует очень мало кода для создания приличных результатов.
Не нравится мне в этом подходе его ограниченность. Локальные вычисления означают, что каждая точка независима от всех других. Разные области карты *не связаны друг с другом*. Каждое место на карте «кажется» одинаковым. Здесь не существует глобальных ограничений, например «на карте должно быть от 3 до 5 озёр» или глобальных характерных особенностей, например реки, текущей с вершины высочайшего пика в океан. Также мне не нравится то, что для получения хорошей картинки нужно долго настраивать параметры.
Почему же я его рекомендую? Я считаю, что это хорошая отправная точка, особенно для инди-игр и гейм-джемов. Двое моих друзей написали первоначальную версию [Realm of the Mad God](https://en.wikipedia.org/wiki/Realm_of_the_Mad_God) всего за 30 дне для [игрового конкурса](http://www.tigsource.com/2010/02/07/assemblee-competition-results/). Они попросили меня помочь в создании карт. Я использовал эту технику (плюс ещё несколько функций, оказавшихся не особо полезными) и сделал им карту. Через несколько месяцев, получив отзывы игроков и внимательнее изучив дизайн игры, мы создали более продвинутый генератор карт на основе многоугольников Вороного, описанный [здесь](http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/) ([перевод](https://habr.com/post/322504/) на Хабре). В этом генераторе карт не используются описанные в данной статье техники. В нём шум для создания карт применяется совсем по-другому.
Дополнительная информация
-------------------------
Существует *множество* крутых вещей, которые можно сделать с помощью функций шума. Если поискать в Интернете, то можно найти такие варианты, как turbulence, billow, ridged multifractal, amplitude damping, terraced, voronoi noise, analytical derivatives, domain warping и другие. Можно использовать [эту страницу](http://iquilezles.org/www/articles/warp/warp.htm) как источник вдохновения. Здесь я их не рассматриваю, моя статья сосредоточена на простоте.
На этот проект повлияли мои предыдущие проекты генерации карт:
* Я использовал общий шум Перлина для [моего первого генератора карт игры Realm of the Mad God](http://simblob.blogspot.com/2010/01/simple-map-generation.html). Мы использовали его для первых шести месяцев альфа-тестирования, а затем заменили его на [генератор карт на многоугольниках Вороного](http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/), специально созданный под требования геймплея, определённые нами в процессе альфа-тестирования. Биомы и их цвета для статьи взяты из этих проектов.
* При изучении обработки звуковых сигналов я написал [туториал по шуму](https://www.redblobgames.com/articles/noise/2d/#spectrum), в котором объясняются такие концепции, как частота, амплитуда, октавы и «цвет» шума. Те же концепции, работающие для звука, также применимы для генерации карт на основе шума. В то время я создал несколько сырых [демо генерации рельефа](https://www.redblobgames.com/articles/noise/2d/), но так их и не доделал.
* Иногда я экспериментирую, чтобы найти границы. Я хотел узнать, сколько кода минимально необходимо для создания убедительных карт. В [этом минипроекте](https://www.redblobgames.com/x/1446-svg-filters/) я дошёл до **нуля** строк кода — всё делается фильтрами изображений (турбулентность, пороги, цветовые градиенты). Это меня и порадовало, и огорчило. В какой степени генерация карт может выполняться фильтрами изображений? В достаточно большой. Всё, рассказанное выше о «схеме плавных цветовых градиентов» взято из этого эксперимента. Слой шума — это фильтр изображения «турбулентность»; октавы — это изображения, наложенные друг на друга; инструмент степени называется в Photoshop «коррекция кривых».
Меня немного напрягает то, что бОльшая часть кода, которую пишут разработчики игр для генерации рельефа на основе шума (в том числе и смещение средней точки (midpoint displacement)), оказывается той же, что и в фильтрах звука и изображений. С другой стороны, он создаёт вполне достойные результаты всего в нескольких строках кода, поэтому я и написал данную статью. Это *быстрая и простая опорная точка*. Обычно я не использую такие карты долго, а заменяю их на более сложный генератор карт, как только узнаю, какие типы карт лучше подойдут к дизайну игры. Для меня это является стандартным паттерном: начинать с чего-то чрезвычайно простого, а потом заменять это только после того, как я лучше пойму систему, с которой работаю.
Есть ещё *множество* штук, которые можно проделать с шумом, в статье я упомянул лишь несколько. Попробуйте [Noise Studio](https://codepen.io/MittenedWatchmaker/full/aVeoRM/), чтобы интерактивно протестировать различные возможности. | https://habr.com/ru/post/430384/ | null | ru | null |
# Утечка исходного кода Winamp (843 МБ)
В веб-архиве обнаружили [репозиторий с исходным кодом Winamp](https://web.archive.org/web/20210515031018/https://github.com/CONIGUERO/winamp), который был удалён в мае 2021 года или позже. Хотя сохранились не все файлы самого репозитория, зато успешно скопировался файл [winamp-main.zip](https://web.archive.org/web/20210418214109if_/https://codeload.github.com/CONIGUERO/winamp/zip/refs/heads/main) по ссылке «Скачать весь архив» из зеркала репозитория ([альтернативная версия](https://app.nihaocloud.com/f/4fb0b449f18f4eaca90c/), файл `winamp-cvs.zip`).
Похоже, что копия лежит в веб-архиве несколько месяцев, но только сейчас [привлекла внимание аудитории на HN](https://news.ycombinator.com/item?id=29379346), в связи с чем её могут в ближайшее время быстро удалить.
Размер архива `winamp-cvs.zip` составляет 291,8 МБ, 15 720 файлов, исходники на C. В разархивированном виде 842,8 МБ.
**Список директорий в архиве**
```
a52\
a52dec\
aacdec\
aacPlus\
adpcm\
Agave\
alac\
albumart\
amrdec\
apev2\
auth\
bmp\
burner\
burnlib\
codesign\
coloreditor\
config\
conformance\
dataview\
dca\
devices\
dlmgr\
Elevator\
enc_aacplus\
enc_fhgaac\
enc_flac\
enc_flac2\
enc_lame\
enc_vorbis\
enc_wav\
enc_wma\
expat\
f263\
filereader\
flac\
freetype\
freetypewac\
gen_crasher\
gen_dropbox\
gen_ff\
gen_hotkeys\
gen_ml\
gen_mud\
gen_talkback\
gen_tray\
gen_webauth\
gif\
giflib\
gracenote\
h264\
h264dec\
id3v2\
ie_plugin\
ijg\
in_avi\
in_cdda\
in_dshow\
in_flac\
in_flv\
in_linein\
in_midi\
in_mkv\
in_mod\
in_mp3\
in_mp4\
in_nsv\
in_ogg\
in_swf\
in_vorbis\
in_wave\
in_wmvdrm\
in_wv\
installer\
jnetlib\
jpeg\
libdca\
libmp4v2\
libogg\
libpng\
libsndfile\
libtheora\
libvorbis\
libvp5\
libvp6\
libvpx\
libyajl\
logger\
Mastering\
ml_addons\
ml_autotag\
ml_bookmarks\
ml_cloud\
ml_devices\
ml_disc\
ml_downloads\
ml_history\
ml_impex\
ml_local\
ml_nowplaying\
ml_online\
ml_orb\
ml_playlists\
ml_plg\
ml_pmp\
ml_rg\
ml_shoutcast\
ml_transcode\
ml_webdev\
ml_wire\
mp3\
mp4v\
mpeg2dec\
mpeg4dec\
mpegvideo\
nde\
np_plugin\
nprt_plugin\
ns-eel\
ns-eel2\
nsavi\
nscue\
nsid3v2\
nsis_bind\
nsmkv\
nsmpeg\
nsutil\
nsv\
nsvdec_vp3\
nsvdec_vp5\
nsvdec_vp6\
nswasabi\
nu\
ObjectCode\
omBrowser\
openssl\
out_disk\
out_ds\
out_wave\
pcm\
pfc\
playlist\
plist\
pmp_activesync\
pmp_android\
pmp_cloud\
pmp_cloud_demo\
pmp_ipod\
pmp_ipod2\
pmp_njb\
pmp_p4s\
pmp_template\
pmp_usb\
pmp_usb2\
pmp_wifi\
png\
primo\
ReplayGainAnalysis\
replicant\
resources\
SDKs\
tagz\
tataki\
theora\
timer\
vis_avs\
vis_milk2\
vis_nsfs\
vlb\
vorbis\
vp5\
vp6\
vp8x\
vp32\
Wasabi\
Wasabi2\
watcher\
wbm\
Winamp\
winampa\
winampAll\
xml\
xspf\
zlib\
```
Размеры `winamp-main.zip` 242 и 708,3 МБ, соответственно, 15 682 файла.
Исходный код легендарной программы имеет ценность скорее как исторический артефакт. Возможно, он пригодится разработчикам форков и тем, кто желает портировать Winamp на другие платформы.
Реальной практической пользы мало. Во-первых, есть отличные легковесные и мультиплатформенные альтернативы, такие как [qmmp](https://qmmp.ylsoftware.com/), которые даже поддерживают скины Winamp.
Во-вторых, с юридической точки зрения нельзя ни обновлять, ни распространять этот код и программное обеспечение, скомпилированное из него. Ситуация напоминает утечку кода [Opera Presto](https://habr.com/ru/news/t/357672/) несколько лет назад. Для неё вышло несколько патчей на российских форумах, но на этом поддержка и развитие проекта были закончены. Доступ к самому репозиторию был оперативно закрыт согласно процедуре американского закона об авторском праве в цифровую эпоху (DMCA).
Winamp — проприетарный медиаплеер с поддержкой большого количества форматов файлов, скинов, эквалайзеров и потрясающих графических визуализаций, которые особенно удивительно смотрелись в 90-е годы.
Разработчики программы — Джастин Франкель и Дмитрий Болдырев. Первая версия вышла в 1997 году и распространялась по модели shareware. Несмотря на то, что утилитой можно было пользоваться бесплатно, авторов завалили письмами с десятидолларовыми купюрами (в те времена это был самый популярный способ передачи денег между физическими лицами). Через два года компанию Nullsoft купила AOL LLC. В 2004 году последние сотрудники, стоявшие у истоков Winamp, покинули AOL. 20 ноября 2013 года компания AOL объявила, что отказывается от дальнейшей разработки проекта.
В 2014 году права на программу выкупила бельгийская компания Radionomy Group. С тех пор для Winamp не выходило никаких обновлений, если не считать [утечку бинарника Winamp 5.8 для Windows](https://www.bleepingcomputer.com/news/software/winamp-58-media-player-released-in-all-its-nostalgic-glory/).
*Winamp 5.8*
Однако в ноябре 2021 года [стало известно](https://vosveteit.sk/legendarny-winamp-vola-pouzivatelov-aby-sa-stali-beta-testermi-novej-verzie-aplikacie/) о перезапуске проекта в качестве единой мобильной платформы для разных сервисов, подписок, подкастов и стриминговых сервисов. Официальный сайт получил редизайн, был изменён логотип Winamp, появилась возможность [записаться на бета-тестирование](https://audiovalley.typeform.com/betatester?typeform-source=ru.wikipedia.org).
Интересно, что в 2003 году на основе Winamp был разработан плеер Wasabi (также известен как Winamp3). Исходный код [опубликовали](https://hydrogenaud.io/index.php?topic=16613.0) в открытом доступе, но тогда он не вызвал особого интереса публики, потому что время Winamp уже ушло, а историческое значение программы публика ещё не осознала.
По общему мнению, распространение формата mp3 в 1997 году произвело настоящую культурную революцию в мире. | https://habr.com/ru/post/592471/ | null | ru | null |
# Создание web приложения на PHP с иcпользованием Firebird и Laravel
 Привет Хабр!
В прошлой [статье](https://habrahabr.ru/post/312874/) я рассказывал о пакете для поддержки СУБД Firebird в фреймворке Laravel. На этот раз мы рассмотрим процесс создания web приложения с использованием СУБД Firebird на языке PHP с использованием Laravel.
Обзор драйверов для работы с Firebird
-------------------------------------
В PHP есть два драйвера для работы с СУБД Firebird:
* Расширение [Firebird/Interbase](http://php.net/ibase) (ibase\_ функции);
* [PDO драйвер](http://php.net/manual/ru/ref.pdo-firebird.php) для Firebird.
### Обзор расширения Firebird/Interbase
Расширение Firebird/Interbase появилось раньше и является наиболее проверенным. Для установки расширения Firebird/Interbase в конфигурационном файле php.ini необходимо раскомментировать строку
```
extension=php_interbase.dll
```
или для UNIX подобных систем строку
```
extension=php_interbase.so
```
Это расширение требует, чтобы у вас была установлена клиентская библиотека fbclient.dll/gds32.dll (для UNIX подобных систем fbclient.so) соответствующей разрядности.
| |
| --- |
| **Замечание для пользователей Win32/Win64**
Для работы этого расширения системной переменной Windows PATH должны быть доступны DLL-файлы fbclient.dll или gds32.dll. Хотя копирование DLL-файлов из директории PHP в системную папку Windows также решает проблему (потому что системная директория по умолчанию находится в переменной PATH), это не рекомендуется. Этому расширению требуются следующие файлы в переменной PATH: fbclient.dll или gds32.dll. |
В Linux это расширение в зависимости от дистрибутива можно установить одной из следующих команд (необходимо уточнить поддерживаемые версии, возможно, необходимо подключить сторонний репозиторий):
```
apt-get install php5-firebird
rpm –ihv php5-firebird
yum install php70w-interbase
zypper install php5-firebird
```
Это расширение использует процедурный подход к написанию программ. Функции с префиксом ibase\_ могут возвращать или принимать в качестве одного из параметров идентификатор соединения, транзакции, подготовленного запроса или курсора (результат SELECT запроса). Этот идентификатор имеет тип resource. Все выделенные ресурсы необходимо освобождать, как только они больше не требуются. Я не буду описывать каждую из функций подробно, вы можете посмотреть их описание по ссылке, вместо этого приведу несколько небольших примеров с комментариями.
```
$db = 'localhost:example';
$username = 'SYSDBA';
$password = 'masterkey';
// Подключение к БД
$dbh = ibase_connect($db, $username, $password);
$sql = 'SELECT login, email FROM users';
// Выполняем запрос
$rc = ibase_query($dbh, $sql);
// Получаем результат построчно в виде объекта
while ($row = ibase_fetch_object($rc)) {
echo $row->email, "\n";
}
// Освобождаем хэндл связанный с результатом запроса
ibase_free_result($rc);
// Освобождаем хэндл связанный с подключением
ibase_close($dbh);
```
Вместо функции ibase\_connect вы можете применять функцию ibase\_pconnect, которая создаёт так называемые постоянные соединения. В этом случае при вызове ibase\_close соединение не закрывается, все связанные с ней ресурсы освобождаются, транзакция по умолчанию подтверждается, другие виды транзакций откатываются. Такое соединение может быть использовано повторно в другой сессии, если параметры подключения совпадают. В некоторых случаях постоянные соединения могут значительно повысить эффективность вашего веб приложения. Это особенно заметно, если затраты на установку соединения велики. Они позволяют дочернему процессу на протяжении всего жизненного цикла использовать одно и то же соединение вместо того, чтобы создавать его при обработке каждой страницы, которая взаимодействует с SQL-сервером. Этим постоянные соединения напоминают работу с пулом соединений. Подробнее о постоянных соединениях вы может прочитать по [ссылке](http://php.net/persistent-connections).
| |
| --- |
| **Внимание!**
Многие ibase функции позволяют не передавать в них идентификатор соединения (транзакции, подготовленного запроса). В этом случае эти функции используют идентификатор последнего установленного соединения (начатой транзакции). Я не рекомендую так делать, в особенности, если ваше веб приложение может использовать более одного подключения. |
Функция ibase\_query выполняет SQL запрос и возвращает идентификатор результата или true, если запрос не возвращает набор данных. Эта функция помимо идентификатора подключения (транзакции) и текста SQL запроса может принимать переменное число аргументов в качестве значений параметров SQL запроса. В этом случае наш пример выглядит следующим образом:
```
$sql = 'SELECT login, email FROM users WHERE id=?';
$id = 1;
// Выполняем запрос
$rc = ibase_query($dbh, $sql, $id);
// Получаем результат построчно в виде объекта
if ($row = ibase_fetch_object($rc)) {
echo $row->email, "\n";
}
// Освобождаем хэндл связанный с результатом запроса
ibase_free_result($rc);
```
Очень часто параметризованные запросы используются многократно с различным набором значений параметров, в этом случае для повышения производительности рекомендуется использовать подготовленные запросы. В этом случае сначала необходимо сначала получить идентификатор подготовленного запроса с помощью функции ibase\_prepare, а затем выполнять подготовленный запрос с помощью функции ibase\_execute.
```
$sql = 'SELECT login, email FROM users WHERE id=?';
// Подготавливаем запрос
$sth = ibase_prepare($dbh, $sql);
$id = 1;
// Выполняем запрос
$rc = ibase_execute($sth, $id);
// Получаем результат построчно в виде объекта
if ($row = ibase_fetch_object($rc)) {
echo $row->email, "\n";
}
// Освобождаем хэндл связанный с результатом запроса
ibase_free_result($rc);
// Освобождаем подготовленный запрос
ibase_free_query($sth);
```
Подготовленные запросы гораздо чаще используются, когда необходима массовая заливка данных.
```
$sql = 'INSERT INTO users(login, email) VALUES(?, ?)';
// Подготавливаем запрос
$sth = ibase_prepare($dbh, $sql);
$users = [["user1", "user1@gmail.com"], ["user2", "user2@gmail.com"]];
// Выполняем запрос
foreach ($users as $user)) {
ibase_execute($sth, $user[0], $user[1]);
}
// Освобождаем подготовленный запрос
ibase_free_query($sth);
```
По последнему примеру можно увидеть один из недостатков этого расширения, а именно, функции с переменным числом аргументов не очень удобны для параметризованных запросов. Этот недостаток проявляется особенно ярко, если вы пытаетесь написать универсальный класс для исполнения любых запросов. Гораздо удобнее было бы, если параметры можно было передавать одним массивом. Конечно, существуют обходные пути вроде вот такого:
```
function fb_execute ($stmt, $data)
{
if (!is_array($data))
return ibase_execute($stmt, $data);
array_unshift($data, $stmt);
$rc = call_user_func_array('ibase_execute', $data);
return $rc;
}
```
Расширение Firebird/Interbase не работает с именованными параметрами запроса.
По умолчанию расширение Firebird/Interbase автоматически стартует транзакцию по умолчанию после подключения. Транзакцию по умолчанию подтверждается при закрытии соединения функцией ibase\_close. Её можно подтвердить или откатить раньше, если вызвать методы ibase\_commit или ibase\_rollback передав в них идентификатор соединения, или не передавая ни чего (если вы используете единственное соединение.)
Если вам необходимо явное управление транзакциями, то необходимо стартовать транзакцию с помощью функции [ibase\_trans](http://php.net/manual/ru/function.ibase-trans.php). Если параметры транзакции не указаны, то транзакция будет начата с параметрами IBASE\_WRITE | IBASE\_CONCURRENCY | IBASE\_WAIT. Описание констант для задания параметров транзакции можно найти по ссылке [php.net/manual/ru/ibase.constants.php](http://php.net/manual/ru/ibase.constants.php). Транзакцию необходимо завершать с помощью метода ibase\_commit или ibase\_rollback передавая в эти функции идентификатор транзакции. Если вместо этих функций использовать функции ibase\_commit\_ret или ibase\_rollback\_ret, то транзакция будет завершаться как COMMIT RETAIN или ROLLBACK RETAIN.
| |
| --- |
| **Замечание.**
Умолчательные параметры транзакции подходят для большинства случаев. Дело в том что соединение с базой данных, как и все связанные с ним ресурсы существуют максимум до конца работы PHP скрипта. Даже если вы используете постоянные соединения, то все связанные ресурсы будут освобождены после вызова функции ibase\_close. Несмотря на сказанное, настоятельно рекомендую завершать все выделенные ресурсы явно, вызывая соответствующие ibase\_ функции.
Пользоваться функциями ibase\_commit\_ret и ibase\_rollback\_ret настоятельно не рекомендую, так как это не имеет смысла. COMMIT RETAIN и ROLLBACK RETAIN были введены для того, чтобы в настольных приложениях сохранять открытыми курсоры при завершении транзакции. |
```
$sql = 'INSERT INTO users(login, email) VALUES(?, ?)';
// Подготавливаем запрос
$sth = ibase_prepare($dbh, $sql);
$users = [["user1", "user1@gmail.com"], ["user2", "user2@gmail.com"]];
$trh = ibase_trans($dbh, IBASE_WRITE | IBASE_CONCURRENCY | IBASE_WAIT);
try {
// Выполняем запрос
foreach ($users as $user)) {
$r = ibase_execute($sth, $user[0], $user[1]);
if ($r === false) {
// Если произошла ошибка, бросаем исключение
$err_msg = ibase_errmsg();
throw new \Exception($err_msg);
}
}
ibase_commit($trh);
}
catch(\Exception $e) {
ibase_rollback($trh);
echo $e->getMessage();
}
// Освобождаем подготовленный запрос
ibase_free_query($sth);
```
| |
| --- |
| **Внимание!**
ibase функции не бросают исключение в случае возникновения ошибки. Часть функций возвращают false, если произошла ошибка. Обращаю ваше внимание, что результат сравнивать с false необходимо строгим оператором сравнения ===. Потенциально ошибка может возникнуть поле вызова любой ibase функции. Текст ошибки можно узнать с помощью функции ibase\_errmsg. Код ошибки можно получить с помощью функции ibase\_errcode. |
Расширение Firebird/Interbase позволяет взаимодействовать с сервером Firebird не только посредством SQL запросов, но и используя Service API (см. функции ibase\_service\_attach, ibase\_service\_detach, ibase\_server\_info, ibase\_maintain\_db, ibase\_db\_info, ibase\_backup, ibase\_restore). Эти функции позволяют получить информацию о сервере Firebird, сделать резервное копирование, восстановление или получить статистику. Эта функциональность требуется в основном для администрирования БД, поэтому мы не будем рассматривать её подробно.
Расширение Firebird/Interbase так же поддерживает работу с событиями Firebird (см. функции ibase\_set\_event\_handler, ibase\_free\_event\_handler, ibase\_wait\_event).
### Обзор расширения PDO (драйвер Firebird)
Расширение PDO предоставляет обобщённый интерфейс для доступа к различным типам БД. Каждый драйвер базы данных, в котором реализован этот интерфейс, может представить специфичный для базы данных функционал в виде стандартных функций расширения.
PDO и все основные драйверы внедрены в PHP как загружаемые модули. Чтобы их использовать, требуется их просто включить, отредактировав файл php.ini следующим образом:
```
extension=php_pdo.dll
```
| |
| --- |
| **Замечание**
Этот шаг необязателен для версий PHP 5.3 и выше, так как для работы PDO больше не требуются DLL. |
Далее нужно выбрать DLL конкретных баз данных и либо загружать их во время выполнения функцией dl(), либо включить их в php.ini после php\_pdo.dll. Например:
```
extension=php_pdo.dll
extension=php_pdo_firebird.dll
```
Эти DLL должны лежать в директории extension\_dir. Драйвер pdo\_firebird требует, чтобы у вас была установлена клиентская библиотека fbclient.dll/gds32.dll (для UNIX подобных систем fbclient.so) соответствующей разрядности.
В Linux это расширение в зависимости от дистрибутива можно установить одной из следующих команд (необходимо уточнить поддерживаемые версии, возможно, необходимо подключить сторонний репозиторий):
```
apt-get install php5-firebird
rpm –ihv php5-firebird
yum install php70w-firebird
zypper install php5-firebird
```
PDO использует объектно-ориентированный подход к написанию программ. Какой именно драйвер будет использоваться в PDO, зависит от строки подключения, называемой так же DSN (Data Source Name). DSN состоит из префикса, который и определяет тип базы данных, и набора параметров в виде <ключ>=<значение>, разделённых точкой с запятой «;». Допустимый набор параметров зависит от типа базы данных. Для работы с Firebird строка подключения должна начинаться с префикса firebird: и иметь вид, описанный в документации в разделе [PDO\_FIREBIRD DSN](http://php.net/manual/ru/ref.pdo-firebird.connection.php).
Соединения устанавливаются автоматически при создании объекта PDO от его базового класса. Конструктор класса принимает аргументы для задания источника данных (DSN), а также необязательные имя пользователя и пароль (если есть). Четвёртым аргументом можно передать массив специфичных для драйвера настроек подключения в формате ключ=>значение.
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
$sql = 'SELECT login, email FROM users';
// Выполняем запрос
$query = $dbh->query($sql);
// Получаем результат построчно в виде объекта
while ($row = $query->fetch(\PDO::FETCH_OBJ)) {
echo $row->email, "\n";
}
$query->closeCursor(); // Закрываем курсор
} catch (\PDOException $e) {
echo $e->getMessage();
}
```
Установив свойство \PDO::ATTR\_ERRMODE в значение \PDO::ERRMODE\_EXCEPTION, мы установили режим, при котором любая ошибка, в том числе и ошибка при подключении к БД, будет возбуждать исключение \PDOException. Работать в таком режиме гораздо удобнее, чем проверять наличие ошибки после каждого вызова ibase\_ функций.
| |
| --- |
| Для того чтобы PDO использовал [постоянные соединения](http://php.net/persistent-connections) необходимо в конструктор PDO в массиве свойств передать PDO::ATTR\_PERSISTENT => true. |
Метод query выполняет SQL запрос и возвращает результирующий набор в виде объекта \PDOStatement. В этот метод помимо SQL запросы вы можете передать способ возвращения значений при фетче. Это может быть столбец, экземпляр заданного класса, объект. Различные способы вызова вы можете посмотреть по ссылке <http://php.net/manual/ru/pdo.query.php>.
Если необходимо выполнить SQL запрос, не возвращающий набор данных, то вы можете воспользоваться методом [exec](http://php.net/manual/ru/pdo.exec.php), который возвращает количество задействованных строк. Этот метод не обеспечивает выполнение подготовленных запросов.
Если в запросе используются параметры, то необходимо пользоваться подготовленными запросами. В этом случае вместо метода query необходимо вызвать метод [prepare](http://php.net/manual/ru/pdo.prepare.php). Этот метод возвращает объект класса \PDOStatement, который инкапсулирует в себе методы для работы с подготовленными запросами и их результатами. Для выполнения запроса необходимо вызвать метод [execute](http://php.net/manual/ru/pdostatement.execute.php), который может принимать в качестве аргумента массив с именованными или неименованными параметрами. Результат выполнения селективного запроса можно получить с помощью методов [fetch](http://php.net/manual/ru/pdostatement.fetch.php), [fetchAll](http://php.net/manual/ru/pdostatement.fetchall.php), [fetchColumn](http://php.net/manual/ru/pdostatement.fetchcolumn.php), [fetchObject](http://php.net/manual/ru/pdostatement.fetchobject.php). Методы fetch и fetchAll могут возвращать результаты в различном виде: ассоциативный массив, объект или экземпляр определённого класса. Последнее довольно часто используется в MVC паттерне при работе с моделями.
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
$sql = 'INSERT INTO users(login, email) VALUES(?, ?)';
$users = [
["user1", "user1@gmail.com"],
["user2", "user2@gmail.com"]
];
// Подготавливаем запрос
$query = $dbh->prepare($sql);
// Выполняем запрос
foreach ($users as $user)) {
$query->execute($user);
}
} catch (\PDOException $e) {
echo $e->getMessage();
}
```
Пример использования именованных параметров.
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
$sql = 'INSERT INTO users(login, email) VALUES(:login, :email)';
$users = [
[":login" => "user1", ":email" => "user1@gmail.com"],
[":login" => "user2", ":email" => "user2@gmail.com"]
];
// Подготавливаем запрос
$query = $dbh->prepare($sql);
// Выполняем запрос
foreach ($users as $user)) {
$query->execute($user);
}
} catch (\PDOException $e) {
echo $e->getMessage();
}
```
| |
| --- |
| **Замечание**
Для поддержки именованных параметров PDO производит предобработку запроса и заменяет параметры вида :paramname на «?», сохраняя при этом массив соответствия между именем параметра и номерами его позиций в запросе. По этой причине оператор EXECUTE BLOCK не будет работать, если внутри него используются переменные маркированные двоеточием. На данный момент нет никакой возможности заставить работать PDO с оператором EXECUTE BLOCK иначе, например, задать альтернативный префикс параметров, как это сделано в некоторых компонентах доступа. |
Передать параметры в запрос можно и другим способом, используя так называемое связывание. Метод [bindValue](http://php.net/manual/ru/pdostatement.bindvalue.php) привязывает значение к именованному или неименованному параметру. Метод [bindParam](http://php.net/manual/ru/pdostatement.bindparam.php) привязывает переменную к именованному или неименованному параметру. Последний метод особенно полезен для хранимых процедур, которые возвращают значение через OUT или IN OUT параметр (в Firebird механизм возврата значений из хранимых процедур другой).
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
$sql = 'INSERT INTO users(login, email) VALUES(:login, :email)';
$users = [
["user1", "user1@gmail.com"],
["user2", "user2@gmail.com"]
];
// Подготавливаем запрос
$query = $dbh->prepare($sql);
// Выполняем запрос
foreach ($users as $user)) {
$query->bindValue(":login", $user[0]);
$query->bindValue(":email", $user[1]);
$query->execute();
}
} catch (\PDOException $e) {
echo $e->getMessage();
}
```
| |
| --- |
| **Внимание**
Нумерация неименованных параметров в методах bindParam и bindValue начинается с 1. |
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
$sql = 'INSERT INTO users(login, email) VALUES(?, ?)';
$users = [
["user1", "user1@gmail.com"],
["user2", "user2@gmail.com"]
];
// Подготавливаем запрос
$query = $dbh->prepare($sql);
// Выполняем запрос
foreach ($users as $user)) {
$query->bindValue(1, $user[0]);
$query->bindValue(2, $user[1]);
$query->execute();
}
} catch (\PDOException $e) {
echo $e->getMessage();
}
```
По умолчанию PDO автоматически подтверждает транзакцию после выполнения каждого SQL запроса, если вам необходимо явное управление транзакциями, то необходимо стартовать транзакцию с помощью метода [\PDO::beginTransaction](http://php.net/manual/ru/pdo.begintransaction.php). По умолчанию транзакция стартует с параметрами CONCURRENCY | WAIT | READ\_WRITE. Завершить транзакцию можно методом [\PDO::commit](http://php.net/manual/ru/pdo.commit.php) или [\PDO::rollback](http://php.net/manual/ru/pdo.commit.php).
```
$dsn = 'firebird:dbname=localhost:example;charset=utf8;';
$username = 'SYSDBA';
$password = 'masterkey';
try {
// Подключение к БД
$dbh = new \PDO($dsn, $username, $password, [\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION]);
// Стартуем транзакцию для обеспечения согласованности между запросами
$dbh->beginTransaction();
// Получаем пользователей из одной таблицы
$users_stmt = $dbh->prepare('SELECT login, email FROM old_users');
$users_stmt->execute();
$users = $users_stmt->fetchAll(\PDO::FETCH_OBJECT);
$users_stmt->closeCursor();
// И переносим их в другую
$sql = 'INSERT INTO users(login, email) VALUES(?, ?)';
// Подготавливаем запрос
$query = $dbh->prepare($sql);
// Выполняем запрос
foreach ($users as $user)) {
$query->bindValue(1, $user->LOGIN);
$query->bindValue(2, $user->EMAIL]);
$query->execute();
}
// Подтверждаем транзакцию
$dbh->commit();
} catch (\PDOException $e) {
// Если соединение произошло и транзакция стартовала, откатываем её
if ($dbh && $dbh->inTransaction())
$dbh->rollback();
echo $e->getMessage();
}
```
К сожалению метод beginTransaction не предоставляет возможности изменить параметры транзакции, однако вы можете сделать хитрый трюк, задав параметры транзакции оператором SET TRANSACTION.
```
$dbh = new \PDO($dsn, $username, $password);
$dbh->setAttribute(\PDO::ATTR_AUTOCOMMIT, false);
$dbh->exec("SET TRANSACTION READ ONLY ISOLATION LEVEL READ COMMITTED NO WAIT");
// Выполняем действия в транзакции
// ….
$dbh->exec("COMMIT");
$dbh->setAttribute(\PDO::ATTR_AUTOCOMMIT, true);
```
Ниже представлена сводная таблица возможностей различных драйверов для работы с Firebird.
| Возможность | Расширение Firebird/Interbase | PDO |
| --- | --- | --- |
| Парадигма программирования | Функциональная | Объектно-ориентированная |
| Поддерживаемые БД | Firebird, Interbase, Yaffil и другие клоны Interbase. | Любая БД, для которой существует PDO драйвер, в том числе Firebird. |
| Работа с параметрами запросов | Только неименованные параметры, работать не очень удобно, поскольку используется функция с переменным числом аргументов. | Есть возможность работать как с именованными, так и неименованными параметрами. Работать очень удобно, однако некоторые возможности Firebird (оператор EXECUTE BLOCK) не работают. |
| Обработка ошибок | Проверка результата функций ibase\_errmsg, ibase\_errcode. Ошибка может произойти после вызова любой ibase функции при этом исключение не будет возбуждено. | Есть возможность установить режим, при котором любая ошибка приведёт к возбуждению исключения. |
| Управление транзакциями | Даёт возможность задать параметры транзакции. | Не даёт возможность задать параметры транзакции. Есть обходной путь через выполнение оператора SET TRANSACTION. |
| Специфичные возможности Interbase/Firebird | Есть возможность работать с расширениями Service API (backup, restore, получение статистики и т.д.), а также с событиями базы данных. | Не позволяет использовать специфичные возможности, с которыми невозможно работать, используя SQL. |
Из приведённой таблицы видно, что большинству фреймворков гораздо удобнее пользоваться PDO.
Выбор фреймворка для построения WEB приложения
----------------------------------------------
Небольшие web сайты можно писать, не используя паттерн MVC. Однако чем больше становится ваш сайт, тем сложнее его поддерживать, особенно если над ним работает не один человек. Поэтому при разработке нашего web приложения сразу договоримся об использовании этого паттерна.
Итак, мы решили использовать паттерн MVC. Однако написание приложение с использованием этого паттерна не такая простая задача как кажется, особенно если мы не пользуемся сторонними библиотеками. Если всё писать самому, то необходимо решить множество задач: автозагрузка файлов .php, включающих определение классов, маршрутизация и др. Для решения этих задач было создано большое количество фреймворков, например Yii, Laravel, Symphony, Kohana и многие другие. Лично мне нравится Laravel, поэтому далее я буду описывать создание приложения с использованием этого фреймворка.
Установка Laravel и создание проекта
------------------------------------
Прежде чем устанавливать Laravel вам необходимо убедится, что ваше системное окружение соответствует требованиям.
* PHP >= 5.5.9
* PDO расширение для PHP (для версии 5.1+)
* MCrypt расширение для PHP (для версии 5.0)
* OpenSSL (расширение для PHP)
* Mbstring (расширение для PHP)
* Tokenizer (расширение для PHP)
Laravel использует [Composer](https://getcomposer.org/) для управления зависимостями. Поэтому сначала установите Composer, а затем Laravel.
Самый простой способ установить composer под windows – это скачать и запустить инсталлятор [Composer-Setup.exe](https://getcomposer.org/Composer-Setup.exe). Инсталлятор установит Composer и настроит PATH, так что вы можете вызвать Composer из любой директории в командной строке.
Если необходимо установить Composer вручную, то необходимо запустить
**Скрипт уcтановки Composer**
```
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('SHA384', 'composer-setup.php') === 'aa96f26c2b67226a324c27919f1eb05f21c248b987e6195cad9690d5c1ff713d53020a02ac8c217dbf90a7eacc9d141d') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"
```
Этот скрипт осуществляет следующие действия:
* Скачивает инсталлятор в текущую директорию
* Проверяет инсталлятор с помощью SHA-384
* Запускает скрипт инсталляции
* Удаляет скрипт инсталляции
После запуска этого скрипта у вас появится файл composer.phar (phar – это архив) — по сути это PHP скрипт, который может принимать несколько команд (install, update, ...) и умеет скачивать и распаковывать библиотеки. Если вы работаете под windows, то вы можете облегчить себе задачу, создав файл composer.bat и поместив его в PATH. Для этого необходимо выполнить команду
`echo @php "%~dp0composer.phar" %*>composer.bat`
Подробнее об установке composer смотри [здесь](https://getcomposer.org/doc/00-intro.md).
Теперь устанавливаем сам Laravel:
```
composer global require "laravel/installer"
```
Если установка прошла успешно, то приступаем к созданию каркаса проекта.
```
laravel new fbexample
```
Ждём завершения, после чего у нас будет создан каркас проекта. Описание структуры каталогов можно найти в [документации](http://laravel.su/docs/5.2/structure) по Laravel. Нас будут интересовать следующие каталоги:
* app – основной каталог нашего приложения. В корне каталога будут размещены модели. В подкаталоге Http находится все, что касается работы с браузером. В подкаталоге Http/Controllers – наши контроллеры.
* config – каталог файлов конфигурации. Подробней о конфигурировании будет написано ниже.
* public – корневой каталог web приложения (DocumentRoot). Содержит статические файлы — css, js, изображения и т.п.
* resources — здесь находятся шаблоны (Views), файлы локализации и, если таковые имеются, рабочие файлы LESS, SASS и js-приложения на фреймворках типа ReactJS, AngularJS или Ember, которые потом собираются внешним инструментом в папку public.
В корне папки нашего приложения есть файл composer.json, который описывает, какие пакеты, потребуются нашему приложению помимо тех, что уже есть в Laravel. Нам потребуется два таких пакета: «[zofe/rapyd-laravel](https://github.com/zofe/rapyd-laravel)» — для быстрого построения интерфейса с сетками (grids) и диалогами редактирования, и «[sim1984/laravel-firebird](https://github.com/sim1984/laravel-firebird)» — расширение для работы с СУБД Firebird. Пакет «sim1984/laravel-firebird» является форком пакета «jacquestvanzuydam/laravel-firebird» поэтому его установка несколько отличается (описание отличий пакета от оригинального вы можете найти в статье «[Пакет для работы с СУБД Firebird в Laravel](https://habrahabr.ru/post/312874/)»). Не забудьте установить параметр minimum-stability равный dev, так как пакет не является стабильным, а так же добавить ссылки на репозиторий.
```
…
"repositories": [
{
"type": "package",
"package": {
"version": "dev-master",
"name": "sim1984/laravel-firebird",
"source": {
"url": "https://github.com/sim1984/laravel-firebird",
"type": "git",
"reference": "master"
},
"autoload": {
"classmap": [""]
}
}
}
],
…
```
В секции require добавьте требуемые пакеты следующим образом:
```
"zofe/rapyd": "2.2.*",
"sim1984/laravel-firebird": "dev-master"
```
Теперь можно запустить обновление пакетов командой (запускать надо в корне веб приложения)
```
composer update
```
После выполнения этой команды новые пакеты будут установлены в ваше приложение. Теперь можно приступить к настройке. Для начала выполним команду
```
php artisan vendor:publish
```
которая создаст дополнительные файлы конфигурации для пакета zofe/rapyd.
В файле config/app.php добавим два новых провайдера. Для этого добавим две новых записи в ключ providers
```
Zofe\Rapyd\RapydServiceProvider::class,
Firebird\FirebirdServiceProvider::class,
```
Теперь перейдём к файлу config/databases.conf, который содержит настройки подключения к базе данных. Добавим в ключ connections следующие строки
```
'firebird' => [
'driver' => 'firebird',
'host' => env('DB_HOST', 'localhost'),
'port' => env('DB_PORT', '3050'),
'database' => env('DB_DATABASE', 'examples'),
'username' => env('DB_USERNAME', 'SYSDBA'),
'password' => env('DB_PASSWORD', 'masterkey'),
'charset' => env('DB_CHARSET', 'UTF8'),
'engine_version' => '3.0.0',
],
```
Поскольку мы будем использовать наше подключение в качестве подключения по умолчанию, установим следующее
```
'default' => env('DB_CONNECTION', 'firebird'),
```
Обратите внимание на функцию env, которая используется для чтения переменных окружения приложения из специального файла .env, находящегося в корне проекта. Исправим в этом файле .env следующие строки
```
DB_CONNECTION=firebird
DB_HOST=localhost
DB_PORT=3050
DB_DATABASE=examples
DB_USERNAME=SYSDBA
DB_PASSWORD=masterkey
```
В файле конфигурации config/rapid.php изменим отображение дат так, чтобы они были в формате принятом в России:
```
'fields' => [
'attributes' => ['class' => 'form-control'],
'date' => [
'format' => 'd.m.Y',
],
'datetime' => [
'format' => 'd.m.Y H:i:s',
'store_as' => 'Y-m-d H:i:s',
],
],
```
Первоначальная настройка закончена, теперь мы можем приступить непосредственно к написанию логики web приложения.
Создание моделей
----------------
Фреймворк Laravel поддерживает ORM Eloquent. ORM Eloquent — красивая и простая реализация паттерна ActiveRecord для работы с базой данных. Каждая таблица имеет соответствующий класс-модель, который используется для работы с этой таблицей. Модели позволяют читать данные из таблиц и записывать данные в таблицу.
Создадим модель заказчиков, для упрощения этого процесса в Laravel есть artisan команда.
```
php artisan make:model Customer
```
Этой командой мы создаём шаблон модели. Теперь изменим нашу модель так, чтобы она выглядела следующим образом:
```
namespace App;
use Firebird\Eloquent\Model;
class Customer extends Model
{
/**
* Таблица, связанная с моделью
*
* @var string
*/
protected $table = 'CUSTOMER';
/**
* Первичный ключ модели
*
* @var string
*/
protected $primaryKey = 'CUSTOMER_ID';
/**
* Наша модель не имеет временной метки
*
* @var bool
*/
public $timestamps = false;
/**
* Имя последовательности для генерации первичного ключа
* @var string
*/
protected $sequence = 'GEN_CUSTOMER_ID';
}
```
Обратите внимание, мы используем модифицированную модель Firebird\Eloquent\Model из пакета sim1984/laravel-firebird в качестве базовой. Она позволяет воспользоваться последовательностью, указанной в свойстве $sequence, для генерирования значения идентификатора первичного ключа.
По аналогии создадим модель товаров – Product.
**Модель Product**
```
namespace App;
use Firebird\Eloquent\Model;
class Product extends Model
{
/**
* Таблица, связанная с моделью
*
* @var string
*/
protected $table = 'PRODUCT';
/**
* Первичный ключ модели
*
* @var string
*/
protected $primaryKey = 'PRODUCT_ID';
/**
* Наша модель не имеет временной метки
*
* @var bool
*/
public $timestamps = false;
/**
* Имя последовательности для генерации первичного ключа
* @var string
*/
protected $sequence = 'GEN_PRODUCT_ID';
}
```
Теперь создадим модель для шапки счёт-фактуры.
**Модель Invoice**
```
namespace App;
use Firebird\Eloquent\Model;
class Invoice extends Model {
/**
* Таблица, связанная с моделью
*
* @var string
*/
protected $table = 'INVOICE';
/**
* Первичный ключ модели
*
* @var string
*/
protected $primaryKey = 'INVOICE_ID';
/**
* Наша модель не имеет временной метки
*
* @var bool
*/
public $timestamps = false;
/**
* Имя последовательности для генерации первичного ключа
*
* @var string
*/
protected $sequence = 'GEN_INVOICE_ID';
/**
* Заказчик
*
* @return \App\Customer
*/
public function customer() {
return $this->belongsTo('App\Customer', 'CUSTOMER_ID');
}
/**
* Позиции счёт фактуры
* @return \App\InvoiceLine[]
*/
public function lines() {
return $this->hasMany('App\InvoiceLine', 'INVOICE_ID');
}
/**
* Оплата
*/
public function pay() {
$connection = $this->getConnection();
$attributes = $this->attributes;
$connection->executeProcedure('SP_PAY_FOR_INOVICE', [$attributes['INVOICE_ID']]);
}
}
```
В этой модели можно заметить несколько дополнительных функций. Функция customer возвращает заказчика связанного со счёт фактурой через поле CUSTOMER\_ID. Для осуществления такой связи используется метод belongsTo, в который передаются имя класса модели и имя поле связи. Функция lines возвращают позиции счёт-фактуры, которые представлены коллекцией моделей InvoiceLine (будет описана далее). Для осуществления связи один ко многим в функции lines используется метод hasMany, в который передаётся имя класса модели и поле связи. Подробнее о задании отношений между сущностями вы можете почитать в разделе [Отношения](http://laravel.su/docs/5.0/eloquent#relationships) документации Laravel.
Функция pay осуществляет оплату счёт фактуры. Для этого вызывается хранимая процедура SP\_PAY\_FOR\_INVOICE. В неё передаётся идентификатор счёт фактуры. Значение любого поля (атрибута модели) можно получить из свойства attributes. Вызов хранимой процедуры осуществляется с помощью метода executeProcedure. Этот метод доступен только при использовании расширения sim1984/laravel-firebird.
Теперь создадим модель для позиций счёт фактуры.
**Модель InvoiceLine**
```
namespace App;
use Firebird\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
class InvoiceLine extends Model {
/**
* Таблица, связанная с моделью
*
* @var string
*/
protected $table = 'INVOICE_LINE';
/**
* Первичный ключ модели
*
* @var string
*/
protected $primaryKey = 'INVOICE_LINE_ID';
/**
* Наша модель не имеет временной метки
*
* @var bool
*/
public $timestamps = false;
/**
* Имя последовательности для генерации первичного ключа
*
* @var string
*/
protected $sequence = 'GEN_INVOICE_LINE_ID';
/**
* Массив имён вычисляемых полей
*
* @var array
*/
protected $appends = ['SUM_PRICE'];
/**
* Товар
*
* @return \App\Product
*/
public function product() {
return $this->belongsTo('App\Product', 'PRODUCT_ID');
}
/**
* Сумма по позиции
*
* @return double
*/
public function getSumPriceAttribute() {
return $this->SALE_PRICE * $this->QUANTITY;
}
/**
* Добавление объекта модели в БД
* Переопределяем этот метод, т.к. в данном случаем мы работаем с помощью ХП
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $options
* @return bool
*/
protected function performInsert(Builder $query, array $options = []) {
if ($this->fireModelEvent('creating') === false) {
return false;
}
$connection = $this->getConnection();
$attributes = $this->attributes;
$connection->executeProcedure('SP_ADD_INVOICE_LINE', [
$attributes['INVOICE_ID'],
$attributes['PRODUCT_ID'],
$attributes['QUANTITY']
]);
// We will go ahead and set the exists property to true, so that it is set when
// the created event is fired, just in case the developer tries to update it
// during the event. This will allow them to do so and run an update here.
$this->exists = true;
$this->wasRecentlyCreated = true;
$this->fireModelEvent('created', false);
return true;
}
/**
* Сохранение изменений текущего экземпляра модели в БД
* Переопределяем этот метод, т.к. в данном случаем мы работаем с помощью ХП
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $options
* @return bool
*/
protected function performUpdate(Builder $query, array $options = []) {
$dirty = $this->getDirty();
if (count($dirty) > 0) {
// If the updating event returns false, we will cancel the update operation so
// developers can hook Validation systems into their models and cancel this
// operation if the model does not pass validation. Otherwise, we update.
if ($this->fireModelEvent('updating') === false) {
return false;
}
$connection = $this->getConnection();
$attributes = $this->attributes;
$connection->executeProcedure('SP_EDIT_INVOICE_LINE', [
$attributes['INVOICE_LINE_ID'],
$attributes['QUANTITY']
]);
$this->fireModelEvent('updated', false);
}
}
/**
* Удаление текущего экземпляра модели в БД
* Переопределяем этот метод, т.к. в данном случаем мы работаем с помощью ХП
*
* @return void
*/
protected function performDeleteOnModel() {
$connection = $this->getConnection();
$attributes = $this->attributes;
$connection->executeProcedure('SP_DELETE_INVOICE_LINE',
[$attributes['INVOICE_LINE_ID']]);
}
}
```
В этой модели есть функция product, которая возвращает продукт (модель App/Product), указанный в позиции счёт фактуры. Связь осуществляется по полю PRODUCT\_ID с помощью метода belongsTo.
Вычисляемое поле SumPrice вычисляется с помощью функции getSumPriceAttribute. Для того чтобы это вычисляемое поле было доступно в модели, его имя должно быть указано в массиве имён вычисляемых полей $appends.
В этой модели мы переопределили операции insert, update и delete так, чтобы они выполнялись, используя хранимые процедуры. Эти хранимые процедуры помимо собственно операций вставки, редактирования и удаления пересчитывают сумму в шапке накладной. Этого можно было бы и не делать, но тогда пришлось бы выполнять в одной транзакции модификацию нескольких моделей. Как это сделать будет показано далее.
Теперь немного поговорим о том, как работать с моделями в Laravel для выборки, вставки, редактирования и удаления данных. Laravel оперирует данными с помощью конструктора запросов. Полное описание синтаксиса и возможностей этого конструктора вы можете найти по [ссылке](https://laravel.ru/docs/v5/queries). Например, для получения всех строк поставщиков вы можете выполнить следующий запрос
```
$customers = DB::table('CUSTOMER')->get();
```
Этот конструктор запросов является довольно мощным средством для построения и выполнения SQL запросов. Вы можете выполнять также фильтрация, сортировку и соединения таблиц, например
```
DB::table('users')
->join('contacts', function ($join) {
$join->on('users.id', '=', 'contacts.user_id')->orOn(...);
})
->get();
```
Однако гораздо удобнее работать с использованием моделей. Описание моделей Eloquent ORM и синтаксиса запроса к ним можно найти по ссылке [laravel.ru/docs/v5/eloquent](https://laravel.ru/docs/v5/eloquent). Так для получения всех элементов коллекции поставщиков необходимо выполнить следующий запрос
```
$customers = Customer::all();
```
Следующий запрос вернёт первые 20 поставщиков отсортированных по алфавиту.
```
$customers = App\Customer::select()
->orderBy('name')
->take(20)
->get();
```
Для сложных моделей связанные отношения или коллекции отношений могут быть получены через динамические атрибуты. Например, следующий запрос вернёт позиции счёт-фактуры с идентификатором 1.
```
$lines = Invoice::find(1)->lines;
```
Добавление записей осуществляется через создание экземпляра модели, инициализации его свойств и сохранение модели с помощью метода save.
```
$flight = new Flight;
$flight->name = $request->name;
$flight->save();
```
Для изменения запись её необходимо найти, изменить необходимые атрибуты и сохранить методом save.
```
$flight = App\Flight::find(1);
$flight->name = 'New Flight Name';
$flight->save();
```
Для удаления записи её необходимо найти и вызвать метод delete.
```
$flight = App\Flight::find(1);
$flight->delete();
```
Удалить запись по ключу можно и гораздо быстрее с помощью метода destroy. В этом случае можно удалить модель не получая её экземпляр.
```
App\Flight::destroy(1);
```
Существуют и другие способы удаления записей, например «мягкое» удаление. Подробно о способах удаления вы можете прочитать по [ссылке](https://laravel.ru/docs/v5/eloquent#удаление).
Теперь поговорим немного о транзакциях. Что это такое я рассказывать не буду, а лишь покажу, как их можно использовать совместно с Eloquent ORM.
```
DB::transaction(function () {
// Создаём новую позицию в счёт фактуре
$line = new App\InvoiceLine();
$line->CUSTOMER_ID = 45;
$line->PRODUCT_ID = 342;
$line->QUANTITY = 10;
$line->COST = 12.45;
$line->save();
// добавляем сумму позиции по строке к сумме накладной
$invoice = App\Invoice::find($line->CUSTOMER_ID);
$invoice->INVOICE_SUM += $line->SUM_PRICE;
$invoice->save();
});
```
Всё что находится в функции обратного вызова, которая является аргументом метода transaction, выполняется в рамках одной транзакции.
Создание контроллеров и настройка маршрутизации
-----------------------------------------------
Фреймворк Laravel имеет мощную подсистему маршрутизации. Вы можете отображать ваши маршруты, как на простые функции обратного вызова, так и на методы контроллеров. Простейшие примеры маршрутов выглядят вот так
```
Route::get('/', function () {
return 'Hello World';
});
Route::post('foo/bar', function () {
return 'Hello World';
});
```
В первом случае мы регистрируем обработчик GET запроса для корня сайта, во втором – для POST запроса с маршрутом /foo/bar.
Вы можете зарегистрировать маршрут сразу на несколько типов HTTP запросов, например
```
Route::match(['get', 'post'], 'foo/bar', function () {
return 'Hello World';
});
```
Из маршрута можно извлекать часть адреса и использовать его в качестве параметров функции-обработчика
```
Route::get('posts/{post}/comments/{comment}', function ($postId, $commentId) {
//
});
```
Параметры маршрута всегда заключаются в фигурные скобки. Подробнее о возможности настройки маршрутизации вы можете посмотреть в документации глава «[Маршрутизация](https://laravel.ru/docs/v5/routing)». Маршруты настраиваются в файле app/Http/routes.php в Laravel 5.2 и routes/wep.php в Laravel 5.3.
Вместо того чтобы описывать обработку всех запросов в едином файле маршрутизации, мы можем организовать её использую классы Controller, которые позволяют группировать связанные обработчики запросов в отдельные классы. Контроллеры хранятся в папке app/Http/Controllers.
Все Laravel контроллеры должны расширять базовый класс контроллера App\Http\Controllers\Controller, присутствующий в Laravel по умолчанию. Подробнее о написании контроллеров вы можете почитать в документации в главе [HTTP-Контроллеры](http://laravel.su/docs/5.2/controllers).
Напишем наш первый контроллер.
```
/*
* Контроллер заказчиков
*/
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Customer;
class CustomerController extends Controller
{
/**
* Отображает список заказчиков
*
* @return Response
*/
public function showCustomers()
{
// запрашиваем из модели первые 20 заказчиков
// отсортированных по алфавиту
$customers = Customer::select()
->orderBy('NAME')
->take(20)
->get();
var_dump($customers);
}
}
```
Теперь необходимо связать методы контроллера с маршрутом. Для этого в routes.php (web.php) необходимо внести строку
```
Route::get('/customers', 'CustomerController@showCustomers');
```
Здесь имя контроллера отделено от имени метода символом @.
Для быстрого построения интерфейса с сетками и диалогами редактирования будем использовать пакет «[zofe/rapyd](https://github.com/zofe/rapyd-laravel)». Мы его уже подключили ранее. Классы пакета zofe/rapyd берут на себя построение типичных запросов к моделям Eloquent ORM. Изменим контроллер заказчиков так, чтобы он выводил данные в сетку (grid), позволял производить их фильтрацию, а также добавлять, редактировать и удалять записи через диалоги редактирования.
**Контроллер Customer**
```
/*
* Контроллер заказчиков
*/
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Customer;
class CustomerController extends Controller {
/**
* Отображает список заказчиков
*
* @return Response
*/
public function showCustomers() {
// Подключаем виджет для поиска
$filter = \DataFilter::source(new Customer);
// Поиск будет по наименованию поставщика
$filter->add('NAME', 'Наименование', 'text');
// Задаём подпись кнопке поиска
$filter->submit('Поиск');
// Добавляем кнопку сброса фильтра и задаём её подпись
$filter->reset('Сброс');
// Создам сетку для отображения отфильтрованных данных
$grid = \DataGrid::source($filter);
// выводимые столбцы
// Поле, подпись, сортируемый
$grid->add('NAME', 'Наименование', true);
$grid->add('ADDRESS', 'Адрес');
$grid->add('ZIPCODE', 'Индекс');
$grid->add('PHONE', 'Телефон');
// Добавляем кнопки для просмотра, редактирования и удаления записи
$grid->edit('/customer/edit', 'Редактирование', 'show|modify|delete');
// Добавляем кнопку добавления заказчика
$grid->link('/customer/edit', "Добавление заказчика", "TR");
// задаём сортировку
$grid->orderBy('NAME', 'asc');
// задаём количество записей на страницу
$grid->paginate(10);
// отображаем шаблон customer и передаём в него фильтр и грид
return view('customer', compact('filter', 'grid'));
}
/**
* Добавление, редактирование и удаление заказчика
*
* @return Response
*/
public function editCustomer() {
if (\Input::get('do_delete') == 1)
return "not the first";
// создаём редактор
$edit = \DataEdit::source(new Customer());
// задаём подпись диалога в зависимости от типа операции
switch ($edit->status) {
case 'create':
$edit->label('Добавление заказчика');
break;
case 'modify':
$edit->label('Редактирование заказчика');
break;
case 'do_delete':
$edit->label('Удаление заказчика');
break;
case 'show':
$edit->label('Карточка заказчика');
// добавляем ссылку для возврата назад на список заказчиков
$edit->link('customers', 'Назад', 'TR');
break;
}
// задаём что после операций добавления, редактирования и удаления
// возвращаемся к списку заказчиков
$edit->back('insert|update|do_delete', 'customers');
// Добавляем редакторы определённого типа, задаём им подпись
// и связываем их с атрибутами модели
$edit->add('NAME', 'Наименование', 'text')->rule('required|max:60');
$edit->add('ADDRESS', 'Адрес', 'textarea')
->attributes(['rows' => 3])
->rule('max:250');
$edit->add('ZIPCODE', 'Индекс', 'text')->rule('max:10');
$edit->add('PHONE', 'Телефон', 'text')->rule('max:14');
// отображаем шаблон customer_edit и передаём в него редактор
return $edit->view('customer_edit', compact('edit'));
}
}
```
Laravel по умолчанию использует шаблонизатор blade. Функция view находит необходимый шаблон в директории resources/views, делает необходимые замены в нём и возвращает текст HTML страницы. Кроме того, она передаёт в него переменные, которые становятся доступными в шаблоне. Описание синтаксиса шаблонов blade вы можете найти в документации в разделе [Шаблонизатор Blade](http://laravel.su/docs/5.3/blade).
Шаблон для отображения заказчиков выглядит следующим образом:
```
@extends('example')
@section('title','Заказчики')
@section('body')
Заказчики
=========
{!! $filter !!}
{!! $grid !!}
@stop
```
Данный шаблон унаследован от шаблона example и переопределяет его секцию body. Переменные $filter и $grid содержат HTML код для осуществления фильтрации и отображения данных в сетке. Шаблон example является общим для всех страниц.
**Шаблон example.blade**
```
@extends('master')
@section('title', 'Пример работы с Firebird')
@section('body')
Пример
======
@if(Session::has('message'))
{!! Session::get('message') !!}
@endif
Пример работы с Firebird.
@stop
@section('content')
@include('menu')
@yield('body')
@stop
```
Этот шаблон сам унаследован от шаблона master, кроме того он подключает шаблон menu. Меню довольно простое, состоит из трёх пунктов Заказчики, Продукты и Счёт фактуры.
```
* {!! link\_to("customers", "Заказчики") !!}
* {!! link\_to("products", "Товары") !!}
* {!! link\_to("invoices", "Счёт фактуры") !!}
```
В шаблоне master подключаются css стили и JavaScript файлы с библиотеками.
**Шаблон master.blade**
```
@yield('title', 'Пример Web приложения на Firebird')
@section('meta', '')
{!! Rapyd::styles(true) !!}
@yield('content')
{!! Rapyd::scripts() !!}
```
Шаблон редактора заказчика customer\_edit выглядит следующим образом
```
@extends('example')
@section('title', 'Редактирование заказчика')
@section('body')
{!! $edit !!}
@stop
```
Контроллер товаров сделан аналогично контроллеру поставщиков.
**Контроллер Product**
```
/*
* Контроллер товаров
*/
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Product;
class ProductController extends Controller {
/**
* Отображает список продуктов
*
* @return Response
*/
public function showProducts() {
// Подключаем виджет для поиска
$filter = \DataFilter::source(new Product);
// Поиск будет по наименованию продукта
$filter->add('NAME', 'Наименование', 'text');
$filter->submit('Поиск');
$filter->reset('Сброс');
// Создам сетку для отображения отфильтрованных данных
$grid = \DataGrid::source($filter);
// выводимые столбцы сетки
// Поле, подпись, сортируемый
$grid->add('NAME', 'Наименование', true);
// задаём формат с 2 знаками после запятой
$grid->add('PRICE|number_format[2,., ]', 'Стоимость');
$grid->row(function($row) {
// Денежные величины прижимаем вправо
$row->cell('PRICE')->style("text-align: right");
});
// Добавляем кнопки для просмотра, редактирования и удаления записи
$grid->edit('/product/edit', 'Редактирование', 'show|modify|delete');
// Добавляем кнопку добавления заказчика
$grid->link('/product/edit', "Добавление товара", "TR");
// задаём сортировку
$grid->orderBy('NAME', 'asc');
// задаём количество записей на страницу
$grid->paginate(10);
// отображаем шаблон customer и передаём в него фильтр и грид
return view('product', compact('filter', 'grid'));
}
/**
* Добавление, редактирование и удаление заказчика
*
* @return Response
*/
public function editProduct() {
if (\Input::get('do_delete') == 1)
return "not the first";
// создаём редактор
$edit = \DataEdit::source(new Product());
// задаём подпись диалога в зависимости от типа операции
switch ($edit->status) {
case 'create':
$edit->label('Добавление товара');
break;
case 'modify':
$edit->label('Редактирование товара');
break;
case 'do_delete':
$edit->label('Удаление товара');
break;
case 'show':
$edit->label('Карточка товара');
$edit->link('products', 'Назад', 'TR');
break;
}
// задаём что после операций добавления, редактирования и удаления
// возвращаемся к списку заказчиков
$edit->back('insert|update|do_delete', 'products');
// Добавляем редакторы определённого типа, задаём им подпись
// и связываем их с атрибутами модели
$edit->add('NAME', 'Наименование', 'text')->rule('required|max:100');
$edit->add('PRICE', 'Стоимость', 'text')->rule('max:19');
$edit->add('DESCRIPTION', 'Описание', 'textarea')
->attributes(['rows' => 8])
->rule('max:8192');
// отображаем шаблон product_edit и передаём в него редактор
return $edit->view('product_edit', compact('edit'));
}
}
```
Контроллер счёт фактур является более сложным. В него добавлена дополнительная функция оплаты счёта. Оплаченные счёт фактуры подсвечиваются другим цветом. При просмотре счёт фактуры отображаются так же её позиции. Во время редактирования счёт фактуры есть возможность редактировать и её позиции. Далее я приведу текст контроллера с подробными комментариями.
**Контроллер Invoice**
```
/*
* Контроллер счёт фактур
*/
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Invoice;
use App\Customer;
use App\Product;
use App\InvoiceLine;
class InvoiceController extends Controller {
/**
* Отображает список счёт-фактур
*
* @return Response
*/
public function showInvoices() {
// Модель счёт фактур будет одновременно
// выбирать связанных поставщиков
$invoices = Invoice::with('customer');
// Подключаем виджет для поиска
$filter = \DataFilter::source($invoices);
// Позволяем фильтровать по диапазону дат
$filter->add('INVOICE_DATE', 'Дата', 'daterange');
// и фильтровать по имени заказчика
$filter->add('customer.NAME', 'Заказчик', 'text');
$filter->submit('Поиск');
$filter->reset('Сброс');
// Создам сетку для отображения отфильтрованных данных
$grid = \DataGrid::source($filter);
// выводимые столбцы сетки
// Поле, подпись, сортируемый
// для даты задаём дополнительную функцию, которая преобразует дату в строку
$grid->add('INVOICE_DATE|strtotime|date[d.m.Y H:i:s]', 'Дата', true);
// для денег задам формат с двумя знаками после запятой
$grid->add('TOTAL_SALE|number_format[2,., ]', 'Сумма');
$grid->add('customer.NAME', 'Заказчик');
// Значение boolean отображаем как Да/Нет
$grid->add('PAID', 'Оплачено')
->cell(function( $value, $row) {
return $value ? 'Да' : 'Нет';
});
// задаём функцию обработки каждой строки
$grid->row(function($row) {
// Денежные величины прижимаем вправо
$row->cell('TOTAL_SALE')->style("text-align: right");
// окрашиваем оплаченные накладные в другой цвет
if ($row->cell('PAID')->value == 'Да') {
$row->style("background-color: #ddffee;");
}
});
// Добавляем кнопки для просмотра, редактирования и удаления записи
$grid->edit('/invoice/edit', 'Редактирование', 'show|modify|delete');
// Добавляем кнопку добавления счёт-фактуры
$grid->link('/invoice/edit', "Добавление счёта", "TR");
// задаём сортировку
$grid->orderBy('INVOICE_DATE', 'desc');
// задаём количество записей на страницу
$grid->paginate(10);
// отображаем шаблон customer и передаём в него фильтр и грид
return view('invoice', compact('filter', 'grid'));
}
/**
* Добавление, редактирование и удаление счет фактуры
*
* @return Response
*/
public function editInvoice() {
// Получаем текст сохранённой ошибки, если она была
$error_msg = \Request::old('error_msg');
// создаём редактор счёт фактуры
$edit = \DataEdit::source(new Invoice());
// если счёт оплачен, то генерируем ошибку при попытке его редактирования
if (($edit->model->PAID) && ($edit->status === 'modify')) {
$edit->status = 'show';
$error_msg = 'Редактирование не возможно. Счёт уже оплачен.';
}
// если счёт оплачен, то генерируем ошибку при попытке его удаления
if (($edit->model->PAID) && ($edit->status === 'delete')) {
$edit->status = 'show';
$error_msg = 'Удаление не возможно. Счёт уже оплачен.';
}
// задаём подпись диалога в зависимости от типа операции
switch ($edit->status) {
case 'create':
$edit->label('Добавление счета');
break;
case 'modify':
$edit->label('Редактирование счета');
break;
case 'do_delete':
$edit->label('Удаление счета');
break;
case 'show':
$edit->label('Счет');
$edit->link('invoices', 'Назад', 'TR');
// Если счёт фактуры не оплачена, показываем кнопку оплатить
if (!$edit->model->PAID)
$edit->link('invoice/pay/' . $edit->model->INVOICE_ID, 'Оплатить', 'BL');
break;
}
// задаём что после операций добавления, редактирования и удаления
// возвращаемся к списку счет фактур
$edit->back('insert|update|do_delete', 'invoices');
// Задаём для поля дата, что оно обязательное
// По умолчанию ставится текущая дата
$edit->add('INVOICE_DATE', 'Дата', 'datetime')
->rule('required')
->insertValue(date('Y-m-d H:i:s'));
// Добавляем поле для ввода заказчика. При наборе имени заказчика
// будет отображаться список подсказок
$edit->add('customer.NAME', 'Заказчик', 'autocomplete')
->rule('required')
->options(Customer::lists('NAME', 'CUSTOMER_ID')->all());
// добавляем поле, которое будет отображать сумму накладной, только для чтения
$edit->add('TOTAL_SALE', 'Сумма', 'text')
->mode('readonly')
->insertValue('0.00');
// Добавляем галочку Оплачено
$paidCheckbox = $edit->add('PAID', 'Оплачено', 'checkbox')
->insertValue('0')
->mode('readonly');
$paidCheckbox->checked_output = 'Да';
$paidCheckbox->unchecked_output = 'Нет';
// создаём грид для отображения строк счет фактуры
$grid = $this->getInvoiceLineGrid($edit->model, $edit->status);
// отображаем шаблон invoice_edit и передаём в него редактор и
// грид для отображения позиций
return $edit->view('invoice_edit', compact('edit', 'grid', 'error_msg'));
}
/**
* Оплата счёт фактуры
*
* @return Response
*/
public function payInvoice($id) {
try {
// находим счёт фактуру по идентификатору
$invoice = Invoice::findOrFail($id);
// вызываем процедуру оплаты
$invoice->pay();
} catch (\Illuminate\Database\QueryException $e) {
// если произошла ошибка, то
// выделяем текст исключения
$pos = strpos($e->getMessage(), 'E_INVOICE_ALREADY_PAYED');
if ($pos !== false) {
// перенаправляем на страницу редактора и отображаем там ошибку
return redirect('invoice/edit?show=' . $id)
->withInput(['error_msg' => 'Счёт уже оплачен']);
} else
throw $e;
}
// перенаправляем на страницу редактора
return redirect('invoice/edit?show=' . $id);
}
/**
* Получение сетки для строк счета фактуры
* @param \App\Invoice $invoice
* @param string $mode
* @return \DataGrid
*/
private function getInvoiceLineGrid(Invoice $invoice, $mode) {
// Получаем строки счёт фактуры
// Для каждой позиции счёта будет инициализироваться связанный с ним продукт
$lines = InvoiceLine::with('product')->where('INVOICE_ID', $invoice->INVOICE_ID);
// Создам сетку для отображения позиций накладной
$grid = \DataGrid::source($lines);
// выводимые столбцы сетки
// Поле, подпись, сортируемый
$grid->add('product.NAME', 'Наименование');
$grid->add('QUANTITY', 'Количество');
$grid->add('SALE_PRICE|number_format[2,., ]', 'Стоимость')->style('min-width: 8em;');
$grid->add('SUM_PRICE|number_format[2,., ]', 'Сумма')->style('min-width: 8em;');
// задаём функцию обработки каждой строки
$grid->row(function($row) {
$row->cell('QUANTITY')->style("text-align: right");
// Денежные величины приживаем вправо
$row->cell('SALE_PRICE')->style("text-align: right");
$row->cell('SUM_PRICE')->style("text-align: right");
});
if ($mode == 'modify') {
// Добавляем кнопки для просмотра, редактирования и удаления записи
$grid->edit('/invoice/editline', 'Редактирование', 'modify|delete');
// Добавляем кнопку добавления заказчика
$grid->link('/invoice/editline?invoice_id=' . $invoice->INVOICE_ID, "Добавление позиции", "TR");
}
return $grid;
}
/**
* Добавление, редактирование и удаление позиций счет фактуры
*
* @return Response
*/
public function editInvoiceLine() {
if (\Input::get('do_delete') == 1)
return "not the first";
$invoice_id = null;
// создаём редактор позиции счёт фактуры
$edit = \DataEdit::source(new InvoiceLine());
// задаём подпись диалога в зависимости от типа операции
switch ($edit->status) {
case 'create':
$edit->label('Добавление позиции');
$invoice_id = \Input::get('invoice_id');
break;
case 'modify':
$edit->label('Редактирование позиции');
$invoice_id = $edit->model->INVOICE_ID;
break;
case 'delete':
$invoice_id = $edit->model->INVOICE_ID;
break;
case 'do_delete':
$edit->label('Удаление позиции');
$invoice_id = $edit->model->INVOICE_ID;
break;
}
// формируем url для возврата
$base = str_replace(\Request::path(), '', strtok(\Request::fullUrl(), '?'));
$back_url = $base . 'invoice/edit?modify=' . $invoice_id;
// устанавливаем страницу для возврата
$edit->back('insert|update|do_delete', $back_url);
$edit->back_url = $back_url;
// добавляем скрытое поле с кодом счёт фактуры
$edit->add('INVOICE_ID', '', 'hidden')
->rule('required')
->insertValue($invoice_id)
->updateValue($invoice_id);
// Добавляем поле для ввода товара. При наборе имени товара
// будет отображаться список подсказок
$edit->add('product.NAME', 'Наименование', 'autocomplete')
->rule('required')
->options(Product::lists('NAME', 'PRODUCT_ID')->all());
// поле для ввода количества
$edit->add('QUANTITY', 'Количество', 'text')
->rule('required');
// отображаем шаблон invoice_line_edit и передаём в него редактор
return $edit->view('invoice_line_edit', compact('edit'));
}
}
```
Редактор счёт фактур имеет не стандартный для zofe/rapyd вид, поскольку нам необходимо выводить сетку с позициями счёт фактур. Для этого мы изменили шаблон invoice\_edit следующим образом.
**Шаблон invoice\_edit.blade**
```
@extends('example')
@section('title','Редактирование счета')
@section('body')
{!! $edit->header !!}
@if($error\_msg)
**Ошибка!** {{ $error\_msg }}
@endif
{!! $edit->message !!}
@if(!$edit->message)
{!! $edit->render('INVOICE\_DATE') !!}
{!! $edit->render('customer.NAME') !!}
{!! $edit->render('TOTAL\_SALE') !!}
{!! $edit->render('PAID') !!}
{!! $grid !!}
@endif
{!! $edit->footer !!}
@stop
```
Теперь, когда все контроллеры написаны, изменим маршруты так, чтобы наш сайт на стартовой странице открывал список счёт фактур. Напоминаю, что маршруты настраиваются в файле app/Http/routes.php в Laravel 5.2 и routes/wep.php в Laravel 5.3.
```
// Корневой маршрут
Route::get('/', 'InvoiceController@showInvoices');
Route::get('/customers', 'CustomerController@showCustomers');
Route::any('/customer/edit', 'CustomerController@editCustomer');
Route::get('/products', 'ProductController@showProducts');
Route::any('/product/edit', 'ProductController@editProduct');
Route::get('/invoices', 'InvoiceController@showInvoices');
Route::any('/invoice/edit', 'InvoiceController@editInvoice');
Route::any('/invoice/pay/{id}', 'InvoiceController@payInvoice');
Route::any('/invoice/editline', 'InvoiceController@editInvoiceLine');
```
Здесь маршрут /invoice/pay/{id} выделяет идентификатор счёт фактуры из адреса и передаёт его в метод payInvoice. Остальные маршруты не требуют отдельного пояснения.
Напоследок приведу несколько скриншотов получившегося веб приложения.
На этом мой пример закончен. Исходные коды вы можете скачать по ссылке <https://github.com/sim1984/phpfbexample> | https://habr.com/ru/post/317458/ | null | ru | null |
# EasyMapping, или Путешествие по JSON'у
> Computer programs are the most complex things that humans make. It is also the nature of software to be extensively modified over its productive life. If we can read and understand it, then we can hope to modify and improve it.
>
>
>
> Douglas Crockford, автор спецификации JSON
JSON — это мост между двумя мирами: миром веб-сервисов и миром клиентских приложений. Однако мост не настолько совершенен, чтобы данные существовали в одном формате. Пока что мы всегда вынуждены преобразовывать информацию в представление того языка, с которым работаем, для архитектуры того приложения, которое пишем. Для того чтобы такое преобразование было успешным, оно должно быть в первую очередь простым.
Есть много способов превращения JSON в Objective-C обьекты, однако многие из них имеют свои недостатки, которые мешают с ними работать. Есть известный и любимый многими [RestKit](https://github.com/RestKit/RestKit), однако он, к сожалению, эффективно работает только при наличии идеального REST API. Шаг в сторону — и вы будете забивать гвозди микроскопом, не понимая, зачем нужно писать такие сложные конструкции для достаточно простых вещей. Есть решение от разработчиков GitHub — [Mantle](https://github.com/github/Mantle), однако с ним вы будете вынуждены наследоваться от базового класса Mantle и постоянно использовать [NSValueTransformer](https://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Classes/NSValueTransformer_Class/Reference/Reference.html) — не самую популярную технологию в iOS/Mac OS разработке.
Я хочу рассказать о фреймворке, который недавно нашелся на просторах GitHub, и который позволяет достаточно просто и красиво преобразовывать JSON в Objective-C обьекты — [EasyMapping](https://github.com/lucasmedeirosleite/EasyMapping).
Если заинтересовались, добро пожаловать под кат!
#### Задача
Возьмем для примера следующий JSON:
```
{
"name": "Lucas",
"email": "notexisting@gmail.com",
"gender" : "male",
"car": {
"model": "i30",
"year": "2013"
},
"phones": [
{
"ddi": "55",
"ddd": "85",
"number": "1111-1111"
},
{
"ddi": "55",
"ddd": "11",
"number": "2222-222"
}
]
}
```
В Objective-C будем использовать такие классы:
```
typedef enum {
GenderMale,
GenderFemale
} Gender;
@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSString *email;
@property (nonatomic, assign) Gender gender;
@property (nonatomic, strong) Car *car;
@property (nonatomic, strong) NSArray *phones;
@end
@interface Car : NSObject
@property (nonatomic, copy) NSString *model;
@property (nonatomic, copy) NSString *year;
@end
@interface Phone : NSObject
@property (nonatomic, copy) NSString *DDI;
@property (nonatomic, copy) NSString *DDD;
@property (nonatomic, copy) NSString *number;
@end
```
#### Реализация
Для каждого класса необходимо создать маппинг (EKObjectMapping), например:
```
EKObjectMapping * mapping = [[EKObjectMapping alloc] initWithObjectClass:[Person class]];
```
После чего необходимо добавить соотношения ключ-значение для связи <ключ в JSON> -> <имя свойства обьекта>. Рассмотрим наиболее часто встречающиеся ситуации при маппинге и обработку этих ситуаций при помощи EasyMapping.
**1. Ключи в JSON совпадают с именами свойств обьекта**
Пример, класс Person:
```
[mapping mapFieldsFromArray:@[@"name",@"email"]];
```
**2. Ключи в JSON отличаются от имен свойств обьекта**
Пример, класс Phone:
```
[mapping mapFieldsFromDictionary:@{@"ddi":@"DDI", @"ddd":@"DDD"}];
```
**3. Значение требует дополнительной обработки**
Пример, класс Person
```
NSDictionary *genders = @{ @"male": @(GenderMale), @"female": @(GenderFemale) };
[mapping mapKey:@"gender" toField:@"gender" withValueBlock:^(NSString *key, id value) {
return genders[value];
}];
```
**4. Обьект содержит обьект другого класса**
Пример, класс Person
```
[mapping hasOneMapping:[Car objectMapping] forKey:@"car"];
```
**5. Обьект содержит массив обьектов другого класса**
Пример. Класс Person
```
[mapping hasManyMapping:[Phone objectMapping] forKey:@"phones"];
```
#### Результат
Полностью маппинги для наших классов:
```
// Car mapping
+ (EKObjectMapping *)objectMapping
{
EKObjectMapping * mapping = [[EKObjectMapping alloc] initWithObjectClass:[Car class]];
[mapping mapFieldsFromArray:@[@"model", @"year"]];
return mapping;
}
// Phone mapping
+ (EKObjectMapping *)objectMapping
{
EKObjectMapping * mapping = [[EKObjectMapping alloc] initWithObjectClass:[Phone class]];
[mapping mapFieldsFromArray:@[@"number"]];
[mapping mapFieldsFromDictionary:@{
@"ddi" : @"DDI",
@"ddd" : @"DDD"
}];
return mapping;
}
// Person mapping
+ (EKObjectMapping *)objectMapping
{
EKObjectMapping * mapping = [[EKObjectMapping alloc] initWithObjectClass:[Person class]];
NSDictionary *genders = @{ @"male": @(GenderMale), @"female": @(GenderFemale) };
[mapping mapFieldsFromArray:@[@"name", @"email"]];
[mapping mapKey:@"gender" toField:@"gender" withValueBlock:^(NSString *key, id value) {
return genders[value];
}];
[mapping hasOneMapping:[Car objectMapping] forKey:@"car"];
[mapping hasManyMapping:[Phone objectMapping] forKey:@"phones"];
return mapping;
}
```
Теперь, когда маппинг готов, создание обьекта Person выглядит следующим образом:
```
NSDictionary * personProperties = ...; // JSON обьекта Person, приведенный выше, распарсенный в словарь.
Person * person = [[Person alloc] init];
[EKMapper fillObject:person fromExternalRepresentation:personProperties withMapping:mapping];
```
Таким образом, при создании обьекта не используются никакие конструкции if-else, отсутствуют проверки на NSNull. Кроме того, существующие обьекты можно легко обновить новыми данными, если такая потребность возникнет.
##### Дополнительные плюшки EasyMapping
1. Поддержка CoreData
2. Встроенная проверка на NSNull — NSNull автоматически заменяется на nil.
3. Возможность сериализации обьектов в NSDictionary/NSArray
4. Поддержка установки через CocoaPods
5. Полностью покрыт тестами.
##### Удачные практики при реализации
Заполнение обьекта при помощи EKMapper лучше вынести в базовый класс, скажем, BaseModel, следующим образом:
```
- (id)initWithProperties:(NSDictionary *)properties
{
if (self = [super init])
{
[EKMapper fillObject:self fromExternalRepresentation:properties
withMapping:[[self class] objectMapping];
}
return self;
}
+ (EKObjectMapping *)objectMapping
{
//Do nothing. Implement in subclass if you want to initialize object
//via object mapping
return nil;
}
```
Таким образом, создание обьекта будет выглядеть так:
```
Person * person = [[Person alloc] initWithProperties:personProperties];
```
#### Заключение
Каждый качественный open-source продукт — это трамплин, который позволяет нам как программистам прыгать все выше и выше. Проекту EasyMapping всего лишь один месяц, если судить по первому коммиту, однако, на мой взгляд, он уже может соперничать с намного более старыми и продвинутыми решениями, по крайней мере, своей простотой. Хочется пожелать удачи автору этого интересного фреймворка, а всем, кто дочитал до конца, — спасибо за ваше время и удачи в путешествиях по JSON'у!
#### Ссылки
1. [EasyMapping на github](https://github.com/lucasmedeirosleite/EasyMapping)
2. [CocoaPods](http://cocoapods.org/)
##### Альтернативные решения
1. [RestKit](https://github.com/RestKit/RestKit)
2. [Mantle](https://github.com/github/Mantle) | https://habr.com/ru/post/176721/ | null | ru | null |
# Бой антивирусов
Почти беспристрастное сравнение антивирусов LMD, Manul, ClamAV и Вирусдай.
--------------------------------------------------------------------------
За последний год ряды антивирусов, которые борются с заражением веб-сайтов, пополнились несколькими новыми представителями. Теперь выбор веб-мастера или владельца сайта становится сложнее. Еще год или два назад выбирать было не из чего.
Разборы отдельных случаев применения антивирусов уже публиковались на Хабре. Однако, сколько-нибудь общее и полноценное сравнение никто не делал. Чтобы помочь понять разницу между антивирусными продуктами для борьбы с вирусами на серверах и сайтах мы сегодня сравним по полноте и точности антивирусные базы четырех антивирусов. Сделать постараемся это корректно и беспристрастно.
Сравнение точности детектирования
---------------------------------
Давайте разберемся с точностью детектирования угроз каждым антивирусом. Для каждого из пациентов возможны ложные срабатывания и наша задача — определить их долю во множестве обнаруженных файлов каждым из антивирусов в отдельности. Ведь никому не нужен антивирус, который показывает пальцем на хорошие файлы вместо зараженных.
Для анализа точности определения угроз мы будем использовать набор сайтов (W). Разницы между заражениями и подозрениями мы не будем делать из-за того, что подобных функций нет у некоторых антивирусов. Нам придется вручную проверить обнаруженный каждым антивирусом файл на предмет наличия вредоносного кода в нем (мы же боремся за объективность). Такая работа, как вы понимаете, (в случае, если таких файлов много) отнимет много сил и времени. Поэтому мы возьмем набор сайтов W необходимым и достаточным для удовлетворительной точности и сравнительно небольшого времени ручного анализа. W=1500.
Пусть , , ,  — множества файлов, определенные каждым из антивирусов в отдельности при анализе одного и того же набора сайтов (W).
Точностью определения (A) антивируса будем называть подмножество различных гарантированно содержащих вредоносный код файлов , выявленных им на соответствующем множестве . Т.е. , , , .
Для наглядности будем измерять точность детектирования A в единицах соответствующего . Результаты замеров точности приведены ниже.
В тестах мы не использовали md5 сигнатуры из антивирусных баз ClamAV и LMD. При заражении веб-сайтов вредоносный код почти всегда либо встраивается в существующие файлы, либо видоизменяется от одного заражения к другому. Такой полиморфизм легко реализовать, когда дело касается заражения веб-сайтов. В таком случае эффективность определения угроз по контрольным суммам файлов крайне низка, но при этом она подразумевает вычисление этих сумм для тысяч файлов на сайте, что существенно снижает быстродействие, почти не сказываясь на качестве обнаружения.
Сравнение полноты определения
-----------------------------
Второй важный параметр для антивируса — полнота определения, т.е. количество выявляемых угроз из их полного числа на зараженном сервере или сайте.
Полнота в нашем анализе тесно связана с точностью определения. Мы будем рассматривать для сравнения полноты только точные (не ложные) срабатывания антивирусов.
Возьмем множества точных срабатываний антивирусов из предыдущего теста: , , ,  — множества точно зараженных файлов, определенные каждым из антивирусов в отдельности при анализе одного и того же набора сайтов (W). Считаем, что  — это объединенное множество гарантированно зараженных файлов, выявленных антивирусами на заданном тестовом наборе сайтов W. Другими словами, .
Полнотой определения (F) антивируса будем называть подмножество различных гарантированно зараженных файлов, выявленных им на объединенном множестве файлов . Т.е. , , , .
Будем измерять полноту определения F в единицах . Итак, вот какие данные мы получили при анализе параметра полноты для каждого из антивирусов.
Итак, мы сравнили качество и полноту детектирования заражений. Теперь приведем сводные данные в одной таблице.
| | | |
| --- | --- | --- |
| | Полнота определения F, % | Точность определения A, % |
| LMD | 11,86% | 60,52% |
| Вирусдай | 78,87% | 92,72% |
| Манул | 47,42% | 2,53% |
| ClamAV | 9,28% | 69,23% |
При ручной проверке файлов, определенных антивирусами как зараженные, мы выявили несколько интересных фактов, о которых хотелось бы упомянуть отдельно. Начнем с количества файлов, обнаруженных каждым антивирусом. Manul нашел зараженные или подозрительные файлы почти на каждом проверяемом сайте. Мы были сильно удивлены, когда посчитали, что доля детектированных им файлов составила 98% от общего количества файлов, детектированных всеми антивирусами.
Беда в том, что, как видно из второй диаграммы, только 2.5% этих файлов действительно были заражены. Остальные — ложные срабатывания. Хотя полнота определения у него достаточно высока, такое количество ложных срабатываний сильно затрудняет дальнейший ручной анализ и лечение. Анализируя саму антивирусную базу Manul мы выяснили, что он записывает в «подозрения» достаточно большое количество часто встречающихся безопасных фрагментов кода. Например, как подозрения определяются следующие вхождения: `file_put_contents`, `@file_get_contents`, `move_uploaded_file`, `ini_set`, `error_reporting`, `phpinfo`, `extract`, `@include`, `mail`, `touch`, `chdir`, `copy`, `create_function` и тп. Отсюда следует, что весьма сложно написать сколь нибудь серьезный PHP скрипт, в котором Manul не найдет подозрений.
Отчасти это касается и ClamAV. Он, к примеру, ищет вхождения некоторых простых английских слов и тоже определяет их как заражения. LMD очень часто по неизвестной причине находит вирусы в библиотеке zip.lib.php, встречающейся на многих сайтах. Конкретно определяется как заражение такой участок кода:
```
$fr .= "\x00\x00";
```
Причины этого неизвестны. И таких примеров можно найти еще достаточно много. Вирусдай тоже не безгрешен. Бывает так, что он находит подозрительный (например, обфусцированный) код в файле, который не является вредоносным. Обфускация может применяться и для защиты программ, а не только для сокрытия вредоносных кодов. Но не смотря на это, его полнота определения превосходит остальные веб-антивирусы.
Наше сравнение, как написано в начале статьи, все же является «почти беспристрастным» по нескольким причинам. Мы проводили тесты на веб-сайтах, то есть искали вирусы только в веб-скриптах. В связи с этим мы не обрабатывали md5 сигнатуры (по описанным выше причинам). Так же ClamAV все же более универсальное средство поиска угроз, рассчитанное не только на веб-сайты.
Сравнение качества лечения
--------------------------
С детектированием мы разобрались. Выясним насколько полно антивирусы определяют фрагмент вредоносного кода в файле. Это важно для организации лечения. Будет не очень хорошо, если при удалении найденного антивирусом фрагмента кода файл вдруг станет нерабочим, а как следствие, часто и сам сайт перестанет функционировать. Конечно, существуют целые вредоносные файлы, но сейчас мы рассматриваем случаи, когда вредоносный код внедрен в хороший файл и удалять все его содержимое целиком нельзя.
Разберем этот параметр на примере вредоносного кода, который детектировали сравниваемые антивирусы. В нашем примере код имел такое содержание:
LMD определяет его как вредоносный по вхождению такого участка кода:
```
= ''; for($i=0; $i < strlen($
```
Сам по себе этот участок кода вряд ли можно назвать вредоносным и он вполне может встретиться в нормальных скриптах.
Manul определяет его как вредоносный по вхождению такого участка:
```
eval(
```
Как мы уже писали, Manul много чего считает опасным. Использование множества встроенных PHP функций присутствует почти в каждом скрипте и поднимать тревогу только по этому поводу нет смысла, это только затрудняет анализ отчетов по сканированиям.
ClamAV не нашел в этом коде ничего.
Вирусдай смог найти этот код целиком. Соответственно этот код может быть безопасно удален из файла, чего нельзя сказать о других антивирусах.
Возьмем другой пример с кодом примерно такого содержания:
Его нашли все 4 антивируса.
LMD нашел такой участок:
```
_']=Array(base64_decode('
```
Сомнительно, но имеет право на жизнь.
ClamAV:
```
$GLOBALS['_433305846_']=Array(base64_decode('' .'ZG' .'Vma' .'W5l'),base64_decode('ZmlsZV9n' .'ZXRfY2'
</code
```
Хорошо, но ClamAV ищет этот код по точному вхождению. Он не сможет найти этот код при малейшем его изменении при повторном заражении. Но эта разновидность вируса редко встречается именно в таком виде и скорее всего при заражении другого сайта код будет выглядеть несколько иначе.
Manul нашел это:
```
$GLOBALS['_433305846_']=Array(base64_decode('' .'ZG' .'Vma' .'W5l'),base64_decode('ZmlsZV9n' .'ZXRfY2' .'9udGVudH' .'M=')
```
Тоже хорошо, тем более любая разновидность этого кода им тоже будет найдена, так как поиск производится по достаточно сложному регулярному выражению, охватывающему все разновидности этого кода.
Но ни в одном случае найденный код не может быть вырезан из файла. Вирусдай же определяет весь этот код от начала до конца как вредоносный и может безболезненно его вырезать при лечении. Вообще лечение файлов (имеется в виду не удаление файла, а именно вырезание вредоносного участка из файла) недоступно во всех этих антивирусах. Вирусдай тоже может вылечить не все, но многое.
Вы можете подумать, что мы специально могли взять такие примеры вирусов, которые не лечатся другими антивирусами. Это не так. Мы просто постарались выбрать примеры, наиболее наглядно показывающие разницу качества лечения. В принципе почти любой пример, который мы могли бы взять, показывал бы то же самое, но не так наглядно. Мы анализировали антивирусные базы всех антивирусов, и почти все сигнатуры в этих базах детектируют отдельные мелкие участки кода, не охватывая тело вируса целиком.
Вместо вывода
-------------
ClamAV не умеет лечить. LMD, ClamAV и Манул — бесплатные серверные утилиты, а [Вирусдай](https://virusdie.ru/) — платный SaaS с поддержкой и фаерволом. Обсуждать функциональность и удобство использования каждого антивируса мы в данной статье не будем, поскольку отличий у них множество, а ограничимся только сравнением антивирусных баз. Сухая статистика говорит лучше обилия пустых слов. Да и кроме того, каждый волен выбирать себе инструмент по душе и по потребностям. | https://habr.com/ru/post/263785/ | null | ru | null |
# Выборочное логирование SQL запросов в Hibernate
В начале прошлой недели я стал работать на реальном проекте который управляет аудиоконтентом для радиостанции. Обычная админ панель с использованием VAADIN фреймворка (<https://vaadin.com/home>) предоставляет пользователю веб интерфейс, который позволяет настраивать списки проигрывания и прочие фичи, упрощающие жизнь диджеев.
Заказчику досталось приложение по наследству и он захотел расширить его функционал и исправить баги, которые были выявлены в ходе работы системы. Как по мне, то вполне обычное и рациональное желание.
Одним из моих заданий было исправить баг с выборкой данных. Как оказалось приложение писало в базу данных записи с пустыми значениями, а при выборке подразумевалось, что данные непусты. Приложение использует JPA реализацию от Hibernate для работы с базой данных. Ну в принципе ничего удивительного, ведь Hibernate достаточно распространенный фреймворк. С ним работаю уже несколько лет, но не являюсь профессионалом. Кроме того модель базы данных и объектная Java модель оказались не из простых: с использованием циклических зависимостей, наследования, связей многие-ко-многим и т.д. В общем сразу, взглянув на модель, я не понял где искать причину ошибки.
Встал вопрос о логировании SQL для того чтобы определить где пропушен валидатор.
Использовать параметр **hibernate.show\_sql = true** мне не очень нравилось. Я видел две проблемы:
1) Hibernate в System.out пишет только SQL запросы с вопросительными знаками и без реальных параметров;
2) Hibernate пишет абсолютно все запросы к базе данных (Как оказалось на одну загрузку станицы приложение выполняло порядка 50 запросов).
Взглянув на выведенные запросы, я понял, что нужно мне выводить только запросы к тем таблицам, которые связанны с моим заданием.
Обратившись за помощью к google я нашел совет как мне отображать реальные параметры: при использовании Log4j нужно добавить логгер для параметров ([ссылка на статью](http://www.mkyong.com/hibernate/how-to-display-hibernate-sql-parameter-values-log4j/)):
# Hibernate logging options (INFO only shows startup messages)
log4j.logger.org.hibernate=INFO
# Log JDBC bind parameter runtime arguments
log4j.logger.org.hibernate.type=trace
После данных телодвижений я решил проблему № 1: в лог писались параметры запросов, но логи стали чрезмерно большими, мне пришлось несколько минут искать нужный мне запрос. Я сразу понял что так дело не пойдет и тогда родилась идея при работе приложения включать и выключать логирование запросов.
Текущий проект использует EJB 3 компоненты для работы с базой данных, прочитав об Interceptors возникла идея написать его для включения и выключения логирования SQL запросов на лету.
Код следующий:
```
//Класс Interceptor
public class ShowHibernateSQLInterceptor {
//аннотированный метод
@AroundInvoke
public Object showSQL(InvocationContext ictx) throws Exception {
//включение логирования SQL запросов
Logger sqlLogger = Logger.getLogger("org.hibernate.SQL");
sqlLogger.setLevel(Level.DEBUG);
//Включение логирования параметров запросов
Logger descLogger = Logger.getLogger("org.hibernate.type.descriptor.sql.BasicBinder");
descLogger.setLevel(Level.TRACE);
//Выполнение аннотированного метода сервиса
Object res = ictx.proceed();
//Выключение логирования SQL
sqlLogger = Logger.getLogger("org.hibernate.SQL");
sqlLogger.setLevel(Level.INFO);
//Выключение логирования параметров
descLogger = Logger.getLogger("org.hibernate.type.descriptor.sql.BasicBinder");
descLogger.setLevel(Level.INFO);
return res;
}
}
```
Пример использования логирования для выбранного метода из сервиса:
```
@Override
@Interceptors(ShowHibernateSQLInterceptor.class)
public List listAllAudioItems() {
return em.createQuery("select a from AudioItem a").getResultList();
}
```
При вызове метода в лог пишутся все SQL запросы с параметрами, относяшиеся к выбору сущностей AudioItem из базы данных.
(Если **@Interceptors(ShowHibernateSQLInterceptor.class)** указать для всего класса сервиса, а не для выбранного метода, то логироваться будут все методы данного класса)
Т.к. запросы выводяться в лог Hiberante-ом из-за org.hibernate.SQL=DEBUG, необходимость в
**hibernate.show\_sql = true** отпала и я отключил данную возможность.
Итог:
Для логирование только отдельных методов рекомендуется:
1) отключить **hibernate.show\_sql = true**
2) Написать класс Interceptor
3) Добавить interceptor для выбранного метода.
Ограничения:
1) Тестировал только с log4j — не уверен что будет работать с другим логгером, но думаю, что возможно либо добавить Log4j в проект, либо подкорректировать Interceptor для другого logger-фреймворка
2) Предложенное решение актуально только для EJB 3, если проект использует Spring, то необходимо написать аспект (Spring AOP) с похожим функционалом.
3) Тестировал на JBoss AS: этот сервер использует свой logger адаптер для Log4j. Поэтому на другом сервере должно работать, но могут быть нюансы…
Возможно есть более элегантные решения для данной проблемы, но беглый обзор результатов поиска в Google не позволил мне найти таких, поэтому решил потратить 20 минут и проблема была решена и, как результат, таск был выполнен в срок.
Если кто-то знает более лучшее решение, готов его выслушать — так как иногда нуждаюсь в иструменте для анализа запросов Hibernate, который поможет быстро решить поставленную задачу. | https://habr.com/ru/post/149001/ | null | ru | null |
# MPS 2018.3: планы генерации, улучшения в языке сборки и упаковки и в языке редактора, обновленный интерфейс
Привет, Хабр! Недавно мы выпустили [MPS 2018.3](https://www.jetbrains.com/mps/download/). В этой версии много новых функций, с которыми работа над проектами станет еще эффективнее. Мы улучшили планы генерации и язык описания редактора, добавили новые конструкции в язык сборки и упаковки, обновили элементы интерфейса для удобной навигации по иерархии наследования и внесли много других изменений для продуктивной работы.
BaseLanguage
------------
### Иконки для навигации по переопределенным/реализованным концептам
На полях концептов и интерфейс-концептов появились иконки переопределенных/реализованных концептов, которые упрощают навигацию к дочерним концептам.
### Настраиваемые пакеты для классов BaseLanguage
В предыдущих версиях MPS Java-пакет сгенерированных классов однозначно определялся именем модели, в которой находились исходные элементы. В новой версии для BaseLanguage Classifiers добавлено свойство packageName, позволяющее переопределить имя конечного Java-пакета. Свойство packageName имеет смысл только для BL classifiers верхнего уровня, как и в случае с Java classifiers.
### Новые возможности генераторов для расширений BaseLanguage
Для языка BaseLanguage часто создают расширения. Однако для некоторых расширений бывает непросто написать подходящий генератор. Мы добавили в BaseLanguage несколько новых концептов, чтобы упростить процесс написания генераторов для расширений.
### Генерация Lvalue-выражений
Lvalue-выражение представляет собой переменную, в которую можно произвести чтение или запись значения. В некоторых случаях сгенерировать Lvalue-выражение трудно, поскольку оно может зависеть от контекста, в котором используется. Новый вспомогательный концепт `generic lvalue-expression` упростит генератор и сделает его контекстно-независимым.
### Преобразование Lvalue-выражения в ссылки
Некоторые выражения включают другие Lvalue-выражения для осуществления более сложных операций с переменными (например, выражения plus assignment или increment and get). Вводить конструкции с такой семантикой было трудно, потому что для них непросто написать правильный генератор.
В новой версии можно обернуть любое Lvalue-выражение выражением `@byRef`. Генератор BaseLanguage преобразует обернутое выражение в выражение типа `Reference`, что обеспечит методы get и set для обернутой переменной.
Подробнее о новых концептах читайте в [этой статье](https://confluence.jetbrains.com/display/MPSD20183/Implementing+generators+for+BaseLanguage%27s+extensions).
### Поддержка default-методов
В новой версии MPS вы можете создавать default-методы в интерфейсах BaseLanguage. Ключевое слово default реализуется концептом DefaultModifier — расширением концепта Modifier. DefaultModifier содержится в языке jetbrains.mps.baseLanguage.jdk8, поэтому, чтобы создать default-метод в интерфейсе, импортируйте язык jdk8.
Генератор
---------
### Язык генератора (язык трансформации моделей)
Мы убрали макрос $INCLUDE$, заменив его использование на $CALL$. Соответствующая миграция поможет обновить ваши проекты. Макрос $INCLUDE$ не поддерживает шаблоны с аргументами, а наличие двух схожих по функциональности макросов усложняет язык.
Макроc $WEAVE$ и weaving-правила теперь научились вызывать шаблоны с аргументами. Кроме того, мы исправили неприятный, хотя и не очень заметный дефект, возникающий при одновременном использовании скомпилированных и интерпретируемых шаблонов. «Внедрение» (weave) внешнего шаблона из интерпретируемого кода раньше всегда приводило к интерпретации, теперь же будет работать скомпилированный шаблон (конечно, при условии, что использование скомпилированных шаблонов включено в свойствах генератора). Аналогичным образом работает «внедрение» (weave) интерпретируемого внешнего шаблона из скомпилированного.
QueriesGenerated, набор скомпилированных модельных запросов для модели с шаблонами, всегда полагался на соглашение имен и механизм Java reflection для исполнения кода. Вы могли видеть это в стектрейсах, когда в модельном запросе из генератора что-то прошло не так. Мы, наконец, избавились от этого механизма.
Элементы UI/UX
--------------
### Поддержка тачбара MacBook
Обладатели макбуков с тачбаром теперь могут использовать его для работы в MPS: например, вызывать действия запуска, сборки и отладки приложения из тачбара, а также быстро выбирать run/debug конфигурацию или создавать новую. Элементы управления тачбара можно настроить на странице Settings/Preferences | Appearance & Behavior | Menus and Toolbars.
И конечно, возможности тачбара можно расширить! Просто добавьте нужное действие в соответствующую `InterfaceGroup`.
### Высококонтрастная тема
Как и в IntelliJ Platform в MPS появилась новая высококонтрастная тема. Ее можно включить в Settings/Preferences -> Appearance & Behavior.
### Инструменты для поиска deprecated кода
В меню Migration | Deprecated Code собраны действия для поиска deprecated кода и работы с его использованиями. ***Find Usages of Deprecated*** группирует результаты поиска по предполагаемой версии удаления, что помогает определить критичность и выбрать, какие из использований следует удалить в первую очередь.
### Иконки для навигации по переопределенным/реализованным behavior-методам
На полях behavior-классов мы добавили иконки для навигации по переопределенным/реализованным behavior-методам. Ниже показан список методов getPresentation(), которые переопределяют или реализуют выбранный метод. Из списка можно легко перейти к любому из указанных методов.
### Улучшения всплывающих окон для навигации по переопределенным элементам
Всплывающие окна переопределенных/реализованных концептов/классов/методов стали асинхронными. Это означает, что MPS будет добавлять результаты поиска во всплывающее окно в фоновом режиме. Кроме того, теперь можно фильтровать результаты поиска по имени объекта.
### Изменения в finders
В этой версии мы обновили и оптимизировали finders. Для асинхронного выполнения finder используйте специальное выражение OnEachNodeFoundByExpression, представляющее собой простой вызов finder c функцией обратного вызова для каждого обнаруженного узла.
Также изменились настройки поиска использований (Find Usages settings) для концептов. Мы добавили опции поиска Concept Ancestors и Derived Concepts, которые выдают список родительских и дочерних концептов соответственно. Кроме того, возможности поиска для behavior-методов были расширены опциями Overridden Methods и Overriding Methods.
### Игнорирование ошибок
В MPS можно игнорировать ошибки на узлах. Это удобно в случаях, когда ошибка отображается в редакторе, но в конкретном контексте не имеет смысла (например, в шаблонах генератора). Раньше возможности для подавления таких ошибок были негибкими. Если узел был аннотирован атрибутом ‘SuppressErrorAnnotation’, то на нем вызывали интеншен ‘Suppress error for node …’. Применение этого интеншена подавляло все виды ошибок на этом узле и всех его потомках — таким образом могли быть проигнорированы актуальные ошибки.
Теперь появилась возможно игнорировать только определенные виды ошибок. Выбранная ошибка будет проигнорирована для данного узла и всех его потомков, но при этом все остальные сообщения будут отображаться. Подробнее о новых возможностях управления ошибками читайте в [документации](https://confluence.jetbrains.com/display/MPSD20183/Suppressing+Errors).
Язык сборки и упаковки
----------------------
### Tips & Tricks
В RCP (Rich Client Platform) приложения раньше по умолчанию добавлялись tips & tricks из MPS. Теперь tips & tricks для своего приложения возможно переопределять с помощью с новой конструкции tips & tricks в билд-скрипте. Как и раньше можно использовать tips из дистрибутива MPS или определять их самостоятельно в каталоге или solution-модуле и импортировать.
### Язык описания Tips & Tricks
Чтобы импортировать tips & tricks в билд-скрипт из solution-модуля, создайте solution и импортируйте языки jetbrains.mps.build.tips и jetbrains.mps.core.xml. Затем создайте экземпляр концепта MPSTipsAndTricks и опишите в нем ваши tips (советы). Каждый совет представляет собой HTML-текст и может содержать не более одного изображения.
### Способы упаковки
Мы пометили способ упаковки (custom packaging) в BuildMps\_IdeaPlugin как deprecated. Вместо него используйте способ упаковки в конструкции BuildMpsLayout\_Plugin.
Способ сборки Auto packaging помещает все модули типа language и solution в папку ‘languages’ корневого каталога плагина, а опция Manual packaging позволяет разработчику задавать структуру плагина самостоятельно.
### Новая конструкция языка сборки и упаковки
Мы расширили возможности тестовой конфигурации (test configuration) в языке сборки и упаковки. Теперь в ней можно указывать дополнительные IntelliJ IDEA плагины, которые должны быть загружены для выполнения MPS тестов из Ant.
В некоторых случаях для выполнения теста требуется определенный плагин, который язык сборки не мог вычислить по модулям, содержащим тесты. Теперь вы можете указать плагин необходимый для выполнения теста в test configuration конструкции.
Редактор
--------
### Повторное использование cell action maps
Элементы сell action map из существующего action map можно использовать повторно при помощи импортов.
Прочие улучшения
----------------
### Полностью компилируемые datatypes
Двигаясь в направлении полностью компилируемых языков, мы создали полностью сгенерированные datatypes. Вся сгенерированная информация о datatypes доступна через SModel API.
### Сохранение данных миграции в аннотациях
Мы реализовали новый способ сохранения данных при миграциях, который рекомендуем использовать в дальнейшем. Производный узел, содержащий данные, теперь должен быть прикреплен к любому узлу, расположенному достаточно близко к месту, к которому относятся эти данные.
В скрипте миграции, создающем узлы с данными, нужно объявить концепт таких узлов и использовать конструкцию putData () для вставки каждой такой аннотации в модель:
Извлечение узлов, содержащих данные, выполняется так же, как и раньше:
### Изменения в диалоге разрешения конфликтов
Раньше при конфликте можно было применить изменения только с одной стороны. Но иногда важно не потерять и другие изменения.
Это касается изменений соседних узлов, находящихся в одной и той же множественной роли. Теперь после применения изменений с одной стороны конфликта изменения из другой ветки будут отображены как добавление. Чтобы закончить разрешение конфликта, это добавление нужно обязательно применить или отклонить.
После применения изменений с левой стороны конфликта можно применить или проигнорировать строку с правой стороны:
Скачать новую версию можно [здесь](https://www.jetbrains.com/mps/download/), надеемся, она вас порадует. В любом случае будем ждать ваших [отзывов](https://mps-support.jetbrains.com/hc/en-us/requests/new?ticket_form_id=360000119880)! Полный список исправлений доступен [на этой странице](https://youtrack.jetbrains.com/issues?q=%23MPS%20Fix%20versions:%20%7B2018.3%20Beta%20(EAP8)%7D,%7B2018.3%20EAP%7D%20,%7B2018.3%20EAP1%7D%20,%7B2018.3%20EAP2%7D%20,%7B2018.3%20EAP3%7D%20,%7B2018.3%20EAP4%7D%20,%7B2018.3%20EAP5%7D%20,%7B2018.3%20FF%20(EAP7)%7D%20,%7B2018.3%20RC1%7D%20,%7B2018.3%20RC2%7D%20%20State:%20Fixed). О любых проблемах сообщайте нам, пожалуйста, в [трекере](https://youtrack.jetbrains.com/issues/MPS).
*Ваша команда JetBrains MPS*
*The Drive to Develop* | https://habr.com/ru/post/436652/ | null | ru | null |
# Интеграция шаблонизатора Twig в Symfony 1.4
При попытке интегрировать Twig в Symfony, возникли следующие проблемы: информации практически нет, нет гайда по интеграции, есть мини документация по Twig, которая описывает как работать с Twig, но не как научить его работать с Symfony. Пришлось немного поискать и поспрашивать в google groups.
Надеюсь, кому-то этот материал будет полезен.
Скачиваем [sfTwigPlugin](http://github.com/henrikbjorn/sfTwigPlugin) (здесь есть расширения, которые «импортируют» хелперы Symfony в Twig, есть класс представления, переопределяющий sfPHPView).
Следуем инструкции, описанной [здесь](http://github.com/henrikbjorn/sfTwigPlugin/blob/master/doc/01-Introduction.markdown).
Помещаем плагин в директорию /lib/vendor/symfony/lib/plugins/sfTwigPlugin/.
Подключаем его в ProjectConfiguration.class.php:
> `$this->enablePlugins('sfDoctrinePlugin', 'sfTwigPlugin');
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/88634/ | null | ru | null |
# Генератор кликов на Python для программы Data Engineer
Процесс разработки образовательной программы очень похож на процесс разработки нового продукта. И там, и там ты пытаешься вначале понять, а есть ли спрос на то, что ты собираешься производить? Существует ли в реальности та проблема, которую ты хочешь решить?
### Предыстория
В этот раз для нас всё было довольно просто. Несколько выпускников нашей программы «Специалист по большим данным» в течение, наверное, года просили:
> Сделайте для нас еще одну программу, где мы бы могли научиться работать с Kafka, Elasticsearch и разными инструментами экосистемы Hadoop, чтобы собирать пайплайны данных.
Потом со стороны работодателей стали «прилетать» запросы, которые собирательно можно описать так:
> Data Engineer'ы – это очень горячие вакансии!
>
> Реально их уже на протяжении полугода никак не можем закрыть.
>
> Очень здорово, что вы обратили внимание именно на эту специальность. Сейчас на рынке очень большой перекос в сторону Data Scientist'ов, а больше половины работы по проектам – это именно инженерия.
С этого момента стало понятно, что спрос есть, и проблема существует. Надо бросаться в разработку программы!
Интересный момент в разработке образовательной программы, что ты её валидируешь не у непосредственного потенциального клиента. Ну представьте, мы подходим к человеку, который хотел бы у нас учиться, и спрашиваем: «Вот это — то, что тебе нужно?» А он вообще без понятия, потому что пока не разбирается в этом.
Поэтому программу нужно валидировать, во-первых, у тех, кто в этом разбирается — реальных data engineer'ов; во-вторых, у работодателей — ведь, это они в конечном счёте потребители нашего продукта.
Пообщавшись с шестью дата инженерами, часть из которых участвуют в найме сотрудников в команду, стало очень быстро понятно, в чем состоит основная суть работы такого человека, и какие задачи такой человек должен уметь решать.
### Программа
Суть работы дата инженера заключается в том, чтобы уметь создавать пайплайны из данных, мониторить их и траблшутить, а также решать разовые ad-hoc задачи по выгрузке и трансформации данных.
Конкретизируя, получилось, что он должен уметь:
1. Собирать сырые данные
2. Работать с очередями и их конфигурировать
3. Запускать джобы с обработкой данных (в т.ч. ML) по расписанию
4. Конфигурировать BI
5. Работать с реляционными БД
6. Работать с noSQL
7. Работать с инструментами для real-time обработки
8. Пользоваться command-line tools
9. Работать грамотно с окружением
В каждом из этих пунктов можно записать целый ряд различных инструментов. Есть даже [прекрасная визуализация](http://xyz.insightdataengineering.com/blog/pipeline_map/) на эту тему. Их все охватить в программе не представлялось возможным, да и нужным, поэтому мы решили, что человеку достаточно получить опыт создания одного batch- и одного real-time пайплайна. Остальное, при необходимости, он самостоятельно в будущем освоит.
Но важно, чтобы он научился делать пайплайн «от и до», чтобы не было ни одного белого пятна в этом процессе. И тут возникла проблема для нас, как организаторов.
### Генератор кликов
Мы остановились на том, что наши участники будут анализировать кликстрим. Причем мы должны придумать, как мы будем его генерировать прямо им на сайты. Предпосылки такого решения следующие:
1. Поскольку один из пайплайнов должен быть real-time, то статические готовые датасеты нам не подходят, нам нужно как-то генерировать данные тоже в real-time,
2. Поскольку мы решили, что участники должны строить пайплайн «от и до», то это значит, что они должны собирать данные прямо с сайта, как это они бы делали в реальной жизни.
Отлично, осталось придумать как. Часть дата инженеров подсказала, что можно смотреть в сторону инструментов для тестирования сайта — например, [Selenium](https://habrahabr.ru/post/248559/). Часть даже сделала уточнение, что лучше использовать [PhantomJS](https://en.wikipedia.org/wiki/PhantomJS) внутри него, поскольку он «headless», а значит, будет быстрее.
Мы воспользовались их советом, и написали свой эмулятор пользователей для сайтов наших участников. Сам не-ахти-какой-код ниже (важно: мы выдадим один и тот же сайт всем, поэтому можем в коде использовать конкретные параметры поиска, зная структуру этого сайта):
```
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from numpy.random import choice
import time
import numpy as np
dcap = dict(DesiredCapabilities.PHANTOMJS)
dcap["phantomjs.page.settings.userAgent"] = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 YaBrowser/17.6.1.745 Yowser/2.5 Safari/537.36")
driver = webdriver.PhantomJS(desired_capabilities=dcap)
driver.set_window_size(1024, 768)
hosts = ["35.190.***.***"]
keywords = {"music": "песн", "grammar": "англ"}
conformity = 0.9
condition = 1
def user_journey(host, journey_length, keywords, user_type, conformity):
driver.get("http://" + host)
el = driver.find_element_by_link_text("Статьи") # начинаем наш journey со статей
el.click()
print driver.current_url
for i in xrange(journey_length):
try:
links = []
the_links = []
p = 0
P = []
links = driver.find_elements_by_class_name("b-ff-articles-shortlist__a") # собираем список всех url на странице
if len(links) == 0:
links = driver.find_elements_by_class_name("b-ff-mobile-shortlist__a") # если так не удалось, то другим способом
if len(links) == 0:
links = driver.find_elements_by_class_name("b-ff-articles-tags__a") # если и так не удалось, то другим способом
links[0].click
driver.current_url
the_links = driver.find_elements_by_partial_link_text(keywords.get(user_type)) # собираем все url, содержащие ключевик
the_link = choice(the_links, 1)[0] # рандомно выбираем один из нужных url
links.append(the_link) # добавляем к списку всех ссылок на странице
p = (1-conformity)/float(len(links)-1) # рассчитываем равную вероятность для всех url, но учитывая, что у одной из них будет вероятность conformity
P = [p]*len(links) # присваиваем всему списку одну и ту же вероятность
P[-1] = conformity # у последнего элемента 'the link' меняем вероятность на conformity
l = choice(links, 1, p=P) # делаем рандомный выбор ссылки с заданным списком вероятностей
time.sleep(np.random.poisson(5)) # случайное время ожидания на странице
l[0].click()
print driver.current_url
except:
driver.close # закрыть драйвер, если что-то пошло не так
while condition == 1:
for host in hosts:
journey_length = np.random.poisson(5)
user_type = choice(keywords.keys(), 1)[0]
print user_type
user_journey(host, journey_length, keywords, user_type, conformity)
```
Что мы сделали? Мы генерируем пользователей разного типа. Здесь указаны два (на самом деле их больше): меломан и человек, желающий разобраться в грамматике. Выбор типа выбирается рандомно.
Внутри типа мы тоже внедрили элемент случайности: пользователь одного типа не будет ходить по одним и тем же ссылками, которые бы мы прямо захардкодили, а ссылка будет выбираться рандомно из подмножества «правильных» ссылок + есть еще элемент случайности, когда пользователь будет попадать на «неправильные» ссылки. Это было сделано, потому что в будущем участники будут анализировать эти данные и пробовать как-то сегментировать этих пользователей.
Помимо этого, чтобы прям вообще было похоже на реальное пользовательское поведение, мы внедрили рандомное время ожидания на странице. И эта пушка стреляет пока мы её не остановим.
Единственное, что группу в 20-30 человек с такой пушкой быстро не обработаешь, поэтому мы решили запускать этот скрипт через [gnu parallel](https://www.gnu.org/software/parallel/). Такая строчка позволяет запустить наш скрипт параллельно на всех доступных ядрах:
```
$ parallel -j0 python ::: cannon.py
```
### Итог
1. Каждый участник поднимает у себя выданный нами сайт при помощи nginx.
2. Присылает нам ip-адрес своего сервера.
3. Внедряет на все страницы своего сайта javascript для сбора кликов.
4. Собирирает данные, прилетающие из нашей пушки на его сайт.
5. Передает в Kafka.
6. Ну и дальше по пайплайну...
Так начинается проект, над которым он будет работать в течение 6 недель на [программе Data Engineer](https://goo.gl/2zxBzW). | https://habr.com/ru/post/334756/ | null | ru | null |
# Tests vs. Types — Rust version
A few days ago [0xd34df00d](https://habr.com/ru/users/0xd34df00d/) has published the translation of the [article](https://kevinmahoney.co.uk/articles/tests-vs-types), describing the possible information about some function if we use it as a "black box", not trying to read its implementation. Of course, this information is quite different from language to language; in the original article, four cases were considered:
* Python — dynamic typing, almost no information from signature, some hints are gained by the tests;
* C — weak static typing, a little more information;
* Haskell — strong static typing, with pure functions by default, a lot more information;
* Idris — dependent typing, compiler can prove the function correctness.
"Here's C and there's Haskell, and what about Rust?" — this was the first question in the following discussion. The reply is here.
Let's first recall the task:
> Given a list of values and a value, return the index of the value in the list or signify that it is not present in the list.
If someone don't want don't want to read this all, the code examples are provided in the [Rust playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=3fc9cc183531335eb63b31858ac2f226).
Otherwise, let's start!
#### Simple search
The first approach will be the almost naive signature, differing from the C code only in some idiomatic elements:
```
fn foo(x: &[i32], y: i32) -> Option {
// Implementation elided
}
```
What do we know about this function? Well, in fact — not very much. Of course, `Option` as a return value is a great improvement over whatever is provided by C, but there's no information about the function semantics. In particular, we have no guarantee of the side-effects being absent and no way to somehow check the desired behaviour.
Can a test improve this? Look here:
```
#[test]
fn test() {
assert_eq!(foo(&[1, 2, 3], 2), Some(1));
assert_eq!(foo(&[1, 2, 3], 4), None);
}
```
Nothing more, it seems — all these checks can be just the same in Python (and, in anticipation, tests will be of little help for the whole article).
#### Use the generics, Luke!
But is it any good that we have to use only 32-bit signed numbers? Fixing it:
```
fn foo(x: &[El], y: El) -> Option
where
El: PartialEq,
{
// Implementation elided
}
```
Well, that's something! Now we can take any slice, consisting of elements of any comparable type. Explicit polymorphism is almost always better that implicit (hello, Python) and almost always better then no polymorphism at all (hello, C), right?
Although, this function might unexpectedly pass this test:
```
fn refl(el: El) -> Option {
foo(&[el], el) // should always return Some(0), right?
}
#[test]
fn dont\_find\_nan() {
assert\_eq!(refl(std::f64::NAN), None);
}
```
This hints on the one missing point, since the specification wants the `refl` function, in fact, to always return `Some(0)`. Of course, this is all due to the specific behaviour of the partially-equivalent types in general and floats in particular.
Maybe we want to get rid of this problem? So, we'll simply tighten the bound on the El type:
```
fn foo(x: &[El], y: El) -> Option
where
El: Eq,
{
// Implementation elided
}
```
Now, we're requiring not only the type to be comparable, — we require this comparisons to be [equivalences](https://en.wikipedia.org/wiki/Equivalence_relation). This, of course, limits the possible types to use with this function, but now both the signature and the tests hint that the behaviour should fit into the specification.
**Side note: we want to go MORE generic!**This case has no relation to the initial task, but this seems to be a good example of the well-known principle: "be liberal in what you accept, be conservative in what you do". In other words: if you can generalize the input type without harming the ergonomics and performance — you probably should do it.
Now, we'll check this:
```
fn foo<'a, El: 'a>(x: impl IntoIterator, y: El) -> Option
where
El: Eq,
{
// Implementation elided
}
```
What do we know about this function now? In general, all the same, but now it accepts not only the slice or list, but some arbitrary object, which can yield the references to the type El, so that we compare it with the object in question. For example, if I'm not mistaken, in Java this type would be `Iterable`.
#### Like before, but a bit more strict
But now, maybe we need some more guaranties. Or we want to work on the stack (and so can't use `Vec`), but need to generalize our code for every possible array size. Or we want to compile the function optimized for every concrete array size.
Anyway, we need a generic array — and there's a crate in Rust, providing [exactly that](https://crates.io/crates/generic-array).
Now, here's our code:
```
use generic_array::{GenericArray, ArrayLength};
fn foo(x: GenericArray, y: El) -> Option
where
El: Eq,
Size: ArrayLength,
{
// Implementation elided
}
```
What do we know from it? We know that function will take the array of some particular size, reflected in its type (and will be compiled independently for each such size). For now, this is almost nothing — the same guarantees were provided at runtime by the previous implementation.
But we can get further.
#### Type-level arithmetic
The initial article mentioned several guarantees provided by Idris which were impossible to get from other languages. One of them — and probably the simplest, since it doesn't involve any proofs or tests, just a little change in types, — states that the return value, if it's not `Nothing`, will always be less then the list length.
Looks like that the dependent types — or something like them — are necessary for such guarantee, and we can't get the same from Rust, right?
Meet the [typenum](https://crates.io/crates/typenum). Using it, we can write our function in the following way:
```
use generic_array::{ArrayLength, GenericArray};
use typenum::{IsLess, Unsigned, B1};
trait UnsignedLessThan {
fn as\_usize(&self) -> usize;
}
impl UnsignedLessThan for Less
where
Less: IsLess,
Less: Unsigned,
{
fn as\_usize(&self) -> usize {
::USIZE
}
}
fn foo(x: GenericArray, y: El) -> Option>>
where
El: Eq,
Size: ArrayLength,
{
// Implementation elided
}
```
"What is this black magic?!" — you could ask. And you're right: typenum *is* a black magic, and any attempts to use it are even more magic.
But this function signature is fairly concrete.
* It takes an array of El's with the length Size and one more El.
* It returns an Option, which, if it is Some,
+ holds a [trait object](https://doc.rust-lang.org/1.29.2/book/2018-edition/ch17-02-trait-objects.html), based on the `UnsignedLessThan` trait;
+ and the `UnsignedLessThan` is implemented wherever `Unsigned` and `IsLess` are implemented and `IsLess` returns B1, i.e. true.
In other words, this function is *guaranteed* to return unsigned integer *less than* the array size (strictly speaking, it returns the trait object, but we can call `as_usize` method and get the integer).
I can now speak of two major caveats:
1. We can get a loss of performance. If somehow this function will be on the "hot" path of the program, the constant dynamic dispatches might slow down the whole process. This might not be a large concern, in fact, but there's another:
2. For this function to compile, we must either write the proof of its correctness right inside it, or trick the type system with some `unsafe`. The former is fairly complex, and the latter is just cheating.
#### Conclusion
Of course, in practice we'll generally use either the second approach (with generic slice) or the approach in spoiler (with iterator). All subsequent discussion is probably not of any practical interest and is here only as an exercise with types.
Anyway, the fact that the Rust type system can emulate the feature from the stronger Idris type system, as for me, is fairly impressive by itself. | https://habr.com/ru/post/468271/ | null | en | null |
# Открыта регистрация на КИБоРИФ
Наконец-то открыта [регистрация](http://ok2009.ru/registration/) на объединённую конференцию по вопросам интернета и бизнеса в России. Регистрируйтесь и приезжайте. Будет приятно пообщаться!
` `Объединенная конференция РИФ+КИБ — главное профильное мероприятие Рунета — пройдет в подмосковном пансионате «Лесные дали» с 22 по 24 апреля 2009 года. | https://habr.com/ru/post/54879/ | null | ru | null |
# Ускоряем Dart. Нативно, недорого
Релиз [Dart 2.12](https://medium.com/dartlang/announcing-dart-2-12-499a6e689c87) принёс, помимо всего прочего, [поддержку FFI](https://dart.dev/guides/libraries/c-interop) в стабильной версии, что позволит относительно легко добавить биндинги к своим любимым библиотекам, которые используют сишный ABI для экспорта. А это позволяют сделать в том числе и Rust, Go, Swift и другие.
---
Считаем логарифмы
-----------------
Для начала попробуем написать синтетический код на чистом Dart, который будет выполняться относительно долго, но не слишком. Например, посчитаем сто миллионов логарифмов.
Забегая вперёд, скажу что такой подход выбран, чтобы скомпилировать эквивалентный код на C так, чтобы компилятор его не вырезал в попытках оптимизации.
```
import 'dart:math';
// считаем n логарифмов функцией из стандартной библиотеки
double log_loop(int n) {
double l = 0;
for (int i = 0; i < n; i++) {
l = log(i);
}
return l;
}
```
Чтобы проверить результат, напишем минимальную функцию `main`, которая замеряет время выполнения
```
var w = Stopwatch()..start();
double result = log_loop(100000000);
print('${w.elapsed.inMilliseconds}');
```
Запустив полученный код без компиляции, используя `dart run`, узнаем что расчёты выполнялись **10.05 секунд**.
*Конфигурацию системы, на которой происходило тестирование, сознательно нe привожу. Цели провести качественный бенчмарк в абсолютных значениях не было, и далее будут иметь значение только относительные показатели.*
Можно ли лучше? В принципе да. Выполняем `dart compile exe` и получаем ускорение на 10% или **9.00 секунд**.
Идём за горизонт событий
------------------------
Если для вас 10 секунд - это слишком долго, можно попробовать пострелять себе в ноги.
Пишем эквивалентный код на C, используя `log` из . Здесь и далее подразумевается, что `log` входит в состав libm из glibc, а код компилируется GCC 9.1.
```
// log_loop.c
#include
double log\_loop(int n) {
double l = 0;
for (int i = 0; i < n; i++) {
l = log(i);
}
return l;
}
```
Видите разницу? И я не вижу. Поэтому тоже сделаем небольшую обёртку чтобы замерить время, за которое посчитает реализация на C. Предполагаем, что код `log_loop.c` просто входит в состав `main.c` и функция `main` содержит следующий код:
```
clock_t ts = clock();
double result = log_loop(100000000);
printf("%.2f\n", 1000.0*(clock() - ts)/CLOCKS_PER_SEC);
```
Компилируя в обычный ELF при помощи `gcc -o main -lm main.c` увидим, что полученный бинарник выполняет свои действия за **1.69 секунд**.
Не мудрствуя лукаво, сразу пробуем скомпилировать с уровнями оптимизации `O3`, `O2` и `O1`:
* `03` - 0.822 с
* `02` - 0.832 с
* `01` - 0.834 с
Как видно, разница не слишком большая, поэтому далее ограничимся рассмотрением только уровней `O3` и `O0`.
### Стыкуемся
Перед тем, как использовать `dart:ffi` попробуем проверить, несёт ли какие-то накладные расходы подключение библиотек без использования FFI, непосредственно из кода на C, для которого сишные библиотеки совсем не *инородные*.
В наш `main.c` добавим объявление `double log_loop(int)` вместо реализации, описанной выше.
Предварительно компилируем `log_loop.c` в объектный файл через `gcc -c -o log_loop.o log_loop.c` и далее:
* `ar rcs liblog_loop.a log_loop.o` — для компиляции в статически линкуемый архив
* `gcc -L. -o main -lm -llog_loop main.c` — для сборки бинарника
В результате получим **1.69 секунд** для `O0` и **0.83 секунд** для `O3`.
Для разделяемых библиотек процесс примерно такой же. Отмечу, что эти же библиотеки и будут использоваться для подключения через `dart:ffi`:
* `gcc -shared -o liblog_loop.so log_loop.o` — для получения динамической библиотеки
* `gcc -L. -o main -lm -llog_loop main.c` — для сборки бинарника
Для запуска приложению будет нужна `log_loop.so` поэтому будем использовать `LD_LIBRARY_PATH=.`.
Здесь результаты примерно такие же: **1.70 секунд** для `O0` и **0.83 секунд** для `O3`.
### Начинаем рисковать
Чтобы использовать библиотеку через FFI, её надо подключить в рантайме. Используем для этого `dlopen`.
В код библиотеки никаких изменений не вносим, а вот процесс подключения библиотеки в исполняемом файле существенно меняется:
```
#include
// предполагаем, что ошибок не будет, поэтому для простоты пропускаем всю обработку
void \*loader;
if ((loader = dlopen("liblog\_loop.so", RTLD\_NOW)) == NULL) // в конце нужно не забыть про dlclose(loader)
return 1;
double (\*log\_loop)(int);
\*(void \*\*)(&log\_loop) = dlsym(l, "log\_loop");
// аналогичным образом замеряем производительность
```
И в этом случае показатели абсолютно не меняются: **1.69 секунд** для `O0` и **0.83 секунд** для `O3`.
### Небольшой итог
Независимо от того, каким образом вычисляющий метод попадает в бинарник - будь то `dlopen`, статическая или динамическая библиотека, непосредственно подключение библиотеки на время выполнения значительным образом не влияет, поэтому за базовую величину для дальнейшего сравнения примем, соответственно, **1.69 секунд** для `O0` и **0.83 секунд** для `O3`.
Поехали
-------
Ну штош, приступим к тому, для чего так долго готовились.
### Готовим неправильно
Как мы помним, 10 секунд нас не устраивают и мы хотим быстрее. Раз функция `log` есть в `libm`, то попробуем оттуда её и взять.
Функцию `main` в нашем dart-коде оставим неизменной, а вот вычислительный метод будет таким:
```
import 'dart:ffi';
typedef LogFFI = Double Function(Double);
typedef Log = double Function(double);
double log_loop(int n) {
final libm = DynamicLibrary.open("/lib/.../libm.so"); // путь зависит от libc
double l = 0;
for (int i = 0; i < n; i++) {
final log = libm.lookup>('log').asFunction();
l = log(i \* 1.0);
}
return l;
}
```
Принцип подключения разделяемых библиотек в Dart похож на работу с `dlopen`, но более типобезопасен. Здесь мы описываем сигнатуру для нативной функции `double log(double)`из `libm.so` через типы `dart:ffi` и приводим её к функции со встроенными типами Dart.
Получаем, что теперь наш код выполняется за **70 секунд** в скомпилированном виде и **75 секунд** через `dart run`, что в 7 раз медленнее чем реализация на основе `dart:math`.
Поиск и преобразование функции делать во время выполнения критичных операций не стоит. В синтетическом примере это довольно очевидная ошибка, но по невнимательности её допустить довольно просто.
Перепишем функцию по-нормальному, вынеся `lookup` за пределы цикла:
```
double log_loop(int n) {
final libm = DynamicLibrary.open("/lib/.../libm.so"); // путь зависит от libc
final log = libm.lookup>('log').asFunction();
double l = 0;
for (int i = 0; i < n; i++) {
l = log(i \* 1.0);
}
return l;
}
```
После таких манипуляций получим **2.96 секунд** в скомпилированном виде и **3.08 секунд** через `dart run`. Это в 3 раза быстрее оригинальной реализации, но всё же пока что примерно в 3.5 раза медленнее, чем самая быстрая нативная реализация на C.
### Делаем хорошо
Раз мы уже имеем скомпилированные библиотеки, почему бы не взять готовое? Справедливое заключение, поэтому так и сделаем, подключив вместо `libm` готовую реализацию `log_loop` на C. Сначала определим типы для функции:
```
import 'dart:ffi';
// В Dart нет типа Int для нативных функций, поэтому пользуемся тем что есть
typedef LogLoopFFI = Double Function(IntPtr);
typedef LogLoop = double Function(int);
```
Код вычисления времени выполнении остаётся аналогичным самому первому примеру, за исключением предварительной работы по подключению библиотеки. Для этого в начале функции `main` просто добавим следующее (предполагая, что библиотеку мы расположили в директории `lib/`):
```
final loader = DynamicLibrary.open("lib/liblog_loop.so");
final log_loop = loader.lookup>('log\_loop').asFunction();
```
Для библиотеки, скомпилированной с уровнем оптимизаций `O3` получим **0.83 секунды** для скомпилированного файла и **0.86 секунд** для `dart run`.
Как можно заметить, это ничем не отличается от нативной реализации, примерно в 10 раз быстрее, чем нативная реализация на Dart и в 2.5 раза эффективнее вызова `log`напрямую из `libm`.
Большой итог
------------
Закругляясь, для наглядности приведу сводную табличку с результатами всех тестов:
| | | | |
| --- | --- | --- | --- |
| **Среда** | **-O** | **exe** | **Время, сек** |
| **C** | 0 | **+** | 1.69 |
| **3** | **0.82** |
| С (shared) | 0 | 1.70 |
| 3 | 0.83 |
| C (static) | 0 | 1.69 |
| 3 | 0.83 |
| C (dlopen) | 0 | 1.69 |
| 3 | 0.83 |
| **Dart** | | **+** | **9.00** |
| - | 10.1 |
| Dart (libm, loop lookup) | | + | 70.2 |
| - | 75.8 |
| Dart (libm, fixed) | | + | 2.96 |
| - | 3.07 |
| Dart (ffi) | 0 | + | 1.71 |
| - | 1.72 |
| **Dart (ffi)** | **3** | **+** | **0.83** |
| - | 0.86 |
Как можно заметить, при правильном подходе среда выполнения практически не оказывает влияние на производительность при работе с FFI. При этом, несмотря на то, что вызов `log` через FFI ускоряет выполнение, хорошо видно влияние интерфейса между Dart и C.
При сравнении с реализацией на C получим что на каждый вызов `log` Dart тратит дополнительно (2.96-0.83)×1e8/1e9 = 0.213 нс на каждую итерацию. Считая, что каждая операция выполняется за 0.82×1e8/1e9 = 0.082 нс получаем более чем двукратную разницу.
К счастью, стоимость операции вызова функции постоянна (по крайней мере, для функций с одинаковыми аргументами), поэтому чем больше времени выполняется сторонний код, тем менее заметно будет влияние FFI. Но это ожидаемый исход и в целом такая картина характерна для реализации похожих интерфейсов в других языках.
Стоит, однако, сделать ремарку, что работа со сложными типами вроде структур или передача больших объёмов данных через указатели, преобразование строк из `Utf8Pointer` и т. д. безусловно приведут к дополнительному оверхеду. В качестве бонуса отмечу существование пакета [ffigen](https://pub.dev/packages/ffigen) для генерации биндингов к библиотекам из сопутствующих заголовочных файлов.
 | https://habr.com/ru/post/547946/ | null | ru | null |
# Визуализация весов в машинном обучении на примере алгоритма Random Forest и Decision Tree
Привет, Хабр!
Меня зовут Александр Серов, я Data Scientist и являюсь участником [профессионального сообщества NTA](https://newtechaudit.ru/). Сегодня загляну «под капот» алгоритмов, использующих в своей основе деревья решений. Один из самых мощных алгоритмов контролируемого машинного обучения на сегодня – градиентный бустинг (Catboost, XBGR), построен на столь казалось легком и базовом элементе, как бинарное дерево, или же дерево решений. Оно является строительным блоком данного алгоритма, в данном случае можно привести притчу про веник и его части, но в этом случае, иногда даже одно дерево решений способно выдать неплохой результат в решениях задач классификации и регрессии. Сегодня я рассмотрю его подробнее, на примере Decision Tree и Random Forest из библиотеки sklearn, а также визуализирую работу.
В практике всегда возникает проблема верного выявления гипотез, в моей работе с этим помогают модели машинного обучения, но и их необходимо контролировать. Визуализация весов - один из способов это сделать.
Обучать и тестировать модели буду на двух наборах данных, взятых из открытого источника - Kaggle.
* [Данные с числовыми признаками для задачи классификации наличия диабета у человека](https://www.kaggle.com/datasets/akshaydattatraykhare/diabetes-dataset).
* [Данные с категориальными признаками для задачи предсказания оценок по математике](https://www.kaggle.com/datasets/whenamancodes/students-performance-in-exams).
### DecisionTree - задача классификации
```
# импортируем набор данных по диабету
import pandas as pd
df_clf = pd.read_csv('../input/pima-indians-diabetes-database/diabetes.csv')
df_clf.head()
```
Начну с задачи классификации. Набор данных основан на определенных диагностических измерениях, ограничен 1000 значений, где были выбраны женщины из индейского племени Пима. Изучим подробное описание каждого признака:
* Pregnancies – количество беременностей;
* Glucose – концентрация глюкозы в плазме крови;
* BloodPressure – дистолическое давление крови;
* SkinThickness – толщина кожи трицепса;
* Insulin – содержания инсулина в крови;
* BMI – индекс массы тела;
* DiabetesPedigreeFunction – показатель функции генетического диабета;
* Age – возраст;
* Outcome – наша целевая переменная, где 0 – нет диабета, 1 – есть.
Цель, как указывалось выше, переменная "Outcome", то есть бинарный признак. В следующем шаге разделим набор данных на тренировочную выборку и тестовую, с пропорциями 71:29 (можете поэкспериментировать с данным показателем, допустим разброс, зависимый от количества данных и их разнообразия).
```
from sklearn.model_selection import train_test_split
target_df_clf = df_clf['Outcome']
feature_df_clf = df_clf.drop(columns=['Outcome'])
X_train_clf, X_test_clf, y_train_clf, y_test_clf = train_test_split(feature_df_clf,
target_df_clf,
test_size=0.29,
random_state=11)
```
После того, как подготовил данные, начну обучение с модели DecisionTreeClassifier. Это всё то же бинарное дерево решений, для автоматического подбора параметров модели используем GridSearchCV. Необходимо для нахождения оптимального решения и оптимизации затрат по времени.
```
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
from sklearn.tree import DecisionTreeClassifier
tree_param = [{'criterion': ['entropy', 'gini'], 'max_depth': [i for i in range(1, 20)],
'min_samples_leaf': [i for i in range(1, 25)],
'max_leaf_nodes': [i for i in range(1, 20)]}]
dtc_model = GridSearchCV(DecisionTreeClassifier(), tree_param, cv=10)
dtc_model.fit(X = X_train_clf.values,
y = y_train_clf)
prediction_clf = dtc_model.best_estimator_.predict(X_test_clf)
score = accuracy_score(y_test_clf, prediction_clf)
print(f'Лучшие найденные параметры: {dtc_model.best_estimator_}')
print(f'Точность на тренировочных данных: {round(dtc_model.best_score_*100, 2)}')
print(f'Точность на тестовых данных: {round(score*100, 2)}')
```
Точность на тренировочных данных: 74.31
Точность на тестовых данных: 72.65
Полученная точность нашей модели - 72%, что уже довольно неплохо, а это ведь только 1 дерево. К сведению, если применять данную модель в реальных условиях мы можем уменьшить порог для классификации положительного результата (tresholding), так как в жизни ложноположительный результат лучше, чем ложноотрицательный, потому что можно провести углубленные исследование. Но для этой модели сейчас важна абсолютная точность.
Теперь попробуем визуализировать результат и посмотреть, как модель распределяла веса для классификации целевого признака.
```
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
plt.figure(figsize=(15,15))
plot_tree(dtc_model.best_estimator_, filled=True, impurity=True)
```
Нужно добавить немного теории, чтобы понять нашу визуализацию.
Модель выбрала алгоритм работы на основе энтропии:
* Энтропия в свою очередь направлена на максимизацию получения информации. Это можно легко представить, как будто мы угадываем загаданного персонажа. И чтобы как можно быстрее это сделать, нам необходимо сужать круг вариантов как можно больше с каждым вопросом.
Также популярен другой вариант, это коэффициент Gini:
* С индексом Джини в качестве цели дерево выбирает на каждом шаге признак и порог, который будет их разделять.
Но мне больше нравится другой способ визуализации c помощью библиотеки dtreeviz, давайте посмотрим на него.
```
# %pip install dreeviz
from dtreeviz.trees import dtreeviz
image_est = dtreeviz(dtc_model.best_estimator_,
x_data=X_train_clf,
y_data=y_train_clf,
target_name='class',
feature_names=[i for i in X_train_clf.columns],
class_names=['Не диабет', 'Диабет'],
title="Визуализация подбора весов Decision Tree")
image_est.save('dtreeviz.svg')
```
Инфографика процесса представлена более подробно. Видим, как дерево отбирает решения, максимизирует информацию. Глубина дерева получилось всего 3, где задействованы все признаки, а это отличный результат для анализа.
Это действительно полезно, так как можем сравнить полученную информацию с медицинскими гипотезами, подтвердив точность своей модели. Судя из графиков, при высоком уровне сахара в крови - шанс наличия диабета повышен, что совпадает с общепринятыми данными.
#### DecisionTree – задача регрессии
Сейчас предлагаю рассмотреть вариант с задачей регрессии (предсказания). Для этого используем второй набор данных об успеваемости студентов на экзамене. Он состоит из полученных оценок по различным предметам.
* Gender – пол студента;
* Race/ethnicity – этническая группа (данные обезличены);
* Parental level of education – уровень образования родителей;
* Lunch – тип питания;
* Test preparation score – оценка подготовки к экзаменам;
* Math score – оценка по математике;
* Reading score – оценка по чтению;
* Writing score – оценка по письму.
Выберу целевой признак - оценки по математике (math score), метрику - абсолютную ошибку.
Так как данные являются категориальными, необходимо их обработать и перевести в числовой формат, использую для этого LabelEncoder.
```
df_reg = pd.read_csv('../input/students-performance-in-exams/StudentsPerformance.csv')
df_reg.head()
```
```
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df_reg = df_reg.apply(le.fit_transform)
target_df_reg = df_reg['math score']
feature_df_reg = df_reg[[i for i in df_reg.columns if i != 'math score']]
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(feature_df_reg,
target_df_reg,
test_size=0.29,
random_state=11)
```
Обучу модель, применяя аналогичный подход с авто-параметрами.
```
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_absolute_error
tree_param = [{'criterion': ['squared_error', 'friedman_mse', 'absolute_error'],
'max_depth': [i for i in range(1, 20)],
'min_samples_leaf': [i for i in range(1, 25)],
'max_leaf_nodes': [i for i in range(2, 20)],
}]
dtr_model = GridSearchCV(DecisionTreeRegressor(), tree_param, cv=5)
dtr_model.fit(X = X_train_reg.values,
y = y_train_reg)
prediction_reg = dtr_model.best_estimator_.predict(X_test_reg)
score_reg = mean_absolute_error(prediction_reg, y_test_reg)
print(f'Лучшие найденные параметры: {dtr_model.best_estimator_}')
print(f'Средняя абсолютная ошибка на тестовых данных: {round(score_reg, 3)}')
```
Средняя абсолютная ошибка на тестовых данных: 5.722
```
plt.figure(figsize=(15,15))
plot_tree(dtr_model.best_estimator_, filled=True, impurity=True)
```
```
image_est2 = dtreeviz(dtr_model.best_estimator_,
x_data=X_train_reg,
y_data=y_train_reg,
target_name='class',
feature_names=[i for i in X_train_reg.columns],
title="Визуализация подбора весов Регрессии")
image_est2.save('dtreeviz2.svg')
```
Дерево решений получилось глубже, чем в первом случае, так как задача регрессии здесь требует больше данных. Здесь алгоритмом работы бинарного дерева выступала средняя абсолютная ошибка.
По визуализации весов можно сделать несколько выводов:
* Модель в основном задействовала оценки по другим предметам.
* Навыки письма имеют связь с гендером, то есть значительно коррелируют.
* Этническая принадлежность студента не использовалась\*.
* Образование родителей также не влияет на оценки\*.
"\*" - имеют очень малое влияние, поэтому бинарное дерево выбрало другие признаки
Возможно, исключив оценки по другим предметам, были бы задействованы не вошедшие факторы, но пострадала бы и точность предсказания. В моем случае разброс +-6 баллов из 100.
### Random Forest
И настал заключительный момент, проверить визуализации весов на алгоритме случайного леса. Он является ансамблевой моделью, то есть он использует для предсказания переменной несколько моделей внутри себя. В данном случае модель обучает несколько бинарных деревьев (со случайной генерацией random\_seed) и усредняет их показатели, в результате повышается точность.
Обучать буду модель классификации, после чего выведу визуализацию всех деревьев в его ансамбле.
```
def GridSearch_CV_RFС(X_train, y_train):
from sklearn.ensemble import RandomForestClassifier as rfc
estimator = RandomForestClassifier()
param_tree = {
"n_estimators" : [i for i in range(1, 21)],
"max_features" : ["auto", "sqrt", "log2"],
"min_samples_split" : [2,4,8],
"bootstrap": [True, False],
"max_depth": [i for i in range(1, 15)],
'criterion': ['entropy', 'gini'],
'n_jobs': [-1]
}
model_rfc = GridSearchCV(estimator, param_tree, n_jobs=-1, cv=5)
model_rfc.fit(X_train, y_train)
return model_rfc.best_score_ , model_rfc.best_estimator_
def RFR(X_train, X_test, y_train, y_test, best_params):
from sklearn.ensemble import RandomForestRegressor
estimator = RandomForestRegressor(n_jobs=-1).set_params(**best_params)
estimator.fit(X_train,y_train)
y_predict = estimator.predict(X_test)
print ("R2 score:",r2(y_test,y_predict))
return y_test,y_predict
```
```
score, model = GridSearch_CV_RFС(X_train_clf, y_train_clf)
```
```
print(f'Точность на тестовых данных: {round(score*100, 2)}%')
```
Точность на тестовых данных: 77.8%
```
plt.figure(figsize=(10,15))
fn = [i for i in X_train_clf.columns]
cn = ['Диабет', 'Не диабет']
# обозначим набор графиков для вывода нескольких деревьев
fig, axes = plt.subplots(nrows = 1,ncols = 5,figsize = (30,10))
for index in range(0, 5):
# Построение графика 1 дерева, выбираем по индексу из общей модели
plot_tree(model.estimators_[index],
feature_names = fn,
class_names=cn,
filled = True,
ax = axes[index]);
axes[index].set_title('Дерево № ' + str(index+1), fontsize = 11)
fig.savefig('rf_5trees.svg')
```
Как можно увидеть - выросла точность предсказания с 72% до 77%, в общем итоге, в «лесу» 12 бинарных деревьев, в идеале можно вывести каждые из них и проанализировать. Для примера я вывел 5 первых деревьев, чтобы в общем рассмотреть их структуру. Сохранять изображение лучше в векторном формате «svg», чтобы можно было увеличить изображения без потери качества. Анализируя структуру вижу, что увеличилась глубина деревьев, она выросла до 7, также многие из них стали несимметричные (одна из веток имеет значительно больше разветвлений).
### Вывод
Обобщу полученные в ходе работы результаты. Деревья решений - строительный блок более серьёзных и эффективных моделей, поэтому, контролируя его, аналитики повышают общие результаты работы. В нашем случае, визуализация помогает не только выполнять прямое назначение - видеть результаты работы весов внутри обученной модели, но и помогает создавать и подтверждать гипотезы, которые предлагает машинное обучение, как видно на примере классификации диабета. Проделанной работой можно повысить качество любого исследования, а также предоставить специалистам, не работающим с машинным обучением, полезную информацию. | https://habr.com/ru/post/711770/ | null | ru | null |
# Фишинг с поддельным приглашением на встречу
Вы когда-нибудь задумывались о том, как работают приглашения на встречи в Microsoft Teams и Google Meet? Недавно я занимался вопросом социальной инженерии, и у меня в голове возникла случайная мысль: как на самом деле работают приглашения на встречи, можно ли как-то использовать их в мошеннических схемах?
Да, такая мысль уже обсуждалась ранее, и этот метод уже использовали. Но никто нигде не объяснял, как он работает. Мне не удалось найти ни одного блога, который технически описывает эту атаку. Поэтому я решил покопаться в ней сам, чтобы человеческим языком рассказать всем, кто интересуется пентестами и вопросами безопасности в целом.
### Что я хотел сделать в этой атаке?
Отправить поддельное приглашение на встречу, создав ощущение срочности, чтобы жертва не пыталась разобраться в вопросе, а просто перешла по моей ссылке, запрашивающей учётные данные.
Создание встречи (в Outlook) обычно работает следующим образом:
* нажмите кнопку «Новая встреча», после чего откроется страница с полями для электронной почты, предварительно заполненным шаблоном команды и URL-адресом встречи
* установите название встречи и укажите участников
* нажмите «Отправить», и ваши участники получат красивое электронное письмо, в котором они смогут принять или отклонить приглашение на собрание.
Создание встречи в OutlookТак выглядит приглашение на встречу### Что не так с этим приглашением?
Когда вы создаёте приглашение на встречу, вы фактически отправляете обычное электронное письмо с вложенным файлом iCalendar. В зависимости от почтового клиента получателя письма и того, как этот клиент обрабатывает iCalendar, вы можете увидеть красивый email или простое письмо с вложением. Ниже вы можете увидеть, как выглядит приглашение на собрание команды в protonmail.
### Что такое объект iCalendar?
Согласно [Википедии](https://en.wikipedia.org/wiki/ICalendar) :
«*Универсальный формат iCalendar позволяет пользователям хранить и обмениваться информацией своего календаря и расписания (например, события, задачи, информация о свободном/занятом времени). Файл iCalendar сохраняется в текстовом формате и содержит событие или задачу; используется для отправки событий или задач другим пользователям, которые могут импортировать их в свои календари. Обычно имеет расширение .ics*»
iCalendar поддерживается Outlook, календарём Google, Yahoo, Apple и многими другими. В этой статье я сосредоточусь на Outlook.
Ниже вы можете увидеть мою версию iCalendar для приглашения на групповую встречу. Я просто отправил приглашение на встречу на свой адрес в protonmail, загрузил его и прочитал вложение.
```
BEGIN:VCALENDAR
METHOD:REQUEST
PRODID:Microsoft Exchange Server 2010
VERSION:2.0
BEGIN:VTIMEZONE
TZID:GTB Standard Time
BEGIN:STANDARD
DTSTART:16010101T040000
TZOFFSETFROM:+0300
TZOFFSETTO:+0200
RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=10
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:16010101T030000
TZOFFSETFROM:+0200
TZOFFSETTO:+0300
RRULE:FREQ=YEARLY;INTERVAL=1;BYDAY=-1SU;BYMONTH=3
END:DAYLIGHT
END:VTIMEZONE
BEGIN:VEVENT
ORGANIZER;CN=ExAndroid Developer:mailto:@outlook.com
ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=NEEDS-ACTION;RSVP=TRUE;CN=@protonmail.com:mailto:@protonmail.com
DESCRIPTION;LANGUAGE=en-US:\n\n
UID:040000008200E00074C5B7101A82E00800000000508CC0468E28D701000000000000000
01000000096DF011F20A29943A70B5DA5047021A5
SUMMARY;LANGUAGE=en-US:Test meeting
DTSTART;TZID=GTB Standard Time:20210403T000000
DTEND;TZID=GTB Standard Time:20210404T000000
CLASS:PUBLIC
PRIORITY:5
DTSTAMP:20210403T103619Z
TRANSP:OPAQUE
STATUS:CONFIRMED
SEQUENCE:0
LOCATION;LANGUAGE=en-US:Microsoft Teams Meeting
X-MICROSOFT-CDO-APPT-SEQUENCE:0
X-MICROSOFT-CDO-OWNERAPPTID:-570210331
X-MICROSOFT-CDO-BUSYSTATUS:TENTATIVE
X-MICROSOFT-CDO-INTENDEDSTATUS:BUSY
X-MICROSOFT-CDO-ALLDAYEVENT:FALSE
X-MICROSOFT-CDO-IMPORTANCE:1
X-MICROSOFT-CDO-INSTTYPE:0
X-MICROSOFT-SKYPETEAMSMEETINGURL:https://teams.microsoft.com/l/meetup-join/
19%3ameeting\_YmM1MjRmMTktYjA2Ncd8%22%7d
X-MICROSOFT-SCHEDULINGSERVICEUPDATEURL:https://api.scheduler.teams.microsof
t.com/teams/dcDAyMmZj@thread.v2/0
X-MICROSOFT-SKYPETEAMSPROPERTIES:{"cid":"19:meeting\_YmM1MjRmMTktYjA2Ny00YWQ
4LWI1NWEtZmE1NGVlMDAyMmZj@thread.v2"\,"private":true\,"type":0\,"mid":0\,"
rid":0\,"uid":null}
X-MICROSOFT-ONLINEMEETINGCONFLINK:conf:sip:\;gruu\;opaque=
app:conf:focus:id:teams:2:0!19:meeting\_YmM1MjRmMTktYjA2Ny00YWQ4LWI1NWEtZmE
1NGVlMDAyMmZj-thread.v2!56474ffc245241c5ab4081a127cc1cd8!dcf23acb18fc41d28
6acf752f1ca658d
X-MICROSOFT-DONOTFORWARDMEETING:FALSE
X-MICROSOFT-DISALLOW-COUNTER:FALSE
X-MICROSOFT-LOCATIONS:[ { "DisplayName" : "Microsoft Teams Meeting"\, "Loca
tionAnnotation" : ""\, "LocationSource" : 0\, "Unresolved" : false\, "Loca
tionUri" : "" } ]
BEGIN:VALARM
DESCRIPTION:REMINDER
TRIGGER;RELATED=START:-PT15M
ACTION:DISPLAY
END:VALARM
END:VEVENT
END:VCALENDAR
```
Здесь нужно понимать, что каждый объект iCalendar начинается с `BEGIN: VCALENDAR` и заканчивается `END: VCALENDAR` . Часть встречи находится между `BEGIN: VEVENT` и `END: VEVENT`. Внутри вашего мероприятия вы указываете так называемые компоненты. Обычно требуются не все компоненты, и в моем POC вы можете найти урезанный файл \*.ics с только необходимыми компонентами. Большинство из них самоочевидны, но я отмечу самые интересные из них.
**ORGANIZER**. Указывает имя и адрес электронной почты организатора встречи. Вы можете указать здесь любой email и имя, чтобы казалось, что приглашение на собрание исходит от этого человека.
**ATTENDEE**. Указывает участников встречи. Если вам нужно много участников, у вас будет несколько компонентов ATTENDEE. Имейте в виду, что участники не получат электронное письмо с приглашением на собрание, оно предназначено только для отображения. Вы можете легко имитировать присутствие 30 человек на собрании, если на самом деле отправляете электронное письмо одной жертве.
**X-MICROSOFT-SKYPETEAMSMEETINGURL. Е**сли вы укажете этот компонент, в напоминании о встрече будет отображаться кнопка «Подключиться». К сожалению, при нажатии система попытается открыть указанный URL-адрес через приложение для рабочих столов, что приводит к ошибке.
**DTSTART, DTSTAMP**, **DTEND**. Указывают время встречи и её продолжительность. Я проделал хитрый трюк и установил время начала встречи на 5 минут раньше текущего времени, таким образом складывается ощущение, что вы опоздали на встречу на 5 минут. Когда жертва получает email, Outlook обрабатывает его как приглашение на встречу. Видит, что встреча началось 5 минут назад, и сразу же отображает напоминание на экране. Это помогает симулировать срочность.
Как вы думаете, сколько человек в разгар рабочего дня кликнули бы по ссылке, видя, что опаздывают на встречу?
В этой статье я показал, как Outlook обрабатывает приглашения на собрания. Это должно работать с любым провайдером/клиентом email-сообщений, который обрабатывает вложения \*.ics. Вы можете проверить мой POC на [github](https://github.com/ExAndroidDev/fakemeeting/) и отредактировать скрипт и шаблоны в соответствии со своими потребностями.
---
**Что ещё интересного есть в блоге**[**Cloud4Y**](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)
→ [Частые ошибки в настройках Nginx, из-за которых веб-сервер становится уязвимым](https://habr.com/ru/company/cloud4y/blog/547164/)
→ [Пароль как крестраж: ещё один способ защитить свои учётные данные](https://habr.com/ru/company/cloud4y/blog/541348/)
→ [Облачная кухня: готовим данные для мониторинга с помощью vCloud API и скороварки](https://habr.com/ru/company/cloud4y/blog/555722/)
→ [Подготовка шаблона vApp тестовой среды VMware vCenter + ESXi](https://habr.com/ru/company/cloud4y/blog/542000/)
→ [VMware предупредила о критических уязвимостях в удаленном исполнении кода в vCenter](https://habr.com/ru/company/cloud4y/news/t/559332/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/562780/ | null | ru | null |
# PHPUnit. Автоматические тесты
*Предисловие переводчика:
Недавно начал изучать PHPUnit (framework семейства [xUnit](http://www.smartyit.ru/testing/82)) и с удивлением обнаружил, что на русском языке нет статей про автоматические тесты для самых-самых чайников.
В первой главе документации по PHPUnit на примерах очень доступно рассказывается, что такое автоматическое тестирование.*
Даже хорошие программисты допускают ошибки. Разница между хорошим программистом и плохим заключается в том, что хороший программист как можно чаще использует тесты, чтобы найти свои ошибки.
Чем раньше Вы начнете тестировать, тем выше Ваши шансы найти ошибку, и тем ниже цена исправления.
Это объясняет, почему откладывание тестирования до момента передачи программы заказчику является очень плохой практикой. Большинство ошибок так и не будет найдено, а цена исправления станет такой высокой, что Вам придется составить большой график работы, т.к. сразу Вы не сможете их все исправить.
Тестирование при помощь PHPUnit принципиально не отличается от того тестирования, которое Вы уже выполняете. Это просто другой подход к работе. Разница заключается в следующем: в одном случае Вы просто *проверяете*, что Ваша программа работает как ожидается, в другом — Вы *выполняете серию тестов*, которые представляют собой выполняемые фрагменты кода для автоматической проверки корректности частей (модулей) программного обеспечения.
Эти выполняемые фрагменты кода называются модульными (Unit) тестами.
В этой статье мы проделаем путь от элементарного теста, который просто выводит на экран результат своей работы до полностью автоматизированного теста.
Допустим, нас попросили протестировать встроенный в PHP массив (`array`). На одном из этапов тестирования надо проверить работу функции `count()`. Мы ожидаем, что для только что созданного массива функция `count()` вернет 0. После добавления элемента в массив `count()` должна вернуть `1`.
Пример 1.1 демонстрирует, что мы хотим проверить.
**Пример 1.1: Тестирование операторов массива**
> `php<br$fixture = array();` | https://habr.com/ru/post/87922/ | null | ru | null |
# Настройка сетевого оборудования компании HUAWEI (коммутация, статическая маршрутизация)
HUAWEI – одна из крупнейших китайских компаний в сфере телекоммуникаций. Основана в 1988 году.
Компания HUAWEI достаточно недавно вышла на российский рынок сетевого оборудования уровня Enterprise. С учётом тенденции тотальной экономии, на нашем предприятии очень остро встал вопрос о подборе достойной замены оборудованию Cisco.
В статье я попытаюсь рассмотреть базовые аспекты настройки сервисов коммутации и маршрутизации оборудования HUAWEI на примере коммутатора Quidway серии 5300.
#### Глобальные команды, режимы работы, cходства и различия с CLI CISCO.
Оборудование HUAWEI, построенное на базе операционной системы VRP, имеет cisco-like интерфейс командной строки. Принципы остаются теми же самыми, меняется только синтаксис.
В CLI оборудования HUAWEI существуют 2 режима командного интерфейса:
1. system-view – аналог цисковского режима конфигурирования conf t. В этом режиме приглашение командной строки выглядит как [Switch].
2. user-view – аналог цисковского непривилегированного режима. Режим приглашения выглядит так: .
В отличие от непривилегированного режима Cisco из user-view доступны многие функции, в частности можно ресетнуть запущенные процессы. Подключения по telnet и ssh так же доступны только из user-view.
После некоторых претензий со стороны компании Cisco Systems, в ОС VRP были заменены часть служебных слов. Таблица соответствия некоторых служебных слов CLI представлена ниже.
| **Cisco** | **HUAWEI** |
| --- | --- |
| show | display |
| running-configuration | current-configuration |
| clear | reset |
| configure terminal | system-view |
| write | save |
| quit | exit |
| no | undo |
##### Основные команды:
* system-view – переход из user-view в привилегированный режим system-view;
* save – запись текущих настроек в энергонезависимую память устройства;
* display current-configuration – вывод текущего файла конфигурации
* display current-configuration configuration XXXX – вывод настроек секции XXXX.
* display this – вывод конфигурации текущей секции;
* quit – выход из текущей секции в родительскую.
#### Настройка vlan интерфейсов, режимы работы физических портов коммутатора
##### Создание vlan
Для создания vlan как сущности, на коммутаторе в режиме system-view выполняется команда vlan XXX, где XXX – номер vlan.
```
system-view
Enter system view, return user view with Ctrl+Z.
[Quidway]vlan
[Quidway]vlan 1
[Quidway-vlan1]
```
Vlan создан. Так же командой description можно задать описание или название vlan. В отличие от Cisco имя не является обязательным атрибутом при создании vlan.
Для передачи созданых vlan в пределах локальной сети используется протокол GVRP. Включается он командой gvrp в режиме system-view.
```
[Quidway]gvrp
Info: GVRP has been enabled.
[Quidway]
```
Так же gvrp должен быть разрешён на интерфейсе:
```
#
interface GigabitEthernet0/0/23
port link-type trunk
port trunk allow-pass vlan 100 to 200
gvrp
#
```
Совместимости с Cisco VTP (vlan transfer protocol) нет и быть не может.
##### Создание vlan интерфейса.
```
system-view
Enter system view, return user view with Ctrl+Z.
[Quidway]int vlanif 1
[Quidway-Vlanif1]ip address 2.2.2.2 24
[Quidway-Vlanif1]display this
#
interface Vlanif1
ip address 2.2.2.2 255.255.255.0
#
return
[Quidway-Vlanif1]
```
В отличие от Cisco, маску можно писать сокращённо. Очень удобно.
Думаю, что комментарии излишни.
##### Режимы работы портов
Собственно, ничего нового. Существуют два основных режима работы порта: access и trunk.
Режим trunk
Настройка порта:
```
system-view
Enter system view, return user view with Ctrl+Z.
[Quidway]int gi0/0/1
[Quidway-GigabitEthernet0/0/1]port link-type trunk
[Quidway-GigabitEthernet0/0/1]port trunk allow-pass vlan 1
[Quidway-GigabitEthernet0/0/1]di th
#
interface GigabitEthernet0/0/1
port link-type trunk
port trunk allow-pass vlan 100 900
#
return
```
В отличие от коммутаторов Cisco, по-умолчанию, все vlan запрещены и их необходимо принудительно разрешить командой port trunk allow-pass vlan.
Нетэггированный native vlan на порту включается командой:
```
[Quidway-GigabitEthernet0/0/1]port trunk pvid vlan 600
```
Режим access
```
[Quidway-GigabitEthernet0/0/1]port link-type access
[Quidway-GigabitEthernet0/0/1]port default vlan 2
[Quidway-GigabitEthernet0/0/1]di th
#
interface GigabitEthernet0/0/1
port link-type access
port default vlan 2
#
return
```
##### Настройка eth-trunk
```
interface Vlanif100
ip address 1.1.1.2 255.255.255.252
#
interface GigabitEthernet0/0/23
eth-trunk 1
#
interface GigabitEthernet0/0/24
eth-trunk 1
#
interface Eth-Trunk0
port link-type trunk
port trunk allow-pass vlan 100
#
```
Комментарии излишни.
#### Настройка STP
Для тестирование STP были соединены коммутаторы Cisco 2960 и HUAWEI Quidway S5328C-EI.
Для включения STP на коммутаторе необходимо в режиме system-view ввести команду
```
[Quidway] stp enable
```
По умолчанию, приоритет коммутатора HUAWEI, так же как и коммутатора Cisco равен 32768.
Просмотр информации о текущем состоянии портов:
```
[Quidway]display stp brief
MSTID Port Role STP State Protection
0 GigabitEthernet0/0/1 ALTE DISCARDING NONE
0 GigabitEthernet0/0/2 ROOT FORWARDING NONE
```
Видно, что один из портов заблокирован, т. к. приоритет коммутатора Cisco оказался больше.
Просмотр глобальной информации об STP:
```
[Quidway]disp stp
-------[CIST Global Info][Mode STP]-------
CIST Bridge :32768.781d-baa4-b6a7
Config Times :Hello 2s MaxAge 20s FwDly 15s MaxHop 20
Active Times :Hello 2s MaxAge 20s FwDly 15s MaxHop 20
CIST Root/ERPC :8192 .2893-fe2a-9a80 / 199999
CIST RegRoot/IRPC :32768.781d-baa4-b6a7 / 0
CIST RootPortId :128.2
BPDU-Protection :Disabled
TC or TCN received :107
TC count per hello :0
STP Converge Mode :Normal
Share region-configuration :Enabled
Time since last TC :0 days 1h:16m:17s
Number of TC :9
Last TC occurred :GigabitEthernet0/0/2
```
Изменим приоритет коммутатора HUAWEI. Сделаем его наименьшим: 4096.
```
[Quidway]stp priority 4096
```
Посмотрим, что порт разблокировался:
```
[Quidway]disp stp brief
MSTID Port Role STP State Protection
0 GigabitEthernet0/0/1 DESI FORWARDING NONE
0 GigabitEthernet0/0/2 DESI FORWARDING NONE
[Quidway]
```
Общая информация об STP:
```
[Quidway]disp stp
-------[CIST Global Info][Mode STP]-------
CIST Bridge :4096 .781d-baa4-b6a7
Config Times :Hello 2s MaxAge 20s FwDly 15s MaxHop 20
Active Times :Hello 2s MaxAge 20s FwDly 15s MaxHop 20
CIST Root/ERPC :4096 .781d-baa4-b6a7 / 0
CIST RegRoot/IRPC :4096 .781d-baa4-b6a7 / 0
CIST RootPortId :0.0
BPDU-Protection :Disabled
TC or TCN received :123
TC count per hello :0
STP Converge Mode :Normal
Share region-configuration :Enabled
Time since last TC :0 days 0h:0m:44s
Number of TC :11
Last TC occurred :GigabitEthernet0/0/1
```
##### Статическая маршрутизация
Статические маршруты прописываются точно так же, как на оборудовании Cisco:
```
[Quidway]ip route 0.0.0.0 0.0.0.0 1.1.1.1
```
Просмотр таблицы маршрутизации:
```
[Quidway]disp ip routing-table
Route Flags: R - relay, D - download to fib
------------------------------------------------------------------------------
Routing Tables: Public
Destinations : 6 Routes : 6
Destination/Mask Proto Pre Cost Flags NextHop Interface
2.2.2.0/24 Direct 0 0 D 2.2.2.2 Vlanif1
2.2.2.2/32 Direct 0 0 D 127.0.0.1 Vlanif1
10.0.0.3/32 Direct 0 0 D 127.0.0.1 LoopBack0
90.0.0.1/32 Direct 0 0 D 127.0.0.1 LoopBack10
127.0.0.0/8 Direct 0 0 D 127.0.0.1 InLoopBack0
127.0.0.1/32 Direct 0 0 D 127.0.0.1 InLoopBack0
```
На этом всё.
Если уважаемое сообщество заинтересуется материалом, планирую продолжить освещать настройку оборудования HUAWEI. В следующей статье рассмотрим настройку динамической маршрутизации.
Спасибо за внимание. | https://habr.com/ru/post/153401/ | null | ru | null |
# Парсинг Яндекс Карт или как найти целевую аудиторию
Всем привет, меня зовут Стешенко Артем. Я работаю в Data Science и также занимаюсь небольшим проектом по разработке страниц (или мультиссылок) для самозанятых.
Бизнес-задача
-------------
Перед тем как перейти к парсингу Яндекс Карт, расскажу, какую задачу я хотел решить.
Я решил узнать, **кто является целевой аудиторией для сервисов мультиссылок**, например Taplink. Если зайти на сайт Taplink'a[ссылка удалена модератором], то они там показывают сценарии использования сервиса и пишут о категориях клиентов, на которые они ориентируются. Это “популярные люди”, “бизнес”, “интернет-магазин” и “каждый”. На лендинге немало примеров работ для **оффлайн бизнеса**, поэтому появилась идея проверить, используют ли вообще эти категории бизнеса сервисы мультиссылок. И для этого пригодится информация с Яндекс Карт.
Скрин лендинга https://taplink.ru/#### Поделим сайты на типы:
* сайты на собственном домене (или сделанные в конструкторе, или разработанные самостоятельно)
* сайты на домене конструктора
* страницы на домене сервиса мультиссылок
* последний тип организаций без сайта, но с соцсетью
Целевой аудиторией будут те организации, где последние три категории представлены в большом количестве. Почему так? Потому что компании, имеющие соцсети, развиваются, и многим из них в скором времени может понадобиться сайт. А большое количество организаций (определенной категории бизнеса), которые пользуются конструктором, говорит о том, что этому сегменту интересны сервисы мультиссылок. Бизнес со своим доменом с большой вероятностью не перейдет в Taplink.
Парсинг Карт
------------
Перед тем, как что-то парсить, нужно узнать, есть ли у сервиса API. У Яндекс Карт [оно есть](https://yandex.ru/dev/maps/), но там есть определенные ограничения. Найти XHR запросы в консоли разработчика или json‘ы в html странице мне не удалось, поэтому пришлось писать парсер на [selenium](https://habr.com/ru/post/248559/) и [bs4](https://habr.com/ru/post/544828/).
[Здесь github проекта.](https://github.com/artemsteshenko/parser_maps)
Я разделил работу на две части. Первая: **сбор ссылок на страницы организаций**. Вторая: **сбор информации по этим ссылкам**.
### Собираем ссылки организаций
`LinksCollector` - это сборщик ссылок, в метод `run` нужно передать город, район, тип организации и последний параметр `type_org` - это тип организации (а также папка, куда складываются ссылки)
```
from selenium import webdriver
from link_parser import LinksCollector
driver = webdriver.Safari()
grabber = LinksCollector(driver)
grabber.run(city='Москва', district='район Арбат', type_org_ru='Кафе', type_org='cafe')
```
Внутри `LinksCollector`: `driver` открывает <https://yandex.ru/maps>, вводит нужный запрос, собирает все организации по запросу в регионе и сохраняет.
Пример работы парсера`Parser` - это сборщик информации со страницы организации. В метод `parse_data` нужно передать список ссылок `hrefs`, которые мы нашли ранее и папку для сохранения информации `type_org`(у меня такая же, как тип организации).
```
from selenium import webdriver
from info_parser import Parser
driver = webdriver.Safari()
parser = Parser(driver)
parser.parse_data(
hrefs=["https://yandex.ru/maps/org/tsentr_pravovykh_konsultatsiy/1180977373/"],
type_org='cafe'
)
```
Внутри `Parser`: `webdriver` обходит все страницы по списку и собирает следующую информацию: название, сайт, соцсети, телефон, адрес, рейтинг, время работы. Можно собирать и товары, и услуги при желании. Для моего "исследования" нужны только соцсети и сайт.
Немного аналитики
-----------------
В [jupyter-ноутбуке](https://github.com/artemsteshenko/parser_maps/blob/master/notebooks/analysis.ipynb) можно посмотреть на то, какие организации какие типы сайтов используют.
Кафе практически никогда не используют мультиссылки. Используют чаще всего сайт на своем домене или соцсети. Что логично по нескольким причинам:
1. Крупные сети или дорогие рестораны имеют средства на свой сайт.
2. Небольшим кафе проще добавлять свое меню в Яндекс Картах или постить фото в соцсети.
Поэтому сервисам мультиссылок стоит задуматься об API соцсетей и переносить посты с фото себе. Или сосредоточится на клиентах другой категории. Taplink у себя в лендинге целый раздел завел с примером кафе, хотя стоило бы сделать пример для категории, которая будет использовать сервис чаще и реально является потенциальным клиентом.
https://taplink.ru/ Следущая категория - это "Ногтевая студия". Почти все организации этого типа имеют соцсети, ведь нужно выкладывать фото красивых ноготочков. Но в отличие от "Кафе" некоторые имеют мультиссылки и используют их для записи в салон. Я думаю, если подумать над идеей переноса фото и постов из соцсетей, то пользователей будет больше, ведь тогда на красивые ноготочки можно будет смотреть на странице (мультиссылке).
Такие организации как "Отель", "Фитнес" делают свои сайты. "Шоурумы", как ни странно, тоже: для них важен модный дизайнерский сайт. Подробнее про то, как определялись типы сайтов, и больше аналитики можно посмотреть в [ноутбуке](https://github.com/artemsteshenko/parser_maps/blob/master/notebooks/analysis.ipynb).
Выводы
------
1. Во-первых, сбор небольшого количества данных на коленке может помочь понять: какая ваша целевая аудитория и как себя лучше позиционировать.
2. Просмотр их сайтов или соцсетей поможет понять, что нужно ЦА и какие фичи следует добавить, чтобы улучшить сервис.
Я надеюсь, вам понравилась статья.
Также надеюсь, что вам поможет [парсер](https://github.com/artemsteshenko/parser_maps) для ваших задач. Также не сомневаюсь, что многие могут написать его лучше. Тогда прошу делиться мыслями и идеями | https://habr.com/ru/post/701478/ | null | ru | null |
# Формулы переводов: хитрая локализация для iOS и не только
Сюжет этой истории развивался, когда мне довелось реализовывать одну из продуктовых задач нашей компании Jivo для платформы iOS. Но начну, пожалуй, с небольшого вступления.
Локализация – одна из часто обсуждаемых тем в мобильной разработке.
В основном по этой теме в отношении платформы iOS затрагиваются следующие аспекты:
* сервисы для упрощения организации и синхронизации переводов;
* best-practice по переводам xib файлов;
* вспомогательные compile-time надстройки для верификации переводов.
Однако, наша история не об этом. Для синхронизации переводов у нас в компании успешно интегрирован сторонний сервис, вместо xib файлов мы отдаём предпочтение коду, а compile-time надстройки пока не используем (впрочем, есть мысли по внедрению).
Наша история – о том, как однажды нам довелось столкнуться с задачей, в рамках которой понадобилось практически жонглировать переводами одной и той же по смыслу фразы, которая слегка видоизменялась в зависимости от контекста.
### С чего всё началось
В нашем продукте появился функционал по установке напоминаний. Напоминания могут быть полезны в случае, если оператор пожелает вернуться к клиенту несколько позже. Например, уточнить, не возникло ли дополнительных вопросов спустя некоторое время после оказания консультации, что помогает повысить лояльность. Напоминание на определённое время можно поставить для себя самого или для другого оператора, а также опционально указать текстовый комментарий (описание), если таковой нужен.
Разумеется, факт установки такого напоминания дублируется в ленте диалога системным сообщением. И как раз здесь-то и обнаружилось затруднение: в зависимости от конфигурации напоминания, информационная надпись может выглядеть совершенно по-разному. Например (из английской версии интерфейса):
> ◼︎ You created the reminder for agent Alex on 08/29/20 at 4:30 PM
>
> ◼︎ Agent Nick created the reminder "Ask about any issue happened since our call" on 10/03/20 at 11:30 AM
>
> ◼︎ Agent Alex completed the reminder on 12/05/20 at 5:00 PM
>
>
Как можно заметить, конечный вид надписи зависит одновременно от нескольких факторов:
◼︎ Кто произвёл действие – мы сами или наш коллега
◼︎ Был ли указан комментарий
◼︎ Автор произвёл действие для себя самого или для другого оператора
◼︎ Которое было произведено действие – создание, изменение, отмена или завершение
По не особо сложным подсчётам получается, что из этого обилия может образоваться до 32 вариантов конечной надписи. Разумеется, если учитывать, что наше приложение переведено на шесть языков, то три десятка вариантов легко превращаются примерно в две сотни переводов. И потому несложно догадаться, что возникло стойкое желание сократить количество трудозатрат для жонглирования всеми этими переводами.
### Какие рассматривались варианты
Итак, по уже озвученным причинам подход «в лоб» пришлось отсечь практически сразу, ибо довольно непросто манипулировать тремя десятками ключей и двумя сотнями переводов:
```
// either...
let caption = format(
"REMINDER_CREATE_SELF_FOR_SELF", // !!!
reminder.time)
// or...
let caption = format(
"REMINDER_CREATE_ANOTHER_WITH_COMMENT_FOR_SELF", // !!!
reminder.author.name,
reminder.comment,
reminder.time)
// etc...
```
Еще один из распространённых вариантов заключается в разбиении фразы на составные части. С одной стороны, в этом случае количество необходимых переводов сокращается раза в три, но с другой стороны это всё ещё весьма приличное количество, и к тому же добавляются дополнительные сложности. Например, необходимость помнить или вести учёт, какие вообще существуют составные части и в каком порядке они друг с другом взаимодействуют. Плюс, неизбежная привязка к коду:
```
if reminder.author.isMe {
slices += [format("REMINDER_AUTHOR_SELF")]
}
else {
slices += [format("REMINDER_AUTHOR_ANOTHER", reminder.author.name)]
}
if let comment = reminder.comment {
slices += [format("REMINDER_COMMENT", comment)]
}
if reminder.target.isMe {
slices += [format("REMINDER_FOR_SELF")]
}
else {
slices += [format("REMINDER_FOR_ANOTHER", reminder.target.name)]
}
slices += [format("REMINDER_TIME", reminder.time)]
let caption = slices.joined()
```
После некоторых размышлений стало понятно, что основная трудность нашего случая заключается лишь в обеспечении отображения тех или иных участков надписи в зависимости от какого-то условия. И чаще всего таким условием является непосредственно наличие либо отсутствие нужной информации для отображения.
### Выход найден
В результате возникла идея оформить достаточно тривиальный язык разметки. Как bb-коды применяются для базового форматирования в интернете, так и предполагаемый язык должен был помочь оформлять разметку для переводов. И в итоге удалось составить сравнительно простую разметку, которая теперь с одной стороны помогает использовать тривиальную логику в обработке переводов, а с другой стороны не особо сложна для понимания людьми, не свянными с программированием. Между собой мы называем эту разметку «формулой переводов».
Основное описание и принцип действия можно найти в репозитории проекта (ссылка в конце статьи). Но если вкратце, то в формулах основными контролирующими элементами являются переменные, блоки и алиасы.
**Переменная** – символьное наименование той или иной надписи, например, `$creatorName`, которая в итоге заменяется на соответствующую надпись, если таковая была назначена для переменной.
**Блок** – список отдельных фраз через специальный разделитель внутри управляющих скобок, например, `$[Agent $creatorName ## You]`; в данном случае внутри блока есть две отдельные фразы - `Agent $creatorName` и `You`, разделённые символами `##`; при сканировании блока алгоритм будет проходить по очереди через эти две фразы, и в итоговый результат попадет лишь первая из фраз; та которая окажется корректной. Для того, чтобы фраза считалась корректной, все используемые в ней переменные (если таковые использованы) должны быть назначены; в ином случае алгоритм пропускает фразу и переходит к следующей.
**Алиас** – виртуальное имя фразы, обрамлённое в двоеточия, например, `$[Agent $creatorName ## :another: Another agent ## You]`; в данном случае внутри блока теперь есть три фразы - `Agent $creatorName`, `Another agent` и `You`; но для фразы `Another agent` мы назначили алиас `another`, что означает, что алгоритм будет учитывать эту фразу только в том случае, если предварительно мы активируем соответствующий ей алиас (позволим фразе принимать участие в парсинге).
Посмотрим на примере уже обозначенной ранее ситуации. Для события о создании напоминания у нас может быть несколько вариаций, вот некоторые из них:
> ◼︎ Agent Nick created the reminder on 10/03/20 at 11:30 AM
>
> ◼︎ You created the reminder "Ask about any issue happened since our call" on 10/03/20 at 11:30 AM
>
> ◼︎ Agent Nick created the reminder "Ask about any issue happened since our call" on 10/03/20 at 11:30 AM
>
> ◼︎ You created the reminder for Alex on 10/03/20 at 11:30 AM
>
>
Наша действующая формула для данного случая выглядит так:
```
$[Agent $creatorName ## You] created the reminder $["$comment"] $[for $targetName] on $date at $time
```
И теперь давайте рассмотрим, каких результатов можно достичь с её помощью. Абсолютно все возможные варианты перечислять не станем, но остановимся на тех четырёх, что представлены выше. Формула во всех этих примерах одна и та же, различается только установка переменных (сами примеры на языке Swift, но решение реализовано на C++, поэтому доступно и для многих других языков).
* Другой оператор создал напоминание без комментария:
```
let parser = PureParser()
let formula = "$[Agent $creatorName ## You] created the reminder $[\"$comment\"] $[for $targetName] on $date at $time"
parser.assign(variable: "creatorName", value: "Nick")
parser.assign(variable: "date", value: "10/03/20")
parser.assign(variable: "time", value: "11:30 AM")
let result = parser.execute(formula, collapseSpaces: true, resetOnFinish: true)
print(result)
// Agent Nick created the reminder on 10/03/20 at 11:30 AM
```
* Текущий оператор создал напоминание с комментарием:
```
let parser = PureParser()
let formula = "$[Agent $creatorName ## You] created the reminder $[\"$comment\"] $[for $targetName] on $date at $time"
parser.assign(variable: "comment", value: "Ask about any issue happened since our call")
parser.assign(variable: "date", value: "10/03/20")
parser.assign(variable: "time", value: "11:30 AM")
let result = parser.execute(formula, collapseSpaces: true, resetOnFinish: true)
print(result)
// You created the reminder "Ask about any issue happened since our call" on 10/03/20 at 11:30 AM
```
* Другой оператор создал напоминание с комментарием:
```
let parser = PureParser()
let formula = "$[Agent $creatorName ## You] created the reminder $[\"$comment\"] $[for $targetName] on $date at $time"
parser.assign(variable: "creatorName", value: "Nick")
parser.assign(variable: "comment", value: "Ask about any issue happened since our call")
parser.assign(variable: "date", value: "10/03/20")parser.assign(variable: "time", value: "11:30 AM")
let result = parser.execute(formula, collapseSpaces: true, resetOnFinish: true)
print(result)
// Agent Nick created the reminder "Ask about any issue happened since our call" on 10/03/20 at 11:30 AM
```
* Текущий оператор создал напоминание без комментария для другого оператора:
```
let parser = PureParser()
let formula = "$[Agent $creatorName ## You] created the reminder $[\"$comment\"] $[for $targetName] on $date at $time"
parser.assign(variable: "targetName", value: "Alex")
parser.assign(variable: "date", value: "10/03/20")
parser.assign(variable: "time", value: "11:30 AM")
let result = parser.execute(formula, collapseSpaces: true, resetOnFinish: true)
print(result)
// You created the reminder for Alex on 10/03/20 at 11:30 AM
```
* Бонус: добавим алиас в формулу?
```
let parser = PureParser()
let formula = "$[Agent $creatorName ## :another: Another agent ## You] created the reminder $[\"$comment\"] $[for $targetName] on $date at $time"
parser.activate(alias: "another", true)
parser.assign(variable: "date", value: "10/03/20")
parser.assign(variable: "time", value: "11:30 AM")
let result = parser.execute(formula, collapseSpaces: true, resetOnFinish: true)
print(result)
// Another agent created the reminder on 10/03/20 at 11:30 AM
```
### Профит
В итоге для каждого отдельного события (напоминание создано, завершено, отменено) формула подобного рода обеспечивает в нашем случае покрытие восьми различных случаев, и при этом остаётся сравнительно читабельной даже для менеджера. Такая же схема используется и ещё в нескольких местах помимо напоминаний.
### Где пощупать
Библиотека написана на **C++**, а также есть обёртка на **C** и **Swift**.
Для **Swift** предусмотрено подключение через **CocoaPods** и **Swift Package Manager**.
[Репозиторий на GitHub](https://github.com/JivoSite/pure-parser) | https://habr.com/ru/post/517818/ | null | ru | null |
# Погружение в JetBrains Space Applications
Привет, Хабр.
Недавно JetBrains представили свой новый продукт под названием [Space](https://jetbrains.com/space), о чем был своевременный [пост на Хабре](https://habr.com/en/company/jetbrains/blog/478866/). Прошло немного времени и уже пора бы попробовать некоторые его особенности как платформы. В этой статье речь пойдет о [Space Applications](https://www.jetbrains.com/help/space/applications.html).
Space Applications - это расширения серверной и клиентской частей. Applications позволяют взаимодействовать с разными компонентами платформы и расширять её функциональность.
Первым делом рассмотрим расширения серверной части, которые предоставляет Space. Основное ограничение - Application нельзя запустить непосредственно внутри окружения Space. Для предоставления доступа между Space и Application используется так называемый Endpoint, в котором мы указываем Endpoint URI - адрес нашего плагина, на который Space будет отправлять запросы и коммуницировать с помощью Space HTTP API.
На данный момент известно несколько видов Applications:
#### Chatbot
Cтандартный чатбот, с которым взаимодействие происходит в приватном с ним чате. На данный момент кастомизация сильно уступает, например, Telegram. Нельзя добавлять бота в канал (групповой чат), а из интерактивного интерфейса пока доступны только кнопки.
#### Slash commands
Для каждого канала могут быть заданы разные команды, и когда пользователь вводит "/", ему показывается список доступных команд. На данный момент доступны только для чатботов.
#### Client applications
Используют функционал Space, чтобы получать от него разную информацию или взаимодействовать с разными модулями и компонентами, например, открывать/закрывать issues, писать сообщения, отправлять посты в канал и так далее.
#### Custom menus
Позволяют расширить стандартные меню новыми элементами. На момент написания статьи api для них еще не доступен.
Также можно свободно комбинировать сразу несколько типов Applications. Например, создать бота, у которого будет кнопка для запуска билда проекта на CI/CD сервере, и результат которого вернется в общий канал.
Для начала Application требуется создать. Делается это через Administration menu. При создании можно указать, какими правами оно будет обладать, чтобы приложение имело доступ только к тем ресурсам, которые нами явно указаны.
После создания в табе Authentication требуется выбрать один из возможных Authentication flows, в зависимости от типа приложения. Кратко каждый из них можно описать так:
* Client Credentials Flow - самый простой способ. Работает через client id и client secret. Наше приложение будет работать от своего лица и не сможет получить доступ к некоторым компонентам платформы. Используется в полностью серверном приложении.
* Authorization Code Flow - логинимся в приложение через Space, получаем код авторизации, который приложение использует чтобы из него получить токен и работать от лица пользователя.
* Implicit Flow - идея таже, что и Authorization Code Flow, только клиент логинится на стороне браузера.
Client application
------------------
В данном разделе мы используем функционал Space, чтобы получить от сервера разную информацию: каналы, приложения, пользователи, проекты, и т.д.
build.gradle.kts
```
repositories {
mavenCentral()
maven("https://kotlin.bintray.com/kotlinx")
maven("https://maven.pkg.jetbrains.space/public/p/space/maven")
}
dependencies {
implementation(kotlin("stdlib"))
// Space api sdk
// https://www.jetbrains.com/help/space/space-sdk.html
val space_version = "61400-beta"
implementation("org.jetbrains:space-sdk-jvm:$space_version")
// Ktor (http client)
// https://github.com/ktorio/ktor
val ktor_version = "1.4.3"
implementation("io.ktor:ktor-client-core:$ktor_version")
implementation("io.ktor:ktor-client-core-jvm:$ktor_version")
implementation("io.ktor:ktor-client-cio:$ktor_version")
}
```
Сначала нам требуется создать и настроить клиент. Мы будем использовать Client Credentials Flow:
```
private const val spaceInstanceUrl = "https://makentoshe.jetbrains.space"
val spaceClient = SpaceHttpClient(HttpClient(CIO)).withServiceAccountTokenSource(
ClientCredentialsFlow.clientId, ClientCredentialsFlow.clientSecret, spaceInstanceUrl
)
object ClientCredentialsFlow {
const val clientId: String = TODO(“Put your client_id here”)
const val clientSecret: String = TODO(“Put your client_secret here”)
}
```
Ниже приведены примеры некоторых расширений и запросов.
```
// There are some examples of retrieving several data from the Space instance.
// We can process this info as we want - create analytics, office dashboards, and so on.
fun main() = runBlocking {
val channels = spaceClient.chats.channels.listAllChannels("").data
println("Channels: ${channels.map { "${it.name}(${it.channelId})" }}")
// View application rights allows to see all applications
// If rights were not accepted - the application can see only itself.
val applications = spaceClient.applications.getAllApplications("")
println("Applications: ${applications.map { "${it.name}(${it.id})" }}")
// Works only with View member profile rights
val profiles = spaceClient.teamDirectory.profiles.getAllProfiles().data
println("Profiles: ${profiles.map { "${it.username}(${it.id})" }}")
// Works only with View project parameters rights
// These rights can be managed for selected projects or for whole projects at one time.
val projects = spaceClient.projects.getAllProjects().data
println("Projects: ${projects.map { "${it.name}(${it.id})" }}")
// Works only with Project Issues: View issues rights
val issues = projects.firstOrNull()?.let { getProjectIssues(it) }
println("Issues: ${issues?.map { "${it.title}(${it.id})" }} ")
}
private suspend fun getProjectIssues(project: PR_Project): List {
return spaceClient.projects.planning.issues.getAllIssues(
project = ProjectIdentifier.Id(project.id),
assigneeId = emptyList(),
statuses = emptyList(),
sorting = IssuesSorting.CREATED,
descending = true
).data
}
```
Output
```
Channels: [Booruchan(4UHs4I3yyno1), general(10xDLp0yqy4w), Habrachan(4HyHLw3SnO9Y), Sipichan(15A2hA1RpAsp)]
Applications: [client(2czEkY3AIaV0), chatbot(d3Q8Z0UeVCF)]
Profiles: [Makentoshe(2iqI4p3gzufl)]
Projects: [Booruchan(qN0K31awqo6), Habrachan(1tJHqn2A76Yf), Sipichan(35BreB35gvdA)]
Issues: [Add custom Run Configuration and support ngrok startup(3S09oT4JHvpC), Add Client template for Space plugin with Gradle (atQRe1SIklB), Add Blank template for Space application plugin support for Gradle(4REln04HAo5k)]
```
В зависимости от настроенных прав полученные данные могут отличаться. Стоит обратить внимание, что почти все данные возвращаются через .data. Изначально возвращается объект Batch, который используется для пагинации и содержит текущий набор данных, ключ к следующему набору, и общее количество элементов. При запросах стоит это учитывать, однако для простоты в данной статье пагинация опущена.
Исходники проекта доступны на [github](https://github.com/Makentoshe/sipichan-client) и со временем будут пополняться.
Chatbot + slash command application
-----------------------------------
Серверные Applications, по сравнению с клиентскими, требуют дополнительной подготовки. Первым делом нам нужно серверное приложение, на котором будет хоститься наш бот. Мы уже использовали HTTP клиент Ktor, так что можем создавать на нем и серверную часть. Создание конфигурационных файлов для Ktor здесь будет опущено, но есть [документация](https://ktor.io/docs/a-ktor-application.html), на которую можно опереться.
Когда мы поднимем наш сервер, мы сможем получить его URL, чтобы Space мог его использовать. Покупать хост, или искать бесплатный не комильфо, поэтому мы пойдем обходным путем - будем использовать туннельный сервис. В официальной документации используется ngrok, однако лично я предпочитаю localtunnel, из-за его возможности указывать постоянный адрес.
```
// localtunnel
npx localtunnel --port 8080 --subdomain makentoshe
// ngrok
ngrok http 8080
```
В любом случае мы получим URL - это как раз то, что нам нужно.
Возвращаемся в настройки Applications в нашем Space. В табе Endpoint в поле Endpoint URI нужно будет указать наш url. Для меня это `https://makentoshe.loca.lt/api/chatbot`. Про то, зачем нужен `/api/chatbot` будет дальше.
В том же табе существует два способа верифицировать наши запросы:
* Verification token - этот токен кладется в каждый запрос от Space. Нам остается сравнить эти токены, и если они совпадают - мы общаемся с нашим Space.
Пример ответа с Verification token
```
{
"className": "ListCommandsPayload",
"accessToken": "",
"verificationToken": "d415ca5965b37f4f0cac59fd33de7b94e396284e897d0fb8a070d0a5e1b7f2d3",
"userId": "2kawvQ4F6GM6"
}
```
* Signing key - более продвинутый метод. Для каждого запроса создается хеш, который кладется в его заголовок. Когда мы получаем запрос мы также вычисляем хеш, и если они совпадают - все ок. Подробнее об алгоритме - [здесь](https://www.jetbrains.com/help/space/verify-space-in-application.html#verifying-requests-using-a-signing-key).
Пример ответа с Signing key
```
POST /api/chatbot HTTP/1.1
Host: 12345abcdef.ngrok.io
User-Agent: Space (61355) Ktor http-client
Content-Length: 163
Accept: */*
Accept-Charset: UTF-8
Content-Type: application/json
X-Forwarded-For: 123.456.123.456
X-Forwarded-Proto: https
X-Space-Signature: 2aa8cba6217a28686de0ca8dcfe2a1d0795e343d744a0c5307308e43777593a5
X-Space-Timestamp: 1607623492912
Accept-Encoding: gzip
{"className":"ListCommandsPayload","accessToken":"","verificationToken":"d415ca5965b37f4f0cac59fd33de7b94e396284e897d0fb8a070d0a5e1b7f2d3","userId":"2kawvQ4F6GM6"}
```
В качестве примера мы возьмем оба варианта и будем сверять и хеши, и токены.
```
object Endpoint {
const val verificationToken: String = TODO("Place your verification_token")
const val signingKey: String = TODO("Place your signing_key")
fun verify(payload: ApplicationPayload): Boolean {
return payload.verifyWithToken(verificationToken)
}
fun verify(timestamp: String, signature: String, body: String): Boolean {
val hmacSha256 = Mac.getInstance("HmacSHA256")
hmacSha256.init(SecretKeySpec(signingKey.toByteArray(), "HmacSHA256"))
val hash = hmacSha256.doFinal("$timestamp:$body".toByteArray()).toHexString()
return hash == signature
}
private fun ByteArray.toHexString() = joinToString("") { (0xFF and it.toInt()).toString(16).padStart(2, '0') }
}
```
Первым делом для сервера нам нужно указать Routing. Это тот самый Endpoint для Space, который он будет использовать, чтобы обращаться к нашему боту.
```
@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
install(Routing) {
chatbot()
}
}
fun Routing.chatbot() {
post("api/chatbot") {
val receiveBody = call.receiveText()
val timestamp = call.request.headers["x-space-timestamp"]
?: return@post call.respond(HttpStatusCode.BadRequest)
val signature = call.request.headers["x-space-signature"]
?: return@post call.respond(HttpStatusCode.BadRequest)
if (!Endpoint.verify(timestamp, signature, receiveBody)) {
return@post call.respond(HttpStatusCode.Unauthorized)
}
val payload = readPayload(receiveBody)
if (!Endpoint.verify(payload)) {
return@post call.respond(HttpStatusCode.Unauthorized)
}
try {
processChatbotPayload(payload)
} catch (unknownCommand: IllegalStateException) {
LoggerFactory.getLogger("Chatbot").error(unknownCommand.message)
}
}
}
```
Как только к серверу происходит обращение по заданному адресу, первым делом мы проверяем, что запрос пришел именно от нашего Space. Если это не так - возвращаем 401 Unauthorized.
Далее боту следует обработать полученный payload. На момент написания статьи существует 5 имплементаций ApplicationPayload:
* MessagePayload - передается нам, когда пользователь отправляет обычное сообщение.
* ListCommandsPayload - передается нам, когда пользователь начинает сообщение с "/" и затем вводит команду посимвольно. Здесь происходит запрос все существующих команд, которые нам нужно будет вернуть в виде json. На ввод каждого символа передается новый Payload.
* MessageActionPayload - передается, когда пользователь нажимает на интерактивный элемент сообщения, например, на кнопку. Корректно срабатывают только элементы из последнего сообщения. Все предыдущие элементы будут "стерты"(например, их actionId всегда будут пустой строкой).
* MenuActionPayload - передается, когда пользователь нажимает на кастомный элемент на одном из меню (ProjectMenu, LocationMenu, ChannelMessageMenu, ChannelAttachmentMenu и т.д.). На момент написания статьи все еще не доступен.
* ListMenuExtensionsPayload - имеет ту же идею, что и ListCommandsPayload, только для меню. На момент написания статьи все еще не доступен.
```
private suspend fun PipelineContext<*, ApplicationCall>.processChatbotPayload(payload: ApplicationPayload) {
when (payload) {
is MessagePayload -> {
processChatbotMessagePayload(payload)
}
is MessageActionPayload -> {
processChatbotMessageActionPayload(payload)
}
is ListCommandsPayload -> {
processChatbotListCommandsPayload(payload)
}
}
}
```
Когда пользователь отправляет нам сообщение - скорее всего это команда, которую боту надо выполнить. Команду можно описать одним дата классом:
```
data class Command(
val name: String,
val info: String,
val action: suspend (payload: MessagePayload) -> Unit
) {
fun toCommandDetail() = CommandDetail(name, info)
}
```
Предлагаю в качестве примера реализовать три простых команды:
* help - выводит сообщение со списком всех команд;
* echo - выводит переданное сообщение обратно пользователю;
* interactive - выводит пример выбранного типа интерактивного элемента, например, button.
```
object Commands {
val help = Command(
"help",
"Show this help",
) { payload ->
val context = HelpContext.from(payload)
printToChat(context, message {
section {
text(
"""Help message:
name - Show this help
${echo.name} - ${echo.info}
${interactive.name} - ${interactive.info}
""".trimIndent()
)
}
})
}
val echo = Command(
"echo",
"Echoing the input string",
) { payload ->
val context = EchoContext.from(payload)
val body = context.message.body
printToChat(context, message = if (body is ChatMessage.Text) {
message { section { text(body.text) } }
} else {
message { section { text("Skip the Block body") } }
})
}
val interactive = Command(
"interactive",
"Displaying available message interactive elements"
) { payload ->
// TODO finish later
}
val list = listOf(help, echo, interactive)
val commands: Commands
get() = Commands(list.map { it.toCommandDetail() })
}
```
Сначала разберемся, что происходит в командах help и echo. Из `ApplicationPayload` каждой команды мы можем извлечь нужные данные для обработки и положить их в соответствующий Context, который мы сами определяем. Этот класс помогает нам аккумулировать данные в одном месте.
Context.kt
```
interface UserContext {
val userId: String
}
fun userContext(applicationPayload: ApplicationPayload) = object: UserContext {
override val userId = applicationPayload.userId ?: throw IllegalArgumentException("Payload does not contains user id")
}
data class EchoContext(override val userId: String, val message: MessageContext) : UserContext {
companion object {
fun from(payload: ApplicationPayload): EchoContext? = when (payload) {
is MessagePayload -> from(payload)
else -> null
}
fun from(payload: MessagePayload): EchoContext {
return EchoContext(payload.userId, payload.message)
}
}
}
data class HelpContext(override val userId: String): UserContext {
companion object {
fun from(payload: ApplicationPayload): HelpContext {
return HelpContext(payload.userId!!)
}
}
}
data class InteractiveContext(override val userId: String): UserContext {
companion object {
fun from(payload: ApplicationPayload): InteractiveContext {
return InteractiveContext(payload.userId!!)
}
}
}
```
После того, как мы получили наш `userId` и остальные сопутствующие данные, нам нужно их вывести в чат пользователя, с которым в данный момент взаимодействует бот. Для этого напишем отдельную функцию `printToChat`.
```
suspend fun printToChat(context: UserContext, message: ChatMessage) {
val member = ProfileIdentifier.Id(context.userId)
spaceClient.chats.messages.sendMessage(MessageRecipient.Member(member), message)
}
```
Любое сообщение в Space представлено в виде класса `ChatMessage`. Этот класс является sealed и имеет 2 наследника: `ChatMessage.Text` и `ChatMessage.Block`.
`ChatMessage.Text` является простым текстовым сообщением поддерживающим markdown.
```
ChatMessage.Text(
"""
**bold**
`code`
*italic*
@{2iqI4p3gzufl, Maksim Hvostov}
@{2iqI4p3gzufl, Makentoshe}
@{2iqI4p3gzufl, any string may be replaced with my name}
[\#general](im/group/10xDLp0yqy4w)
>quote
""".trimIndent()
)
```
Output`ChatMessage.Block` существует для более сложных сообщений, которые могут быть разбиты на секции, иметь разделители, и другие продвинутые элементы форматирования.
Для него существует специальный DSL, который мы и используем. Всё начинается с функции `message` - это корень нашего сообщения, в котором мы можем указать:
* `MessageOutline` - это дополнительная подпись под именем отправителя и, по желанию, иконка, которая задается через строку. Какой именно должна быть эта строка пока не понятно, поэтому вместо иконки передаем `null`.
* `MessageStyle` - изменяет некоторые цвета в сообщении, в соответствии со стилем.
* Для чего нужна `messageData` я пока так и не понял. Чтобы не было передано в сообщении нашему боту, это поле всегда будет `null`.
```
message {
this.outline = MessageOutline(null, "Outline text")
this.style = MessageStyle.PRIMARY
section {
this.text("Primary message")
}
}
```
OutputsПосле этого мы можем либо определить новую секцию методом `section`, либо поставить разделитель методом `divide`.
В секции нам доступны:
* обычное текстовое поле через метод `text`.
* текстовое поле с тегом, для которого можно добавить отдельный стиль.
* текстовое поле с изображением справа от секции.
* текстовое поле с иконкой, в которую опять же передается строка.
* `footer` и `header`.
* конструкция “поле значение” через `fields`
* интерактивные элементы, из которых на момент написания статьи доступна только кнопка.
Как это выглядит:
```
message {
this.outline = MessageOutline(null, "Outline text")
this.style = MessageStyle.PRIMARY
section {
this.header = "Section header"
this.footer = "Section footer"
this.text("Plain text")
}
divider()
section {
header = "This tag may indicate something not good"
this.textWithTag("Text with tag", "error tag", MessageStyle.ERROR)
}
section {
this.text("Plain text just to fill some space.")
this.textWithImage("Text with image", "https://www.jetbrains.com/space/img/feedback-section/video-preview.png")
}
section {
this.textWithIcon("Text with icon", "", MessageStyle.WARNING)
}
section {
header = "Fields"
this.fields {
this.field("field1", "value1")
this.field("field2", "value2")
this.field("field3", "value3")
this.field("field4", "value4")
}
this.controls {
this.button("Disabled button without any action", PostMessageAction("", ""), disabled = true)
}
}
}
```
OutputОсталось реализовать команду interaction и соединить все вместе.
```
val interactive = Command(
"interactive",
"Displaying available message interactive elements"
) { payload ->
val context = InteractiveContext.from(payload)
val arguments = payload.commandArguments()
if (arguments == null || arguments.isBlank()) {
return@Command printToChat(context, message {
section {
text("Specify one of the selected ui elements:\nbutton")
}
})
}
printToChat(context, message {
section {
header = "Available message interactive elements"
controls {
when (arguments) {
"button" -> {
val primaryAction = PostMessageAction("ButtonPrimaryActionId", "InteractiveButtonPayloadPrimary")
button("Primary", primaryAction, MessageButtonStyle.PRIMARY)
val secondaryAction = PostMessageAction("ButtonSecondaryActionId", "InteractiveButtonPayloadSecondary")
button("Secondary", secondaryAction, MessageButtonStyle.SECONDARY)
val regularAction = PostMessageAction("ButtonRegularActionId", "InteractiveButtonPayloadRegular")
button("Regular", regularAction, MessageButtonStyle.REGULAR)
val dangerAction = PostMessageAction("ButtonDangerActionId", "InteractiveButtonPayloadDanger")
button("Danger", dangerAction, MessageButtonStyle.DANGER)
}
}
}
}
})
}
```
Теперь мы можем подключать обработку разных ApplicationPayload's. Для простого сообщения от пользователя мы ищем команду из списка и выполняем её.
```
private suspend fun PipelineContext<*, ApplicationCall>.processChatbotMessagePayload(payload: MessagePayload) {
Commands.list.find { it.name == payload.command() }?.action?.invoke(payload)
?: return call.respond(HttpStatusCode.NotFound)
call.respond(HttpStatusCode.OK)
}
```
Для показа списка команд мы возвращаем список всех команд. Здесь же мы используем подключенный ранее Jackson.
```
private suspend fun PipelineContext<*, ApplicationCall>.processChatbotListCommandsPayload(payload: ListCommandsPayload) {
call.respondText(ObjectMapper().writeValueAsString(Commands.commands), ContentType.Application.Json)
}
```
Для нажатия на интерактивный элемент мы будем принтить actionId этой команды.
```
private suspend fun PipelineContext<*, ApplicationCall>.processChatbotMessageActionPayload(payload: MessageActionPayload) {
printToChat(userContext(payload), message { section { text(payload.actionId) } })
call.respond(HttpStatusCode.OK)
}
```
Исходники чатбота доступны по ссылке на [github](https://github.com/Makentoshe/Sipichan-chatbot).
Итого
-----
Почти все, что может сделать пользователь используя Space через пользовательский интерфейс, можно сделать и через предоставленный Api(если на то будут предоставлены разрешения).
На самом деле у Space гораздо больше способов расширения функционала. Мы рассмотрели лишь самый продвинутый уровень. Большую часть остальных расширений можно настроить имея вообще минимальные навыки программирования.
Вот остальные способы расширения функционала платформы:
* [Webhooks](https://www.jetbrains.com/ru-ru/space/extensibility/external/#webhooks) - оповещение внешних сервисов о событиях в Space.
* [Authorizations](https://www.jetbrains.com/ru-ru/space/extensibility/external/#space-as-an-authorization-server) - доступ к Space через OAuth 2.0.
* [Custom fields](https://www.jetbrains.com/ru-ru/space/extensibility/in-product/#custom-fields) - добавление кастомных полей к сущностям Space.
* [Скрипты](https://github.com/JetBrains/space-issues-import) для импорта данных из других приложений.
* [Сторонние интеграции с инструментами](https://www.jetbrains.com/ru-ru/space/extensibility/in-product/#no-code-workflows-with-external-tools). | https://habr.com/ru/post/545908/ | null | ru | null |
# Новые форматы графики в CSS с помощью обновлённой функции image-set
Перевод статьи [**Ollie Williams**](https://css-tricks.com/author/olliew/) **"**Using Performant Next-Gen Images in CSS with image-set**"**
CSS функция `image-set`поддерживается в браузерах на основе Chromium с 2012 года, а Safari начиная с версии 6. Недавно поддержка появилась в Firefox 88. Давайте углубимся в эту тему и посмотрим, что мы можем и чего не можем делать с помощью функции `image-set ()`
Несколько расширений одного и того же изображения
-------------------------------------------------
Вот что говорится в [спецификации](https://drafts.csswg.org/css-images-4/#image-set-notation) о функции `image-set ():`
> Обеспечение наиболее подходящего разрешения изображения для устройства пользователя может быть сложной задачей. В идеале изображения должны иметь то же разрешение, что и устройство на котором они просматриваются. Однако, есть факторы которые могут повлиять на то, какое изображение отправить на устройство. Например, если у пользователя медленный интернет, вероятнее всего он захочет получить изображение с низким разрешением и не ждать загрузки большого изображения.
>
>
По сути, это CSS фон, эквивалентный HTML атрибуту `srcset` для тегов `img`. Используя `image-set ()`, мы можем выбрать несколько расширений для изображения и доверится браузеру, чтобы он выбрал наиболее подходящее расширение. Это можно использовать для указания значения для трех различных CSS свойств: `content`, `cursor`и, самое полезное, `background-image`
```
.hero {
background-image: image-set("platypus.png" 1x, "platypus-2x.png" 2x);
}
```
**1x** используется для определения изображения с маленьким разрешением, а **2x** используется для определения изображения с большим разрешением. **x** - расшифровывается как **dppx**, что означает количество точек на пиксель.
Chrome / Edge / Opera / Samsung Internet в настоящее время работают только с префиксом **-webkit-**. Если вы используете Autoprefixer, то он подставит этот префикс за вас. В Safari функция `image-set` не требует префикса -webkit-, но использует старый синтаксис, который требует чтобы функция `url()` указывала путь к изображению.
```
.hero {
/* Fallback */
background-image: url("platypus.png");
/* Chrome/Edge/Opera/Samsung, Safari will fallback to this as well */
background-image: -webkit-image-set(url("platypus.png") 1x, url("platypus-2x.png") 2x);
/* Standard use */
background-image: image-set("platypus.png" 1x, "platypus-2x.png" 2x);
}
```
Теперь пользователи дорогих устройств увидят сверхчеткое изображение.
Также производительность будет улучшена для пользователей с медленным интернетом или с более дешевыми экранами, поскольку их браузер автоматически будет запрашивать изображение с более низким разрешением. Если вы хотите быть уверены, что изображение с высоким разрешением используется на мощных устройствах, даже при медленном соединении с интернетом , вы можете воспользоваться медиа-запрос `min-resolution` вместо `image-set().`Подробнее о том как показывать четкие изображения на экранах с высокой плотностью пикселей, можно прочитать в недавнем посте Джейка Арчибальда в его [блоге](https://jakearchibald.com/2021/serving-sharp-images-to-high-density-screens/).
Всё это очень круто, но что мне действительно нужно, так это иметь возможность использовать новые форматы изображений в CSS, и при этом поддерживать старые браузеры...
Новые форматы изображений
-------------------------
Safari 14 поддерживает webp. А это значит, что теперь webp поддерживается везде (кроме IE). Главное преимущество webp в том, что он весит меньше чем (но при этом имеет такое же качество) JPG, PNG, или GIF.
Также, появляется всё больше и больше новых форматов изображений. Например, изображения в формате AVIF имеют невероятно маленький размер. Chrome, Opera и Samsung Internet уже поддерживают этот формат. В Firefox AVIF доступен за флагом. Этот формат изображений пока не поддерживается многими дизайн инструментами, но вы уже можете конвертировать изображения в AVIF формат с помощью приложения [Squoosh](https://squoosh.app/), созданного командой Google. WebP 2, HEIF и JPEG XL также, в конечном итоге появятся в браузерах. Все это довольно интересно, но мы хотим чтобы браузеры, которые не поддерживают эти новые форматы, получали изображения в другом формате. К счастью, у `image-set()` есть для этого синтаксис.
Использование новых форматов изображений путем указания типа
------------------------------------------------------------
HTML уже много лет поддерживает тег.
```
```
Функция `image-set` предоставляет CSS эквивалент, позволяющий использовать современные форматы изображений, указав MIME-тип изображения:
```
.div1 {
background-image: image-set(
"kitten.avif" type("image/avif"),
"kitten.jpg" type("image/jpeg")
);
}
```
Если браузер не поддерживает AVIF, он проигнорирует этот формат и загрузит только второе указанное вами изображение. Если AVIF поддерживается, резервное изображение игнорируется.
В пример выше мы использовали изображение AVIF и добавили JPEG в качестве запасного варианта, но запасным вариантом может быть любой широко поддерживаемый формат изображения. Вот пример использования PNG.
```
.div2 {
background-image: image-set(
"puppy.webp" type("image/webp"),
"puppy.png" type("image/png")
);
}
```
В Chromium и Safari указание типа пока не поддерживается. Это значит, что вы можете использовать функцию `image-set` только для указания разрешений широко поддерживаемых форматов изображений, но не для добавления обратной совместимости при использовании WebP или AVIF в этих браузерах.
```
.div2 {
background-image: image-set(
"puppy.webp" type("image/webp") 1x,
"puppy2x.webp" type("image/webp") 2x,
"puppy.png" type("image/png") 1x,
"puppy2x.png" type("image/png") 2x
);
}
```
Вместо этого используйте для фона
----------------------------------
Возможно, вам вообще не нужно фоновое изображение. Если вы хотите использовать современные форматы изображений, вы можете использовать тег , который лучше поддерживается браузерами. Если вы установите для изображения `position: absolute`, поверх него легко можно будет отобразить другие элементы. | https://habr.com/ru/post/565920/ | null | ru | null |
# Вопросы совместимости Tibero и Oracle. Часть 2. Разработка Java приложений
Мы продолжаем цикл статей разработчиков приложений для баз данных — [Часть 1. Условная компиляция PL/SQL](https://habrahabr.ru/company/tmaxsoft/blog/350530/). Эта статья затронет тему использования Tibero в Java приложениях использующих JDBC и Hibernate, а также фреймворк Spring Roo.
В прошлом году вышел Spring Roo 2.0.0.RC2. Это java фреймворк, который позволяет значительно сократить время для разработки прототипов Spring MVC приложений, взаимодействующих с базами данных (БД), SOAP и RESTful web сервисов. Важно также, что последняя версия фреймворка создает приложения Spring Boot и использует шаблонизатор HTML страниц THYMELEAF, т.е. в отличие от предыдущей версии Spring Roo 1.3.2 использует последние технологии разработки java приложений.
“Из коробки” Spring Roo 2.0.0 работает, со следующими (БД): DB2\_400, DB2\_EXPRESS\_C, DERBY\_CLIENT, DERBY\_EMBEDDED, FIREBIRD, H2\_IN\_MEMORY, HYPERSONIC\_IN\_MEMORY, HYPERSONIC\_PERSISTENT, MSSQL, MYSQL, ORACLE, POSTGRES, SYBASE.
Возможность работы Spring Roo не только с open source, но и коммерческими БД существенно расширяет область его применения. Правда с одной оговоркой, драйвера коммерческих БД недоступны в открытых репозиториях, их необходимо скачать самостоятельно и поместить в локальный репозиторий maven.
Еще сложнее обстоят дела для коммерческих БД, которые не предусмотрены “из коробки” в Spring Roo, например, БД Tibero, которую в последнее время применяют как замену БД Oracle.
В нашей статье, мы покажем, что работать с такими БД ненамного сложнее, чем c коммерческими БД настройки для которых содержатся в Spring Roo.
Кратко опишем установку Spring Roo. Для работы Spring Roo 2.0.0.RC2 необходимо наличие java 8 и фреймворка для автоматизации и сборки проектов Apache Maven, желательно последней версии. Apache Maven берем с сайта maven.apache.org. Spring Roo 2.0.0.RC2 с сайта projects.spring.io/spring-roo.
Оба фреймворка скачиваются как zip архивы и разворачиваются, например для windows, в каталог C:\app\maven и C:\app\roo соответственно. Необходимо в переменную среды path прописать пути до исполняемых каталогов фреймворков: C:\app\maven\bin и C:\app\roo\bin. На этом установку необходимых фреймворков можно считать законченной. После перезапуска сессии пользователя проверяем работоспособность фреймворков.
В каталоге C:\app создаем каталог project. Заходим в каталог C:\app\project и набираем команду: mvn – version. Если фреймворк Apache Maven установлен правильно, то увидим версию самого фреймворка и java:
```
Apache Maven 3.5.0 (...)
Maven home: C:\app\maven\bin\..
Java version: 1.8.0_121, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.8.0_121\jre
Default locale: ru_RU, platform encoding: Cp1251
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"
```
После установки необходимых фреймворков, можно приступать к созданию проекта на Spring Roo. Подключение к БД, указанным в заголовке статьи будем тестировать на примере проекта hello из документации Spring Roo.
В каталоге project создаем каталог hello, где будет располагаться наш проект. Заходим в каталог hello и набираем команду roo. Если Spring Roo установлен правильно, то мы должны увидеть приглашение консоли Spring Roo:
```
_
___ _ __ _ __(_)_ __ __ _ _ __ ___ ___
/ __| '_ \| '__| | '_ \ / _` | | '__/ _ \ / _ \
\__ \ |_) | | | | | | | (_| | | | | (_) | (_) |
|___/ .__/|_| |_|_| |_|\__, | |_| \___/ \___/
|_| |___/ 2.0.0.RC2
Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
roo>
```
Теперь в консоли Spring Roo можно вводить команды для создания проекта:
```
project setup --topLevelPackage com.foo
jpa setup --provider HIBERNATE --database ORACLE
```
Первая строка определяет имя пакета приложения, вторая определяет провайдера ORM и имя БД. Если мы определили БД Oracle, а не HYPERSONIC\_IN\_MEMORY, как в документации, необходимо произвести дополнительный ручные настройки проекта hello, после чего вернуться к командам скрипта roo.
Первое, что нужно сделать, скачать jdbc драйвер Oracle: ojdbc7.jar и загрузить его в локальный репозиторий maven:
```
mvn install:install-file -Dfile=ojdbc7.jar -DgroupId=com.oracle
-DartifactId=ojdbc7 -Dversion=12.1.0.2.0 -Dpackaging=jar
```
Далее, в pom.xml файле проекта заменить зависимость, сформированную roo, на свою, которая учитывает версию jdbc драйвера.
В Spring Roo проектах зависимость для jdbc драйвера нужно прописать в двух разделах pom.xml файла. В разделе dependencyManagement:
```
com.oracle
ojdbc7
12.1.0.2.0
jar
```
И в раздел dependencies:
```
com.oracle
ojdbc7
```
Затем внести настройки в application.properties проекта. Указать имя класса драйвера, строку соединения, имя пользователя БД и пароль:
```
spring.datasource.driver-class-name=oracle.jdbc.OracleDriver
spring.datasource.url=jdbc\:oracle\:thin\:@//\:1521/
spring.datasource.password=<пароль>
spring.datasource.username=<пользователь>
spring.jpa.hibernate.ddl-auto=create-drop
```
Т.к. приложение тестовое, чтобы не засорять БД временными таблицами, последняя строчка настраивает hibernate на создание таблиц при старте приложения и их удаление при завершении работы.
После внесения указанных изменений в проект, можно продолжить создание приложения hello из командной строки Spring Roo:
```
entity jpa --class ~.domain.Timer
field string --fieldName message --notNull
repository jpa --all
service --all
web mvc setup
web mvc view setup --type THYMELEAF
web mvc controller --all --responseType THYMELEAF
web mvc controller --all --pathPrefix /api
```
Кратко опишем действие этих команд. Первые две строчки создают сущность Timer c одним полем message, которое не может быть пустым. Далее создается репозиторий для всех сущностей и сервисы. В этом приложении сущность одна — Timer. В последних строчках настраивается web часть приложения, созданная на основе Spring MVC и шаблонов THYMELEAF.
Все, простое приложение, позволяющее просматривать и редактировать сущность Timer, сохраняя данные в БД Oracle создано.
Исполнить приложение можно командой:
```
mvn spring-boot:run
```
После чего мы увидим результат работы приложения:
Рассмотрим теперь, какие настройки необходимо сделать, чтобы приложение работало с БД Tibero.
Первое, нужно скачать и поместить в локальный репозиторий maven jdbc драйвера Tibero:
```
mvn install:install-file -Dfile=tibero6-jdbc.jar -DgroupId=com.tmax.tibero
-DartifactId=tibero6-jdbc -Dversion=6.0 -Dpackaging=jar
```
Далее заменить jdbc драйвер Oracle на Tibero в зависимостях pom.xml раздела dependencyManagement:
```
com.tmax.tibero
tibero6-jdbc
6.0
jar
```
И в dependencies:
```
com.tmax.tibero
tibero6-jdbc
```
Внести изменения в настройки application.properties проекта:
```
spring.datasource.driver-class-name=com.tmax.tibero.jdbc.TbDriver
spring.datasource.url=jdbc\:tibero\:thin\:@\::
spring.datasource.password=<пароль>
spring.datasource.username=<пользователь>
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.database-platform=org.hibernate.dialect.Oracle10gDialect
```
Последняя строчка конфигурации указывает hibernate диалект БД. Tibero диалекта нет в библиотеке hibernate. Однако известно, что метаданные БД Tibero практически полностью соответствуют метаданным Oracle, что позволяет в настройках приложения указать диалект Oracle. Hibernate, в этом случае будет работать с БД Tibero так, как если бы это была БД Oracle.
Убедиться в работоспособности модифицированного приложения можно как и раньше командой:
```
mvn spring-boot:run
```
Теперь приложение работает с коммерческой БД Tibero, используя диалект Oracle.
Другой способ настройки диалекта hibernate заключается в загрузке специальной библиотеки диалекта. Например для Tibero, — это hibernate-tibero-dialect.jar. Версия диалекта зависит от версии hibernate для которой предназначена библиотека.
Требуемую вам версию диалекта hibernate вы можете запросить в российском представительстве компании TmaxSoft.
Подробнее рассмотрим установку библиотеки диалекта.
Сначала, нужно скачать и поместить в локальный репозиторий maven библиотеку диалекта hibernate для Tibero:
```
mvn install:install-file -Dfile=hibernate-tibero-dialect.jar
-DgroupId=com.tmax.tibero
-DartifactId=hibernate-tibero-dialect -Dversion=6.0
-Dpackaging=jar
```
Затем добавить библиотеку диалекта в pom.xml, раздел dependencyManagement:
```
com.tmax.tibero
hibernate-tibero-dialect
6.0
jar
```
И в dependencies:
```
com.tmax.tibero
hibernate-tibero-dialect
```
Внести класс диалекта в application.properties проекта:
```
spring.jpa.database-platform=org.hibernate.dialect.TiberoDialect
```
Убеждаемся в работоспособности модифицированного приложения:
```
mvn spring-boot:run
```
Теперь приложение работает с коммерческой БД Tibero, используя библиотеку диалекта hibernate для Tibero.
Продолжайте следить за нашими публикациями, в которых мы стараемся делиться с вами опытом использования Tibero. | https://habr.com/ru/post/352560/ | null | ru | null |
# Tree — единый AST чтобы править всеми
Здравствуйте, меня зовут Дмитрий Карловский и я… рассекаю на велосипедах… по бездорожью… против ветра… в гору… на лыжах. И сегодня я приглашаю вас прокатиться со мной вдоль и поперёк текстовых форматов данных и вместе спроектировать идеальный формат.
Я уже [рассказывал о нём](https://habr.com/ru/post/248147/) 5 лет назад, что привело к жарким дебатам, повлёкшим за собой небольшие изменения синтаксиса. Поэтому позвольте рассказать с чистого листа что он представляет из себя на текущий момент.
```
Спикер \Дмитрий Карловский
Место \PiterJS #47
Время 2020-05-20
```
Это — расширенная текстовая версия одноимённого выступления на [PiterJS#47](https://medium.com/piterjs/%D0%B0%D0%BD%D0%BE%D0%BD%D1%81-piterjs-47-cf7cb666834a). Вы можете [читать её как статью](https://github.com/nin-jin/slides/blob/master/tree/readme.md), либо [открыть в интерфейсе проведения презентаций](https://nin-jin.github.io/slides/tree/), либо [посмотреть видео](https://youtu.be/pev6g_oysUs?t=5518).
План
====
* Проанализировать популярные текстовые форматы данных
* С нуля разработать новый формат без недостатков
* Показать примеры применения нового формата
Форматы
=======
Сравнивать мы будем 5 форматов.
| **Формат** |
| --- |
| XML |
| JSON |
| YAML |
| TOML |
| Tree |
Про первые три не слышал только глухой. А вот два последних для многих — тёмные лошадки. Ну ничего, сегодня я пролью на них свет.
Пример XML
----------
XML — некогда самый популярный формат, можно сказать "технологический стандарт". Но не смотря на всю свою мощь, сейчас он изживает своё, так как является слишком сложным для современного веб-разработчика.
```
xml version="1.0" encoding="UTF-8" standalone="no"?
```
Пример JSON
-----------
На смену XML приходит более простой и дерзкий формат данных — JSON.
```
{
"name": "example",
"version": "1.0.0",
"description": "example package",
"main": "index.js",
"repository": "https://example.org",
"author": "anonymous",
"license": "MIT"
}
```
Если вы считаете, что вот он, идеал, то прошу меня заранее извинить, так как далее я буду вас расстраивать.
Пример YAML
-----------
Кто-то уже пророчит YAML на смену JSON.
```
Date: 2001-11-23 15:03:17 -5
User: ed
Fatal:
Unknown variable "bar"
Where:
file: TopClass.py
line: 23
code: |
x = MoreObject("345\n")
```
Благодаря лучшей человекочитаемости он уже обрёл популярность в сфере ручного написания конфигурационных файлов.
Пример TOML
-----------
Про TOML же мало кто слышал. Однако, взгляните на пример и вам станет ясно, почему я о нём вообще упоминаю.
```
[servers]
[servers.alpha]
ip = "10.0.0.1"
dc = "eqdc10"
[servers.beta]
ip = "10.0.0.2"
dc = "eqdc10"
```
Да, это фактически, стандартизированный INI-конфиг, которого покусал JSON. В результате чего он вобрал в себя худшее из обоих миров.
Пример Tree
-----------
Наконец, в качестве спойлера, позвольте показать вам минимальный не пустой файл в формате Tree, который мы и будем разрабатывать далее.
```
spoiler
```
Модели данных
=============
Разные форматы основаны на разных моделях данных. Выбранная модель отвечает на следующие два вопроса.
* Какие данные мы можем записать и прочитать без бубна?
* Как записывать данные не вписывающиеся в модель?
Ни один формат не способен поддержать всё многообразие типов предметных областей, поэтому неизбежно возникает необходимость упаковки данных в некоторый формат и последующей обратной распаковки.
Модель XML
----------
XML основан на модели типизированных элементов в которых находится один словарь атрибутов и один список вложенных типизированных узлов.
* NodeList
* Element Node ()
* Attribute Node (`tabindex="1"`)
* Text Node (`Hello, World!`)
* CDATA Node ( `...` )
* Processing Instruction Node ( `... ?`)
* Comment Node ()
* Document Node
* Document Type Node ()
### Недостатки модели XML
Это довольно гибкая модель, однако она имеет ряд ограничений: значениями атрибутов могут быть только строки, а вложенный список узлов может быть только один. Не смотря на то, что формат XML и так не самый простой, банальный словарь с поддеревьями в качестве значений требует дополнительных соглашений. Например, такого: некоторые элементы используются для описания ключей в родительском элементе и такие элементы в родительском должны быть лишь в одном экземпляре.
```
Вы уверены?
Да
Нет
```
Тут `panel` — это компонент, а `body` — уже не компонент, а параметр. Ему бы место в атрибутах, да только в атрибуты можно лишь строки помещать и ничего более.
### Расширяемость модели XML
Благодаря пространствам имён, в рамках одного XML документа могут вперемешку идти множество языков, не ломая интерпретацию друг друга.
```
```
Это — очень мощная техника, которой не хватает в более молодых форматах.
Модель JSON
-----------
Модель JSON основана на том, что всё дерево состоит из не типизированных списков и словарей. Плюс ограниченный набор примитивов в качестве листьев дерева.
* Null
* Boolean
* Number
* String
* Array
* Dictionary
### Недостатки модели JSON
Наивно было бы полагать, что двух типов структурных узлов хватит для всего. Например, возьмём словарь. Ключи в нём не упорядочены, то есть могут возвращаться парсером в любом порядке.
```
{
"foo": 777,
"bar": 666
}
```
А если нам нужен словарь с упорядоченными ключами?
```
[
[ "foo" , 777 ],
[ "bar" , 666 ]
]
```
Нам пришлось кардинально поменять синтаксис и налепить массивы массивов. А ведь это всего-лишь другой тип словаря.
### Нерасширяемость модели JSON
Ну и самый главный недостаток модели JSON в её нерасширяемости, из-за чего приходится вводить кучу хитрых правил, чтобы упихнуть всё многообразие прикладных типов их отношений. Возьмём для примера запрос к MongoDB, авторы которой решили, что JSON отлично походит на роль языка запросов.
```
{
"$or": [
{
"sex": "female",
"age": { "$gt": 16 },
},
{
"hobby": {
"$regex": "\\b(?:java|type)script\\b"
}
}
]
}
```
Мы видим, что парные логические операции OR и AND имеют совершенно различный синтаксис. Предиката равенства катастрофически не хватает, ведь нужны ещё предикаты "больше", "меньше" и даже "соответствует регулярному выражению". И, кстати, сами регулярные выражения не представимы в JSON иначе как в виде строки и соглашения, что если она находится в словаре для ключа с именем "$regexp", то это сериализованная регулярка и при парсинге нужно создать соответствующий объект.
Модель YAML
-----------
Модель YAML во многом аналогична модели JSON. Разве что тут есть поддержка времени и внутренних ссылок.
* !!null
* !!bool
* !!int
* !!float
* !!str
* !!timestamp
* !!seq
* !!map
* Anchor & Alias
* Document
* **TypeTags**
### Расширяемость модели YAML
Главное преимущество YAML в аннотациях типа, позволяющих объяснять процессору какой алгоритм использовать для распаковки данных.
```
--- !!omap
- foo: 777
- bar: 666
```
В данном примере мы говорим парсеру "возьми этот список пар ключ-значение" и преобразуй его в объект OrderedMap (упорядоченный словарь).
Модель TOML
-----------
Модель TOML как у JSON, но чуть более приземлённая. Например, тут различаются целые и вещественные числа, что важно для компилируемых языков, а так же есть поддержка времени.
* Boolean
* Integer
* Float
* String
* DateTime
* Array
* Dictionary
С расширяемостью же тут всё так же плохо, как и в JSON.
Модель Tree
-----------
Какой бы набор базовых типов мы ни выбрали, его не хватит для всего. А значит неизбежно потребуется некоторый код упаковки и распаковки. А работать с таким кодом проще всего, когда число разных типов узлов минимально, так как для каждого типа требуется писать отдельную ветку логики. В то же время гибкость требуется максимальная. Поэтому нам хватит всего двух типов узлов.
* Struct Node
* Data Node
Структурные узлы служат для описания иерархии, а узлы данных хранят сырые бинарные данные. Любой узел может хранить в себе список любых других узлов, чем достигается недостижимая в иных форматах гибкость.
Расширяемость модели
--------------------
Итого, по расширяемости всё очень плохо. Популярные форматы либо расширяемые, но неимоверно переусложнённые, либо простые, но совершенно не расширяемые.
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Расширяемость | + | - | + | - | + |
| Число паттернов | 90 | 30 | 210 | 90 | **10** |
Обратите внимание на YAML. Его грамматика насчитывает две сотни паттернов. Он настолько сложен, что вы скорее всего не найдёте ни одной полной и правильной реализации его парсера. Да что уж там, даже два одинаково работающих парсера JSON [нужно ещё поискать](https://habr.com/ru/company/mailru/blog/314014/), а ведь там всего казалось бы 30 паттернов.
Нашей целью же будет создание предельно простого, не допускающего разночтений, но в то же время максимально расширяемого формата.
Удобочитаемость
===============
Наглядность синтаксиса важна при самых различных сценариях работы с форматом: при написании, при ревью кода, при разрешении конфликтов, при отладке, при изучении.
Скорость вашей работы и предсказуемость её результатов напрямую зависит от способа сериализации формата. Однако у некоторых форматов с этим серьёзные проблемы.
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Удобочитаемость | - | - | + | + | + |
Удобочитаемость XML
-------------------
XML построен вокруг текста, внутрь которого вкрапляются теги с дополнительной информацией. Пока этой информации не много, всё хорошо, но чем её больше, тем сложнее воспринимать текст, что нивелирует полезность этой фичи.
```
Привет, Алиса!
Как дела?
Не могла бы ты принести мне сейчас кофе?
Привет, [Алиса](http://example.org/user/alice)!
~~Как дела?~~
Не могла бы ты принести мне
сейчас
кофе?
```
Удобочитаемость JSON
--------------------
XML хотя бы поддерживает многострочный текст, а вот JSON, например, этим похвастаться уже не может. Форматы этого типа идут от информационной структуры, в которую уже вкрапляются текстовые и не только текстовые значения.
```
{ "greetings": "Привет, Алиса!\nКак дела?\nНе могла бы ты принести мне кофе?\n" }
```
Строгость
=========
Как правило с пониманием написанного нет никаких проблем. Но YAML тут отличился.
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Однозначный синтаксис | + | + | - | + | + |
Нестрогость YAML
----------------
```
a: true # boolean
b: tru # string
c: (-: # error
d: :-) # string
```
Вот таких приколов в YAML довольно много.
Экранирование
=============
Близкая к читаемости тема — это экранирование. Наличие оного в той или иной мере неизбежно приводит к снижению читаемости. При разработке экранирования стоит иметь ввиду следующие моменты.
* Нужно отличать конструкции формата от собственно данных
* Желательно не терять в наглядности данных
* Желательно не переусложнять редактирование
Экранирование в XML
-------------------
XML — чудесный пример, как делать экранирование не надо.
```
foo > 0 && foo < 10
```
Из простого и наглядного текста получается какой-то криптотекст, который приходится мысленно интерпретировать, чтобы понять что тут написано.
```
`foo > 0 && foo < 10`
```
Экранирование в JSON
--------------------
Похожая проблема есть и в JSON, хоть и в меньшей мере. Если вы когда-нибудь писали плагины для подсветки синтаксиса VSCode, то знаете, что грамматики там описываются именно в JSON формате, куда записываются регулярные выражения.
```
/"[\s\S]*"/
```
Регулярки и сами по себе не самые наглядные штуки, а заэкранированные и того хуже. Допустить в них ошибку в таких условиях очень просто, а дебажить это не очень-то легко.
```
"\"[\\s\\S]*\""
```
Экранирование в YAML
--------------------
В YAML проблему экранирования в целом решили, но какой ценой.
* 5 типов строк
* 4 модификатора обработки пробелов
И всё это вам нужно знать, чтобы правильно прочитать любой YAML файл.
Экранирование в Tree
--------------------
```
Нет
```
Самое удобочитаемое экранирование — это отсутствие экранирования. Поэтому у нас его не будет. Вы возможно подумали, что я сошёл с ума, но чуть позже я покажу, как этого добиться.
Минификация
===========
Многие форматы поддерживают различные способы форматирования одних и тех же данных. Но это всегда компромисс между размером и удобочитаемостью.
* Читаемое форматирование много весит
* Компактное форматирование плохо читается
Минификация XML
---------------
```
Alice
20
```
Если минифицировать XML, то можно сэкономить несколько десятков процентов в размере, но результат получается ещё сложнее читать.
```
Alice20
```
Минификация JSON
----------------
```
{
"users": [
{
"name": "Alice",
"age": 20
}
]
}
```
С JSON экономия чуть больше, но и читаемость страдает сильнее — вместо закрывающих тегов мы видим вереницу квадратных и фигурных скобочек.
```
// 30% less
{"users":[{"name":"Alice","age":20}]}
```
Минификация Tree
----------------
```
Нет
```
Наш путь бескомпромиссный — формат должен быть одновременно и предельно компактным, и легко воспринимаемым человеком.
Статистика по минификации
-------------------------
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Читаемый | 195% | 140% | 125% | 110% | **100%** |
| Минифицированный | 170% | **101%** | - | - | - |
Скачать [файлы примеров](https://github.com/nin-jin/tree.d/tree/master/formats).
Как видите, можно сделать формат, который в читаемом виде весит меньше, чем любой другой, даже если их минифицировать. Весь секрет в том, чтобы читаемость достигалась самой структурой формата, и не требовала дополнительного форматирования, раздувающего объём.
Священные войны
===============
Частая проблема при работе с различными форматами — это бесконечные споры о, казалось бы, мелочах.
* Табы или пробелы?
* 2 или 4 пробела?
* возврат каретки нужен?
* выравнивание делаем?
* правила линтера/форматера?
* при сохранении/комите/пуше?
Эти споры отнимают время и эмоции, но они совершенно бессмысленны. Лучше, если формат будет иметь единые, чётко заданные правила, которые одинаково понимаются любым инструментом и человеком. Поэтому наш формат будет предельно жёстким, без каких-либо вольностей.
Скорость обработки
==================
Простота, жёсткость и отсутствие экранирования потенциально даёт куда большую возможную скорость обработки.
Например, в JSON, чтобы записать произвольную строку, нужно пройтись по каждому символу и перед определёнными вывести в выходной буфер обратную косую черту. То есть мы даже не можем заранее узнать сколько памяти нам на выделить для выходного буфера. А во время парсинга нужно делать обратную операцию с формированием новой строки. Мы не можем переиспользовать исходный кусок памяти.
```
serialization: foo\bar => "foo\\bar"
parsing: "foo\\bar" => foo\bar
```
Когда же у нас нет экранирования, мы можем просто брать куски памяти и как есть отправлять в выходной поток при сериализации, что очень быстро. И наоборот, при парсинге мы можем просто ссылаться на куски исходного буфера и не делать лишних выделений памяти.
Координаты ошибки
=================
Во время парсинга часто теряется информация об исходном расположении получаемых из формата узлов. Например, мы получили JSON, начали его обработку, и где-то в глубине вдруг поняли, что в базе данных у нас нет того пользователя, что указан в файле. В этот момент мы должны показать ошибку, но в тексте этой ошибки мы не можем указать в каком месте какого именно файла она допущена. Всё потому, что эта информация при парсинге теряется. И это весьма распространённая проблема.
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Адрес | + | - | - | - | + |
| Позиция | - | - | - | - | + |
| Диапазон | - | - | - | - | + |
В XML-узлах есть ссылка на ресурс из которого он получен, но где он в этом ресурсе — ищите глазами. Для решения этой проблемы есть специальные парсеры, которые дают на выходе не массивы и словари, а Абстрактное Синтаксическое Дерево. Но работать с ним уже не так-то просто, да ещё и медленно это дело.
Чтож, информация эта важная, и я предлагаю её не терять. Никогда не терять. Сохранение координат узлов нам ещё пригодится, когда речь пойдёт об AST и сорсмапах.
Поточная обработка
==================
Бывает, что данных много, а памяти мало, но работать с данными нужно быстро. А бывает, что данные вообще не кончаются. Например, вам нужно непрерывно обрабатывать логи по мере их поступления. В этих случаях спасают возможности по поточной обработке данных.
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Поточная обработка | - | - | + | + | + |
Как видно, самые распространённые форматы не имеют поддержки поточной обработки. Они требуют, чтобы у вас был ровно один завершённый корень документа, иначе — ошибка парсинга. В случае постоянно поступающих данных типа логов, например, дописывать их в документ, сохраняя его корректность — задача не из простых.
Это не значит, что к ним нельзя прикрутить поточную обработку. Например, для XML есть более низкоуровневые SAX парсеры, позволяющие вам работать не с деревом элементов, а с потоком тегов: открылся такой-то тег, пришла строка, закрылся такой-то тег. А для JSON есть целая [вязанка протоколов стриминга сообщений](https://en.wikipedia.org/wiki/JSON_streaming). Основная проблема тут в том, что далеко не любой поддерживающий формат инструмент сможет переварить ваши данные без дополнительных телодвижений.
Форматы же поддерживающие поточную обработку, можно легко дополнять дописыванием данных в конец. Можно склеивать несколько потоков данных в один и, наоборот, нарезать на части. Можно обрабатывать по частям, не дожидаясь завершения передачи. И всё это без потери корректности работы с форматом.
Формат Tree
===========
Что ж, резюмируя ранее сказанное, давайте сформулируем все требования для нашего нового формата.
* Простота синтаксиса
* Никакого экранирования
* Никаких вольностей
* Никакой минификации
* Минимальный размер
* Гарантированная читаемость
* Поточная обработка
* Точные координаты узлов
Просто tree-узел
----------------
Итак, нам нужно создать узел с именем "house". Какой минимальный код для этого нужен?
```
house
```
Просто пишем это имя и всё.
Список tree-узлов
-----------------
А если нам нужен не один узел, а целый список?
```
house
roof
wall
door
window
floor
```
Просто пишем их на отдельных строках.
Вложение tree-узлов
-------------------
Но что если мы хотим добавить иерархичности и поместить список узлов внутрь первого?
```
house
roof
wall
door
window
floor
```
Просто пишем вложенные узлы с табом в качестве отступа. Знакомые с языком Python тут могут заметить похожий подход — использование хорошего стиля форматирования кода в качестве основы синтаксиса, а не опциональной возможности.
Глубокая tree-иерархия
----------------------
Продолжая добавлять отступы мы можем создавать иерархии любой вложенности.
```
house
roof
wall
door
window
glass
floor
```
Один дома
---------
Часто бывают ситуации, когда вложенный узел только один и тогда увеличивать из-за него уровень отступа для всех вложенных в него узлов будет как-то расточительно.
```
street
house
wall
door
window
```
Поэтому просто выстраиваем такие узлы в одну линию, разделяя пробелами.
```
street house wall
window
door
```
Узлы же записанные с отступом уже вкладываются в последний узел на предыдущей линии.
Сырые данные
------------
Когда же нам нужно записать произвольные данные, символы в которых не должны как-то по особому обрабатываться, просто пишем их после обратной косой черты без какого-либо экранирования.
```
\Любые данные \(^_^)/
```
Обратная косая черта выбрана для ассоциации с экранированием. Она как бы экранирует весь текст до конца строки. Но, если быть точными, то это скорее не экранирование, а своеобразные кавычки. Обратная косая черта — открывающая, а символ перевода строки — завершающая.
Многострочные данные
--------------------
Но как записать всё же многострочный текст содержащий в том числе и символы перевода строки? Всё просто: берём узел данных и помещаем в него список других узлов данных.
```
\
\Тут
\ много
\ котиков
```
При запросе строкового содержимого корневого узла данных все вложенные узлы данных будут соединены через символ перевода строки.
Разные типы узлов
-----------------
Наконец, оба типа узлов мы можем использовать вперемешку в любых комбинациях. Например, опишем некоторого пользователя.
```
user
name \Jin
age \35
hobby
\kendo
\dance
\role play
default
```
Как видите, всё довольно просто. Для создания самого продвинутого формата данных нам потребовалось всего 2 типа узлов и 4 спецсимвола.
Языки основанные на форматах
============================
Пока что мы говорили лишь про форматы, то есть про способы сериализации. На их основе уже проектируются языки, добавляющие семантику абстрактным узлам формата.
| Формат | **Языки** |
| --- | --- |
| XML | XHTML, SVG, XSLT, ... |
| JSON | JSON Schema, json:api, ... |
| YAML | [yaml.org/type](http://yaml.org/type) |
| TOML | - |
| Tree | [xml.tree, json.tree, view.tree, ...](https://github.com/nin-jin/tree.d/wiki/tree-based-languages) |
Любой язык — это некоторое подмножество модели данных формата с ограничениями на возможные типы узлов, их взаимное расположение и содержимое.
Далее я покажу несколько примеров таких языков для формата tree.
Язык grammar.tree
-----------------
Язык [grammar.tree](https://github.com/nin-jin/tree.d/wiki/grammar.tree) — предназначен для описания формальных грамматик. К примеру, давайте напишем полную формальную грамматику собственно формата tree.
```
tree .is .optional .list_of line
line .is .sequence
.optional indent
.optional nodes
new_line
nodes .is .sequence
.optional .list_of struct
.optional data
.with_delimiter space
struct .is .list_of .byte
.except special
```
```
data .is .sequence
data_prefix
.optional .list_of .byte
.except new_line
special .is .any_of
new_line
data_prefix
indent
space
new_line .is .byte \0A
indent .is .list_of .byte \09
data_prefix .is .byte \5C
space .is .list_of .byte \20
```
Как видите, грамматика формата реально предельно простая, что позволяет буквально за час написать парсер на любом языке не прибегая даже к генераторам парсеров.
Читать такую грамматику можно буквально: tree — это опциональный список линий, а линия — это последовательность из опционального отступа, опционального списка узлов и обязательного символа перевода строки. Ну и так далее.
Язык grammar.tree vs EBNF
-------------------------
Сравнивая grammar.tree с [Расширенной Формой Бэкуса Наура](https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form) можно обратить внимание, что первый несколько многословен, но понятен и лаконичен, а последний — компактен, но для понимания требует предварительной подготовки, выразительные возможности всё же несколько уступают, а его ориентация на однострочное представление выглядит несколько неуклюже при многострочной записи.
```
tree .is .optional .list_of line
line .is .sequence
.optional indent
.optional nodes
new_line
nodes .is .sequence
.optional .list_of struct
.optional data
.with_delimiter space
```
```
tree = { line };
line = [ indent ],
[ nodes ],
new_line;
nodes = data |
struct,
{ space , struct },
[ space , data ];
```
Язык xml.tree vs XML
--------------------
Язык [xml.tree](https://github.com/nin-jin/tree.d/wiki/xml.tree) — это способ представления модели данных XML в tree формате. Из него можно генерировать любого вида XML. И наоборот, любой XML может быть сконвертирован в xml.tree.
```
! doctype html
html
meta @ charset \utf-8
link
@ href \web.css
@ rel \stylesheet
script @ src \web.js
body
h1 \Procter & Gamble
```
```
Procter & Gamble
================
```
Было бы классно иметь такую интеграцию в IDE, чтобы открывая любой XML можно было видеть и редактировать его xml.tree представление, но сохранялось бы всё обратно в XML. Это позволило бы больше не ломать глаза об амперсанды и позволило бы работать с XML так же легко и просто, как и, например, с markdown.
Язык json.tree vs JSON
----------------------
А [json.tree](https://github.com/nin-jin/tree.d/wiki/json.tree) — это язык для описания модели json.
```
* user *
name \Jin
age 35
hobby /
\kendo
\dance
home \C:\users\jin\
```
```
{
"user": {
"name": "Jin",
"age": 35,
"hobby": [
"kendo ",
"dance ",
],
"home": "C:\\users\\jin\\"
}
}
```
Нам потребовалось лишь 2 спецсимвола — звёздочка для обозначения словарей и косая черта для обозначения массивов.
Расширения json.tree
--------------------
Прелесть языков, основанных на таких форматах как XML и Tree в том, что их легко расширять оставаясь в рамках формата. Например, и json, и tree как форматы принципиально не поддерживают комментарии. Но, например, в конфигах комментарии необходимы. Как же быть?
```
*
# \If disabled will be used platform specific delimiters
# \CRLN on windows and LN on others
unix_delimiters true
```
В tree мы легко расширили язык под наши нужды, добавив специальный тип узла для комментариев.
```
{
"unix_delimiters#1": "If disabled will be used platform specific delimiters",
"unix_delimiters#2": "CRLN on windows and LN on others",
"unix_delimiters": true,
}
```
В JSON же сказывается ограниченность модели, из-за которой приходится писать костыли.
Язык view.tree vs TypeScript
----------------------------
Язык [view.tree](https://github.com/eigenmethod/mol/tree/master/view#viewtree) — используется для композиции компонент в [разработанном мной фреймворке $mol](https://github.com/nin-jin/HabHub/issues/23).
```
$my_details $mol_view
sub /
<= Pager $mol_paginator
value?val <=> page?val 0
```
Тут описан компонент, который владеет другим компонентом и их свойства двусторонне связаны друг с другом. Можете обратить внимание, что внутри view.tree используются в том числе и язык json.tree для описания массивов, словарей, чисел и прочих JSON типов.
Из такого простого и лаконичного кода генерируется довольно развесистый TypeScript класс. Писать его руками можно, но муторно и без иерархии не очень наглядно.
```
class $my_details extends $mol_view {
sub() { return [ this.Pager() ] }
@ $mol_mem Pager() {
const Pager = new $mol_paginator
Pager.value = val => this.page( val )
return Pager
}
@ $mol_mem page( val = 0 ) {
return val
}
}
```
API
===
Наконец, есть различные API для взаимодействия с форматом из разных языков программирования.
| Формат | Языки | **API** |
| --- | --- | --- |
| XML | XHTML, SVG, XSLT, ... | DOM, SAX, AST |
| JSON | JSON Schema, json:api, ... | Native, AST |
| YAML | yaml.org/type | Native, AST |
| TOML | - | Native, AST |
| Tree | xml.tree, json.tree, ... | AST |
Для XML, например, есть довольно гибкий DOM, а есть низкоуровневый SAX. Форматы, пришедшие ему на смену, в основном возвращают нативные для языка словари, массивы и тд. Правда модель данных JSON не очень хорошо представляется в компилируемых языках, где целые числа и числа с плавающей точкой — это совершенно разные типы. Ну и разумеется для всех языков есть представление в виде Абстрактного Синтаксического Дерева. Правда обычно оно медленное и неудобное. Мы же сделаем это быстрым и удобным, что позволит нам не городить зоопарк несовместимых API.
JSON AST
--------
Возьмём простой JSON файл и засунем его в [ASTExplorer](https://astexplorer.net/).
```
{
"user": {}
}
```
```
{
"type" : "Object",
"children" : [
{
"type" : "Property",
"key" : {
"type": "Identifier",
"value": "user"
}
"value": {
"type": "Object",
"children": []
}
}
]
}
```
Как видно, AST получился большим и сложным. JSON вообще очень плохо подходит для описания AST. Без специальных утилит с ним работать не очень просто.
AST Tree
--------
Теперь давайте возьмём несколько более сложный tree файл.
```
user
name \Jin
age 35
hobby
\kendo
\dance
\role play
```
И посмотрим на его AST.
```
user
name \Jin
age 35
hobby
\kendo
\dance
\role play
```
Так, что-то не так. Это же тот же самый код. А, нет, всё правильно, tree — сам себе AST.
Свойства узла Tree
------------------
В реализация на TypeScript каждый узел имеет примерно следующий интерфейс.
```
interface $mol_tree2 {
type: string
value: string
kids: $mol_tree2[]
span: $mol_span
}
```
Span — это ссылка на серию байт в исходном ресурсе.
```
interface $mol_span {
uri: string
row: number
col: number
length: number
}
```
Производные Tree узлы
---------------------
У каждого узла есть методы для создания новых узлов, на его основе. Эти фабрики, создавая новые узлы, просовывает в них span от оригинального узла. Это позволяет даже после десятков преобразований понять с чего всё началось.
```
interface $mol_tree2 {
struct : ( type , kids )=> $mol_tree2
data : ( value , kids )=> $mol_tree2
list : ( kids )=> $mol_tree2
clone : ( kids )=> $mol_tree2
}
```
Сообщения об ошибках в Tree
---------------------------
Для примера, возьмём конфиг, найдём в нём пароль и если он не подойдёт — кинем исключение, где будет написано в каком месте какого файла написан неправильный пароль.
```
const config_path = './config.tree'
const config_text = fs.readFileSync( config_path )
const config = $mol_tree2.fromString( config_text , config_path )
// server auth
// login \root
// password \qwerty
const password = config.select( 'server' , 'auth' , 'password' , '' )
if( !auth( password.text() ) ) {
// AuthError: Wrong password
// \default
// ./config.tree#5:3-11
throw password.error( 'Wrong password' , AuthError )
}
```
Обработка Tree
==============
Или другой пример — мы решили, что "auth" неудачное название и нужно заменить его на "credentials". Поэтому мы пишем не сложный скрипт для автоматического рефакторинга:
```
// server credentials
// login \root
// password \qwerty
const new_config = config.list(
input.hack({
'auth' : ( tree , context )=> [
tree.struct( 'credentials' , tree.hack( context ) ),
] ,
'' : ( tree , context )=> [
tree.clone( tree.hack( context ) ),
] ,
})
)
fs.writeFileSync( config_path , new_config )
```
И таким образом вы можете легко рефакторить любые языки, основанные на tree формате, без поиска для каждого языка отдельного парсера и разбирательства с тем, как у него происходит работа с AST.
Поддержка редакторами
=====================
* [VSCode](https://github.com/nin-jin/vscode-language-tree)
* [Atom](https://github.com/nin-jin/atom-language-tree)
* [Sublime](https://github.com/yurybikuzin/Smol-sublime)
* [SynWrite](http://www.uvviewsoft.com/synwrite/)
Если вы пользуетесь редактором для которого ещё нет плагина, то это хорошая возможность реализовать его. Сделать это будет проще, чем для любого другого языка.
Поддержка языками
=================
* [TypeScript](https://github.com/eigenmethod/mol/tree/master/tree2)
* [D](https://github.com/nin-jin/tree.d)
Опять же, призываю заинтересовавшихся реализовать поддержку в своём любимом языке и попробовать применить его с пользой.
Итоги
=====
| | XML | JSON | YAML | TOML | Tree |
| --- | --- | --- | --- | --- | --- |
| Размер | 195% | 140% | 125% | 110% | **100%** |
| Число паттернов | 90 | 30 | 210 | 90 | **10** |
| Однозначный синтаксис | + | + | - | + | + |
| Удобочитаемость | - | - | + | + | + |
| Не нужно экранирование | - | - | - | - | + |
| Точные координаты узлов | - | - | - | - | + |
| Поточная обработка | - | - | + | + | + |
| Расширяемая модель данных | + | - | + | - | + |
| Широкая распространённость | + | + | + | - | - |
Идеи
====
А теперь давайте пофантазируем, чего ещё интересного можно сделать используя tree формат.
* Запросы к СУБД
* Логирование
* Общение консольных утилит
* LISP-подобный язык
* Универсальный AST
sql.tree — запросы к СУБД
-------------------------
Помните неуклюжие запросы к MongoDB? Давайте попробуем написать свой SQL:
```
select
from $users
fetch
@name
@phone
@photo *
@uri
@width
@height
where or
and
@sex = female
@age > 16
@hobby ~ \\b(?:java|type)script\b
```
В такой форме запрос распарсить — плёвое дело, в отличие от [настоящего SQL](https://github.com/mozilla/moz-sql-parser/blob/dev/moz_sql_parser/sql_parser.py). Обратите внимание, что на единообразный синтаксис для логических операций и предикатов "равно", "больше" и даже "соответствует регулярке". Кстати, регулярку ведь тоже можно описать в формате tree, что сделает её куда более поддерживаемой.
```
select
from $users
fetch *
where @hobby ~
word-edge
or
\java
\type
\script
word-edge
```
domain.tree — описание домена
-----------------------------
Раз уж мы заговорили о базах данных. Примерно так я описываю модель предметной области.
```
hyoo_api_person
descr \Живой пользователь сервиса
inherit hyoo_api_entity
field
id
descr \Уникальный человекопонятный идентификатор
example \person=jin
key unique
type text
edit author
avatar
descr \Ссылки на аватары
type list hyoo_api_image
edit author
mail
descr \Привязанные имейлы
type set hyoo_api_mail
```
Из такого формального описания автоматически формируется серверный API, правила ACL, схема СУБД и админка для управления всем этим делом.
Логи
----
Распространённая практика выводить в логи однострочные сообщения. Пока они влезают по ширине в ваш терминал — всё хорошо, но это довольно редкая ситуация. Куда чаще сообщения всё же не влезают и начинают переноситься, превращая поток сообщений в настоящее месиво, которое и глазами сложно прочитать, да и программно обрабатывать их — боль и страдания.
access.log.tree — структурированные логи
----------------------------------------
А что если логи сразу выводить в двумерном виде, одновременно легко читаемом как машинами, так и человеком?
```
193.34.12.132 - - [2011-10-20T12:46:08+04:00] GET /nin-jin/slides/edit/master/t
ree/readme.md HTTP/1.1 200 4435
193.34.12.132 - - [2011-10-20T12:46:09+04:00] GET /nin-jin/slides/edit/master/t
ree/readme.html HTTP/1.1 404 4435
access
ip \193.34.12.132
time \2011-10-20T12:46:08+04:00
method \GET
uri \/nin-jin/slides/edit/master/tree/readme.md
protocol \HTTP/1.1
response \200
size \4435
```
tree-tools — CLI утилиты обработки деревьев
-------------------------------------------
Можно написать утилиты, которые бы позволили просто и эффективно обрабатывать такие логи. Например, прочитаем лог, отфильтруем по значению одного из полей, выберем из сообщений лишь интересные нам поля и выведем их табличкой.
```
> cat access.log.tree | pick ip time method uri | table
\193.34.12.132 2011-10-20T12:46:08+04:00 GET /index.html
\193.34.12.132 2011-10-20T12:46:10+04:00 GET /index.css
\193.34.12.132 2011-10-20T12:46:20+04:00 GET /index.js
> cat access.log.tree | filter time >= 2019-09 | pick ip uri | table
\193.34.12.132 /index.html
\193.34.12.132 /index.css
\193.34.12.132 /index.js
```
У меня есть [прототип такой утилиты](https://github.com/hyoo-ru/mill/), который я иногда использую для просмотра логов дев-сервера в реальном времени. Будет классно, если кто-то возьмётся реализовать полный комплект инструментария. А когда будут инструменты, тогда и у разработчиков софта будет мотивация писать логи не как попало, а структурированно.
tree как протокол общения
-------------------------
Можно пойти дальше и не просто писать логи в формате tree, а в принципе продвинуть идею, что вывод любой программы должен быть структурированным. У многих утилит есть флаги для вывода ответа в виде JSON или XML, но человеку читать такой вывод напряжно — приходится переоткрывать выдачу в инструментах наглядного представления, чтобы понять что там возвращается и как этому подступиться. Только представьте себе мир, где выдачу можно прочитать и тут же как-то её преобразовать, не ковыряя маны в поисках нужной комбинации ключей очередной программы.
```
> git log
commit
message \$mol_style: TS@3.9 compatibility
sha \b1a8f07c839604d0d34430a186246f0c1f71e628
date \2020-05-15T23:24:32+0300
author \nin-jin
commit
message \$mol\_regexp: concurent parse ability
sha \be1abfa50542728dd5c156517ea31f469e7fb4d4
date \2020-05-15T23:03:30+0300
author \nin-jin
> git log | pick date message | table
\2020-05-15T23:24:32+0300 $mol\_style: TS@3.9 compatibility
\2020-05-15T23:03:30+0300 $mol\_regexp: concurent parse ability
```
WAT
---
WebAssembly — перспективный ассемблер, опускающийся настолько близко к машине на сколько это возможно без потери портабельности. Для него есть текстовый формат представления, основанный на лисповых s-expressions.
```
(func $fact (param $x i64) (result i64)
(if $x (result i64)
(i64.eqz
(local.get $x))
(then
(i64.const 1))
(else
(i64.mul
(local.get $x)
(call $fact
(i64.sub
(local.get $x)
(i64.const 1)))))))
```
Его сложно воспринимать как ни форматируй. К сожалению, именно такого рода код вы будете видеть при дизассемблировании в браузерных девтулзах.
wasm.tree — ассемблер без мишуры
--------------------------------
Я сейчас работаю над компилятором в байт коды более наглядного wasm.tree описания.
```
func
name $fact
param $x i64
result i64
body switch
test i64.eqz local.get $x
then i64.const 1
else i64.mul
local.get $x
call $fact i64.sub
local.get $x
64.const 1
```
Из этого ассемблера генерится список байт-кодов на языке [bin.tree](https://github.com/nin-jin/tree.d/wiki/bin.tree), который уже элементарной функцией перегоняется в бинарник.
```
00
61
73
6d
01
00
00
00
.
.
.
```
Когда будет что-то более-менее завершённое — попробую протолкнуть этот синтаксис в качестве WAT2.0. Кому не безразлична судьба WebAssembly — присоединяйтесь к разработке.
jack.tree — LISP без скобочек
-----------------------------
На самом деле писать на сыром ассемблере слишком многословно. Поэтому следующим шагом идёт реализация мета-языка, позволяющего расширять язык средствами самого этого же языка. Ядро такого языка должно получиться предельно минималистичным, а все идиомы в него будут подключаться как сторонние библиотеки, написанные на этом же языке.
```
jack
import wasm
tree func $fact
> $x #8
< #8 switch
test is-zero $x
then #8 1
else mul
$x
$fact sub
$x
#8 1
```
Грубо говоря, программа на этом языке итеративно модифицирует свой собственный AST таким образом, что на выходе получается wasm-бинарник. Звучит, возможно, пугающе, но благодаря тому, что tree сохраняет координаты исходников, проследить источник ошибки не составляет труда. В репозитории можно глянуть куцый прототип.
[$mol\_jack](https://github.com/eigenmethod/mol/tree/master/jack)
Упраздняя LLVM
==============
Можно пойти ещё дальше и генерировать не wasm байткоды, а прямо таки байткоды целевого процессора, просто добавив ещё один трансформер в пайплайн.
```
compile pipelines:
jack.tree => wasm.tree =============> bin.tree
jack.tree => wasm.tree => arm.tree => bin.tree
any-dsl.tree => jack.tree => wasm.tree => arm.tree => bin.tree
```
При этом на любом уровне можно запускать дополнительные трансформеры, которые смогут оптимизировать код, применяя информацию, доступную на соответствующих уровнях абстракции.
```
optimization midlewares:
jack.tree => jack.tree
wasm.tree => wasm.tree
arm.tree => arm.tree
```
При этом, напомню, мы не теряем связь с оригинальными исходниками, что позволит выводить адекватные сообщения. А любое промежуточное AST можно всегда сдампить в текст в весьма наглядной форме tree формата.
Опять же, присоединяйтесь к разработке, это может получиться крутая штука на замену LLVM.
Единый AST чтобы править всеми
------------------------------
Ну и, наконец, мы подошли ко главной мысли этого доклада. Tree — это прям идеальный кандидат на место универсального связующего AST. Вы только посмотрите, какой длинный пусть проходит TypeScript код от исходников до результирующего бандла при сборке на типичном проекте.
```
code =(P)=> loader =(P)=> compiler =(SP)=> bundler =(SP)=> terser =(S)=> bundle
P - Parse
S - Serialize
```
И каждый инструмент заново парсит ваши исходники в своё AST, обрабатывает, сериализует и передаёт далее. Если же договориться о едином формате AST, то можно значительно упростить реализацию утилит и снизить накладные расходы на обработку кода.
```
code =(P)=> loader =====> compiler ======> bundler ======> terser =(S)=> bundle
```
Даже если часть утилит будут запускаться в отдельных процессах (а значит промежуточная сериализация неизбежна), формат tree позволит передавать AST максимально быстро, за счёт минимальных накладных расходов на парсинг и сериализацию.
Куда пойти, куда податься
=========================
Надеюсь мне удалось заразить вас идеями о светлом будущем. Но чтобы его приблизить нам вместе надо над этим поработать. Один я, боюсь, всё это не вытяну. Так что пишите, зовите и не пропадайте.
* Эти слайды: [nin-jin/slides/tree](https://github.com/nin-jin/slides/tree/master/tree)
* Всё о Tree: [nin-jin/tree.d](https://github.com/nin-jin/tree.d)
* Чат о языках: [lang\_idioms](https://teleg.run/lang_idioms)
* Связь со мной: [nin\_jin](https://teleg.run/nin_jin)
Обратная связь
==============
 | https://habr.com/ru/post/503240/ | null | ru | null |
# Hotspot-авторизация за копейки и никаких SMS
[](https://habr.com/ru/company/ruvds/blog/695066/)
В начале этого лета в России произошли изменения в тарифах на рассылку SMS-сообщений. Правила игры изменились, цены выросли на порядок. Кто бы мог подумать, что такое может произойти с технологией, которая уже более 20 лет существует в нашей обыденной жизни. По моему мнению, «большая тройка» решила, что отправка SMS стала использоваться только в корпоративных целях (физики давно мигрировали в различные интернет-мессенджеры), следовательно, на ней можно хорошенько заработать, не боясь потерять пользовательскую симпатию. В статье представлен вариант отказа от подобных сервисов в сторону Asterisk на примере Hotspot, когда на указанный номер телефона поступает звонок и диктор сообщает пароль доступа. Тарифы отличные, расходы минимальные, работаем дальше.
▍ Введение
----------
21 июля в курируемом мной проекте перестала работать рассылка SMS-сообщений, содержащих пароль для доступа к общедоступному Wi-Fi, организованному в интересах международной компании **Coffee Cup**, имеющей как собственные бары формата «кофе с собой» в разных городах, так и дилеров по всей России и в странах СНГ. Все технические подробности о том, как это было изначально сделано, можно посмотреть [здесь](https://habr.com/ru/post/534936/). Для рассылки самих сообщений в силу лёгкости решения, гибкости и удобства администрирования были задействованы сторонние ресурсы, счета на которых в июле стремительно обнулились. Что, собственно говоря, произошло, стало понятно после общения с технической поддержкой:
**Переписка**
*Я: у меня перестали отправляться смс. С ошибкой «незарегистрированный sender id».
Поддержка №1: На XXX и XXX отправка возможна только от платных имён с абонентской платой 2 000 руб./мес за каждого оператора. Если нужна временная отправка от общего имени на данных операторов в ближайшее время, есть тариф около 16 руб. за SMS на XXX и 20,30 руб. на XXX.*
Или вот такой:
*Я: Ищу простой способ отправки SMS, без лишних заморочек. Подойдёт любой исходящий номер.
Поддержка №2: Без регистрации и абонентской платы можно отправлять сообщения от общих имён операторов, но по повышенному тарифу (XXX: 18 руб. за SMS, XXX: 20,30 руб. за SMS). К сожалению, такая заградительная цена — ограничение, наложенное операторами.*
Действительно, если поискать информацию на сайтах операторов сотовой связи, то можно увидеть примерно то же самое:
▍ Технические варианты уведомления пользователей
------------------------------------------------
Называть такие тарифы заградительными весьма уместно. Пришло время искать другие решения.
Отправка SMS через собственные модемы (ведь некоторые бары оборудованы таковыми, как, например, на фото из заголовка) отпала сразу. Причины следующие:
* потенциальные проблемы и танцы с бубнами при отправке сообщений через устройства различных производителей, моделей, прошивок,
* потенциальные проблемы с зависаниями устройств,
* сложность централизованного администрирования территориально-распределённого оборудования,
* высокие риски быть заблокированными со стороны сотовых операторов, которые знают толк не только в том, как заработать, но и как вычислить таких, как мы, и ввести против нас ~~и не только~~ различные ограничения.
Другим вариантом замены отправки SMS является доставка кодов доступа посредством интернет-мессенджеров. Тоже не подходит: во-первых, спорная легитимность идентификации пользователей таким образом, во-вторых, при подключении к Hotspot интернет появляется только после ввода отправленного пароля, а значит пользователям нужно отключаться от Wi-Fi, возвращаться в сеть передачи данных своего мобильного оператора, и только после этого подобные уведомления будут доставлены. Всё это надо ещё донести до людей, поэтому сразу нет.
Третий вариант — это задействование возможностей открытого программного обеспечения [Asterisk](https://www.asterisk.org/), когда на номер пользователя поступает автоматизированный звонок, и необходимо в качестве пароля указать последние цифры звонящего номера. Сейчас много где так организовано. Этот способ имеет преимущество — отсутствие длительности разговора, ведь после поднятия трубки АТС самостоятельно разрывает соединение. Однако имеются другие накладные расходы – необходим определённый пул арендуемых номеров (и желательно большой), который стоит денег. Например, аренда одного городского номера выходит порядка 350 рублей в месяц. Если использовать вместо арендуемых номеров обычные модемы – минусы такого решения рассмотрены выше.
Четвёртый вариант — использование Asterisk, когда на номер пользователя поступает автоматизированный звонок, и робот голосом сообщает пароль. Корпоративный арендуемый номер у компании **Coffee Сup** уже был, тарификация посекундная, следовательно, накладные затраты должны быть адекватными. Как это всё интегрировать в имеющуюся [инфраструктуру](https://habr.com/ru/post/534936/) (с учётом того, что сеть за эти годы значительно подросла), подробно рассмотрим ниже. Непосредственно общая настройка АТС к рассматриваемой теме не относится, поэтому концентрироваться на ней не будем.
▍ Hotspot с идентификацией пользователей посредством Asterisk
-------------------------------------------------------------
Изначально проект казался более сложным, чем вышел на самом деле, благодаря гибкости имеющихся решений и используемого программного обеспечения. Казалось, что нужна будет интеграция с API, например, от Google, по переводу текста в голос для работы диктора. Однако это избыточно, ведь Asterisk имеет на борту заготовленные звуковые файлы различного содержания, в том числе подходящие для нашего проекта. Общая схема следующая: пользователь подключается к Hotspot, получает приглашение на ввод номера телефона, который посредством HTTP GET передаётся на сервер АТС, где обрабатывается и формируется задание для Asterisk. Ответом на запрос является пароль доступа к Hotspot. После этого осуществляется звонок на номер пользователя, при котором проигрываются необходимые аудиозаписи с кодом доступа. Далее в рефакторинг не лезем, всё работает по старой схеме. Для начала подготовим аудиофайлы для Asterisk. Скорее всего, они не будут предустановлены:
```
ls /usr/share/asterisk/sounds/
apt-cache search asterisk | grep sounds-ru
apt install asterisk-core-sounds-ru asterisk-core-sounds-ru-gsm asterisk-core-sounds-ru-wav asterisk-core-sounds-ru-g722 -y
ls –l /usr/share/asterisk/sounds/ru/
```
В нашем проекте пароль доступа к Hotspot представляет четырёхзначное число. Здесь лежат звуки пауз, например, длительностью в 1 секунду: */usr/share/asterisk/sounds/ru/silence/1*. Здесь имеются записи произношения диктором цифр: */usr/share/asterisk/sounds/ru/digits/0*. Кстати, на борту представлен простой и удобный способ записи собственных сообщений. Для этого внесём изменения в имеющийся диалплан:
```
# nano /etc/asterisk/extensions.conf
[test-record]
exten => _1000,1,Wait(2)
exten => _1000,n,Record(/tmp/sound${EXTEN:2}:wav)
exten => _1000,n,Wait(1)
exten => _1000,n,Playback(/tmp/sound${EXTEN:2})
exten => _1000,n,Wait(2)
exten -> _1000,n,Hangup()
```
Укажем данный extension нужному endpoint:
```
# nano /etc/asterisk/pjsip.conf
[3002]
type=endpoint
context=test-record
# systemctl restart asterisk
```
Звоним с указанного endpoint на номер *1000*, говорим что-нибудь, после чего слышим произнесённое, а качественная запись голоса будет сохранена в файле */tmp/sound00.wav*. Чтобы инициировать звонок от имени АТС, можно использовать либо CLI, либо командный файл. Пример работы посредством консоли представлен ниже:
```
/usr/sbin/asterisk -rx "channel originate pjsip/3001/3002 application playback /var/lib/asterisk/sounds/custom/sound00"
/usr/sbin/asterisk -rx "channel originate pjsip/+71111111111@siplink-74992222222 application playback /var/lib/asterisk/sounds/custom/sound00"
```
Кстати, вместо проигрывания звуковых файлов может быть использовано встроенное в Asterisk приложение, которое умеет произносить цифры (для озвучивания чисел есть другое приложение) однако придётся позаниматься русификацией:
```
channel originate pjsip/3001/3002 application saynumber 123
```
В проекте вместо CLI использовался командный файл. Чтобы инициировать звонок на номер +71111111111, подготавливаем:
```
# nano /var/spool/asterisk/tmp/test.call
Channel: PJSIP/+71111111111@siplink-74992222222
Application: Playback
Data: /var/lib/asterisk/sounds/custom/sound00
```
Чтобы воспроизвести несколько файлов, их нужно перечислить через амперсанд. Копируем командный файл в нужное место, и АТС сразу выполнит полученные инструкции:
```
cp /var/spool/asterisk/tmp/test.call /var/spool/asterisk/outgoing/test.call
```
Приведу пример используемого extension:
```
# nano /etc/asterisk/extensions.conf
[siplink-out-74992222222]
exten => _XXXX,1,Dial(PJSIP/${EXTEN})
exten => _+X.,1,Dial(PJSIP/${FILTER(+0-9,${EXTEN})}@siplink-74992222222)
```
Здесь хочу порекомендовать провайдера IP-телефонии [Siplink](https://siplink.pro) — профессиональные ребята. Давно пользуюсь их услугами, приятно работать: хорошая поддержка, адекватные тарифы.
На этом настройка Asterisk заканчивается, осталось доработать веб-сервер и RouterOS. В скрипте для работы Hotspot удалим использование API сторонних сервисов и добавим следующее:
```
:local SITE pbx.tratata.ru;
:local PORT 443;
:local APIKEY 0123456789;
…
local pass ([/tool fetch url="https://$SITE:$PORT/\?secret=$APIKEY&msisdn=$uname" output=user as-value]->"data")
```
Пароль пользователя и командный файл для Asterisk будем генерировать прямо на АТС. Для этого настроим любой веб-сервер, активируем HTTPS. Как это сделать, упускаем, инструкций более чем достаточно. Подготовим *index.php*:
```
php
$api = '0123456789';
$key_from_get = trim(htmlspecialchars($_GET["secret"]));
$dir = '/usr/share/asterisk/sounds/ru';
$silence = "$dir/silence/1";
$sip1 = "@siplink-74992222222";
$sip2 = trim(htmlspecialchars($_GET["msisdn"]));
$fileWeb = 'file.txt';
$fileAsterisk = 'file2.txt';
if ( $key_from_get === $api AND strlen("$sip2") === 10 AND ctype_digit("$sip2") ) {
$pas1d = random_int(0, 9);
$pas2d = random_int(0, 9);
$pas3d = random_int(0, 9);
$pas4d = random_int(0, 9);
echo "$pas1d$pas2d$pas3d$pas4d";
$myfile = fopen("$fileWeb", "w");
$txt = "Channel: PJSIP/+7$sip2$sip1\n";
fwrite($myfile, $txt);
$txt = "Application: Playback\n";
fwrite($myfile, $txt);
$txt = "Data: $silence&$dir/digits/$pas1d&$silence&$dir/digits/$pas2d&$silence&$dir/digits/$pas3d&$silence&$dir/digits/$pas4d\n";
fwrite($myfile, $txt);
fclose($myfile);
rename("$fileWeb", "$fileAsterisk");
}
?
```
Веб-сервер получает номер пользователя, генерирует ему пароль доступа, возвращает его в качестве ответа и подготавливает соответствующее задание для АТС. Непосредственный перенос файла в папку Asterisk выполняет bash-скрипт. Такая прослойка сделана для возможности прикручивания допов на будущее, работает стабильно. PHP-cкрипт валидирует и проверяет длину и состав номера пользователя, при звонке сам подставляет телефонный код +7, чтобы отсутствовала возможность списывать деньги со счёта посредством звонков, например, на Марс. Здесь необходимо отметить, что используемый скрипт RouterOS содержит проверку и блокировку множественных однотипных запросов:
```
#Cheks user from spam
:local sendtest yes;
:foreach i in=[/ip firewall address-list print as-value where list=spam_cheks_list] do={
:if (($i->"address")=$uname) do={
:set $sendtest no;
}
}
:if ($sendtest=yes) do={
/ip firewall address-list add list=spam_cheks_list address=$uname timeout=00:05:00;
…
}
```
JavaScript на странице Hotspot никакой реальной защиты не добавляет, а только помогает пользователю не ошибиться при наборе цифр. На страницу добавлено уведомление о том, что поступит звонок от робота с арендуемого нами корпоративного номера:
Готово! Получаем приятную стоимость одного такого звонка в 20-30 копеек, что даже дешевле, чем отправка SMS по «старым» доиюльским ценам:
▍ Заключение
------------
В статье мы рассмотрели доработку Hotspot до идентификации пользователей посредством звонка от Asterisk и диктовки пароля с целью миграции от SMS-gateway-шлюзов из-за значительного удорожания их сервисов. Минусом такой организации является то, что на время приёма звонка сотовый телефон посетителя отключается от Wi-Fi, что не такая уж и проблема, так как при повторном подключении имеется возможность выбрать «*У меня уже есть код*». Решение рабочее, следующая точка отказа – борьба большой тройки с IP-телефонией, как уже некоторые начинают делать, безразборчиво блокируя подобные входящие вызовы, ссылаясь на противодействие мошенничеству. Как видно из кода, несложно всё доработать на использование пула номеров и идентификацию посредством ввода последних цифр звонящего номера, без длительности разговора и списания денег. Полученное решение достаточно гибкое, много что можно нарастить. Моё личное мнение: **Open-source Software** — сила, особенно в очумелых руках.
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=olegtsss&utm_content=hotspot_avtorizaciya_za_kopejki_i_nikakix_sms) | https://habr.com/ru/post/695066/ | null | ru | null |
# Используем возможности CSS4 уже сегодня с cssnext
Вот уже на протяжении четырёх лет, с сентября 2011 г. W3C занимается разработкой CSS4. Модули четвёртой версии каскадных таблиц стилей проектируются на базе CSS3 и дополняют их новыми свойствами и значениями. В этой статье я хотел бы рассказать о том, как использовать возможности CSS4 уже сегодня, о [cssnext](http://cssnext.io/).
Итак, cssnext — это CSS компилятор, позволяющий использовать последний синтаксис CSS уже сегодня. Он преобразует новые CSS спецификации в более современный код так, что вам не придётся ждать поддержки новых возможностей в вашем браузере.
### **Возможности**
##### **Автоматическая расстановка вендорных префиксов**
Вендорные префиксы автоматически добавляются (или же, в том случае если они являются устаревшими, удаляются) с помощью PostCSS плагина [Autoprefixer](https://github.com/postcss/autoprefixer).
##### **Переменные в свойствах CSS**
Благодаря возможностям cssnext в корневом селекторе :root мы можем задавать неограниченное число переменных и использовать их в наших CSS свойствах.
```
:root {
--fontSize: 1rem;
--mainColor: #ddd;
}
a {
color: var(--mainColor);
font-size: var(--fontSize);
}
```
[Спецификация](http://www.w3.org/TR/css-variables/) | [Документация плагина](https://github.com/postcss/postcss-custom-properties)
##### **Простые математические выражения**
Позволяет использовать свойство calc(). Данное свойство можно использовать не только с простыми значениями, но и с переменными.
```
:root {
--fontSize: 1rem;
}
h2 {
font-size: calc(var(--fontSize)*2);
}
```
[Документация плагина](https://github.com/MoOx/reduce-css-calc)
##### **Переменные для медиа-запросов**
```
@custom-media --small-viewport (max-width: 30em);
@media (--small-viewport) {
/* Стили для маленьких экранов */
}
```
[Спецификация](http://dev.w3.org/csswg/mediaqueries/#custom-mq) | [Документация плагина](https://github.com/postcss/postcss-custom-media)
##### **Улучшенный синтаксис медиа-запросов**
Позволяет использовать выражения >= и <= вместо min-width и max-width в медиа-запросах.
```
@media (width >= 500px) and (width <= 1200px) {
/* Ваши стили */
}
```
[Спецификация](http://dev.w3.org/csswg/mediaqueries/#mq-ranges) | [Документация плагина](https://github.com/postcss/postcss-media-minmax)
##### **Пользовательские селекторы**
Позволяет создавать свои собственные селекторы.
```
@custom-selector :--heading h1, h2, h3, h4, h5, h6;
:--heading {
margin-top: 0;
}
```
[Спецификация](http://dev.w3.org/csswg/css-extensions/#custom-selectors) | [Документация плагина](https://github.com/postcss/postcss-custom-selector)
##### **Функции для модификации цвета**
На данный момент уже доступно значительное количество модификаторов цвета. Подробнее можно ознакомиться [здесь](https://github.com/postcss/postcss-color-function#list-of-color-adjuster).
```
a {
color: color(red alpha(-10%));
}
a:hover {
color: color(red blackness(80%));
}
```
[Спецификация](http://dev.w3.org/csswg/css-color/#modifying-colors) | [Документация плагина](https://github.com/postcss/postcss-color-function)
##### **Поддержка цветов hwb()**
Позволяет использовать W3C CSS hwb() цвета, которые будут преобразованы в rgb() или rgba()
```
body {
color: hwb(90, 0%, 0%, 0.5);
}
```
[Спецификация](http://dev.w3.org/csswg/css-color/#the-hwb-notation) | [Документация плагина](https://github.com/postcss/postcss-color-hwb)
##### **Более чем 50 оттенков серого**
Возможность использовать свойство gray(). В качестве первого аргумента вы можете использовать значение от 0 до 255 или от 0 до 100 процентов.
```
.foo {
color: gray(85);
}
.bar {
color: gray(10%, 50%);
}
```
[Спецификация](http://dev.w3.org/csswg/css-color/#grays) | [Документация плагина](https://github.com/postcss/postcss-color-gray)
##### **Цвета #rrggbbaa**
Даёт возможность использования чётырёх или восьмизначных значений для обозначения цвета.
```
.boo {
color: #9d9c;
}
```
[Спецификация](http://dev.w3.org/csswg/css-color/#hex-notation) | [Документация плагина](https://github.com/postcss/postcss-color-hex-alpha)
##### **Цвет rebeccapurple**
Новый цвет.
```
.foo {
background: rebeccapurple;
}
```
[Спецификация](http://dev.w3.org/csswg/css-color/#valdef-color-rebeccapurple) | [Документация плагина](https://github.com/postcss/postcss-color-rebeccapurple)
##### **Свойство font-variant**
Данный плагин позволяет трансформировать свойство font-variant в CSS более совместимый с наиболее популярными на сегодняшний день браузерами.
```
h2 {
font-variant-caps: small-caps;
}
table {
font-variant-numeric: lining-nums;
}
```
[Спецификация](http://dev.w3.org/csswg/css-fonts/#propdef-font-variant) | [Документация плагина](https://github.com/postcss/postcss-font-variant)
##### **Фильтры**
Позволяет использовать 10 различных CSS фильтров:
* grayscale
* sepia
* saturate
* hue-rotate
* invert
* opacity
* brightness
* contrast
* blur
* drop-shadow
```
.blur {
filter: blur(4px);
}
```
[Спецификация](http://www.w3.org/TR/filter-effects/) | [Документация плагина](https://github.com/iamvdo/pleeease-filters)
##### **Единицы rem**
Единицы rem возвращаются в px.
```
h1 {
font-size: 1.5rem;
}
```
[Спецификация](http://www.w3.org/TR/css3-values/#rem-unit) | [Документация плагина](https://github.com/robwierzbowski/node-pixrem)
##### **Псевдокласс :any-link**
Позволяет использовать класс :any-link для ссылок.
```
/* Из: */
nav :any-link > span {
background-color: yellow;
}
/* В: */
nav :link > span,
nav :visited > span {
background-color: yellow;
}
```
[Спецификация](http://dev.w3.org/csswg/selectors/#any-link-pseudo) | [Документация плагина](https://github.com/jonathantneal/postcss-pseudo-class-any-link)
##### **Псевдокласс :matches**
Позволяет использовать класс :matches().
```
/* Из: */
p:matches(:first-child, .special) {
color: red;
}
/* В: */
p:first-child, p.special {
color: red;
}
```
[Спецификация](http://dev.w3.org/csswg/selectors-4/#matches) | [Документация плагина](https://github.com/postcss/postcss-selector-matches)
##### **Псевдокласс :not**
Что-то схожее с предыдущим псевдоклассом, но с обратным результатом.
```
p:not(:first-child, .special) {
color: red;
}
```
[Спецификация](http://dev.w3.org/csswg/selectors-4/#negation) | [Документация плагина](https://github.com/postcss/postcss-selector-NOT)
##### **Альфа-цвета**
Добавляет цветовые фолбэки для rgba цветов (для старых браузеров).
```
body {
background: rgba(153, 221, 153, 0.8);
}
```
[Спецификация](http://www.w3.org/TR/css3-color/) | [Документация плагина](https://github.com/postcss/postcss-color-rgba-fallback)
Также cssnano, кроме всего вышеперечисленного, содержит в себе ряд бонусных возможностей, таких как импорт(@import) сторонних CSS файлов в ваш конечный CSS файл, идущий на продакшен и сжатие конечного выходного CSS с помощью CSSNano.
### **Использование**
Вы можете использовать cssnext как плагин для вашей любимой системы сборки [Grunt](https://github.com/cssnext/grunt-cssnext), [Gulp](https://github.com/cssnext/gulp-cssnext), [Broccoli](https://github.com/cssnext/broccoli-cssnext), [Webpack](https://github.com/cssnext/cssnext-loader), [Fly](https://github.com/cssnext/fly-cssnext) и т.д. или же в качестве плагина для PostCSS.
Мне больше по душе последний вариант. Собственно, его я и использую [в своей стартовой сборке](http://habrahabr.ru/post/265449/) для разработки собственных проектов.
Надеюсь, вам было интересно познакомиться с возможностями cssnext.
На этом всё. Спасибо за внимание! | https://habr.com/ru/post/267181/ | null | ru | null |
# Оптимизация геометрического алгоритма обучения ИНС при анализе независимых компонент
Добрый день, уважаемые хабровчане. Возможно многие из вас зададутся вопросом: «А где же описание основного алгоритма?».
Так вот, ниже будут указанны ссылки на источники, и переписывать основной алгоритм не буду.
Сразу объяснюсь. Данная статья — это результат моей исследовательской работы, а в дальнейшем и тема моего диплома.
Но хватит вводных слов. Поехали!
##### 1. Искусственные нейронные сети
ИНС представляют собой попытку использования процессов, происходящих в нервных системах живых существ для создания новых информационных технологий.
Основным элементом нервной системы является нервная клетка, сокращенно называемая нейроном. Как и у любой другой клетки, у нейрона имеется тело, называемое сомой, внутри которого располагается ядро, а наружу выходят многочисленные отростки — тонкие, густо ветвящиеся дендриты, и более толстый, расщепляющийся на конце аксон (рис. 1).
*Рис.1. Упрощенная структура биологической нервной клетки*
Входные сигналы поступают в клетку через синапсы, выходной сигнал передается аксоном через его нервные окончания (колатералы) к синапсам других нейронов, которые могут находиться как на дендритах, так и непосредственно на теле клетки.
##### 2. Многослойный персептрон
Рассмотрим его как основную используемую модель многослойной НС прямого распространения. Многослойная сеть состоит из нейронов, расположенных на разных уровнях, когда, помимо входного и выходного слоев, имеется еще, как минимум, один промежуточный (скрытый) слой. Обобщенная структура двухслойной НС приведена на (рис.2).
*Рис. 2. Обобщенная структура двухслойной НС (с одним скрытым слоем)*
Выходной сигнал i-го нейрона скрытого слоя можно записать как
а выходные сигналы
Для выделения сигналов источников S(t), содержащихся в смеси сигналов, используем структуру адаптивного фильтра на основе однослойной ИНС (рис. 3), предложенной в 80х годах Херольтом и Джуттеном, где X – матрица векторов наблюдаемых сигналов, образуемая в соответствии с уравнением (1) с помощью неизвестной матрицы смешивания А, W – матрица весов нейронной сети.
`X = AS (1)`
*Рис. 3. Блок-схема работы адаптивного фильтра на ИНС*
##### 3. Использование геометрических алгоритмов обучения ИНС
Итак, как известно, любая нейронная сеть требует обучения.
Существуют различные алгоритмы обучения, с учителем, без учителя, комбинированные.
В данной работе был рассмотрен довольно необычный алгоритм обучения ИНС — геометрический.
Для начала рассмотрим его основные отличия:
* Интуитивная понятность и наглядность
* Высокая скорость обработки данных
* Возможность использования для неквадратных матриц смешивания (только в случае супергауссовых распределений)
* Простота в программировании
В работе была исследованна следующая ситуация.
На вход поступает смесь из различных сигналов (заранее подчеркну, что количество сигналов уже известно).
Необходимо было разработать такой алгоритм обучения нейросети, который позволил бы разделять сигналы из смеси с максимальной точностью.
На рис.4а изображены сигналы источников. Заметно, что четко выделяются 2 независимых компоненты, каждая из которых описывает сигнал.
На рис.4б изображены смеси сигналов. Сигналы кореллируют друг с другом, и становится довольно трудно различить их (попробуйте наложить одно изображение на другое).
*Рис.4. Геометрическая интерпретация умножения на матрицу А
( а) — сигналы источников, б) — сигналы смесей)*
Из (1) ясно, что смесь сигналов получается в результате перемножения сигналов источников на матрицу смешивания A:
,
которая в свою очередь представляется в виде матрицы поворота:
.
Из этой довольно простой идеи и родился геометрический алгоритм обучения ИНС — histGEO.
##### 4. Алгоритм histGEO для случая супергауссовых распределений.
Задача этапа восстановления матрицы смешивания — отыскать
углы α1 и α2 матрицы поворота. В общем случае количество углов равно числу независимых компонент,
участвующих в смешивании.
Кратко схему функционирования histGEO для обработки
супергауссовых сигналов можно описать следующим образом:
* строится диаграмма рассеяния компонент матрицы X;
* рассчитывается распределение плотности вероятностей как функция от угла φ: f=f(φ);
* полученное распределение обрабатывается с помощью усредняющего программного фильтра для сглаживания поверхности полученной функции, с сохранением расположения экстремумов;
* грубо определяются места возможной локализации минимумов функции g=-f(φ), где f(φ) — «сглаженная» g(φ));
* используя алгоритм градиентного спуска, уточняются координаты углов φi(рис.5.)
*Рис.5. Поиск углов φi методом градиентного спуска.*
* рассчитываются коэффициенты восстанавливающей матрицы M
где n — количество независимых компонент в смеси;
* на этапе тестирования алгоритма, полученные значения углов φ; наносятся на диаграмму рассеяния и сравниваются с α (рис. 6.1-6.2)
*Рис.6.1. Результаты оценки смешивающей матрицы для 2х аудиосигналов
(а — geoica, б -fastgeo, в — histgeo)*
*Рис. 6.2. Результаты оценки смешивающей матрицы для 3х аудиосигналов.
Случай переполненного базиса
(а — geoica, б — fastgeo, в — histgeo)*
###### Обработка аудиосигналов
Практические исследования работы рассматриваемых алгоритмов проводили в системе
математического моделирования Matlab 7.5 с использованием пакетов расширений
fastICA, geoICA, ICALab (расширения для обуче.
Работа была разделена на две части с возрастанием сложности разделения:
1. Оценка матрицы смешивания в задаче с квадратной матрицей, сигналы источников S – речь, шум, музыка(рис.7.1-7.4)
2. Оценка матрицы смешивания в задаче с переполненным базисом, сигналы источников S – речь, шум, музыка
*Рис.7.1. Характеристики исходных сигналов: форма исходных сигналов*
*Рис.7.2. Характеристики исходных сигналов: частотные спектры*
*Рис.7.3. Характеристики исходных сигналов: вероятностные распределения*
*Рис.7.4. Характеристики исходных сигналов: диаграммы рассеяния*
##### 5. Алгоритм histGEO для случая субгауссовых распределений.
Помимо часто-встречающегося супергауссового распределения (аудиосигналы, изображения, видеосигнал и т.п.),
существуют т.н. субгауссовы сигналы (различного рода шумы, статистические величины, конкуренция особей одного вида в природе).
И отделить сигналы такого типа порой становиться невообразимо сложно, т.к. они представленны в неявном виде и сильно усложняют картину распределения.
Как ни странно, довольно простые геометрические алгоритмы оказались способны решить эту проблему.
Достаточно лишь правильно выбрать геометрический признак, характеризующий независимую компоненту.
Cигналы на выходах ИНС будут иметь вид
`Y=WX (2)`
т.е. задача линейной фильтрации сводится к поиску верных значений коэффициентов
матрицы весов нейронной сети W.
Из сравнения диаграмм рассеяния исходных источников и полученных смесей X
(рис.8) можно сделать вывод, что умножение на матрицу смешивания А эквивалентно
повороту независимых компонент на некоторые углы α1 и α2 в плоскости x1Ox2.
*Рис.8. Геометрическая интерпретация умножения на матрицу смешивания A
(а – сигналы источников, б – сигналы смесей)*
Для преобразования данных в удобный для работы вид было необходимо
провести процедуру декорреляции набора сигналов («отбеливание»),
которая переводит их совместную корреляционную матрицу в
диагональную форму, элементами которой являются дисперсии этих
сигналов (рис.9). И искомым геометрическим признаком оказались диагонали квадрата:
*Рис.9. Декореллированные («отбеленные») сигналы X1 и X2.
(а – поиск подходящего геометрического признака, б – построение гистограммы распределения)*
Из условий попадания точек в сектор окружности — заведомо большей
по площади, чем площадь анализируемого распределения (рис.9б) –
было рассчитано распределение плотности точек в секторе как
функция от угла φ (рис.10):
*Рис.10. Поиск углов φi в алгоритме histgeo*
`f=f(φ)`
`g(φ)=f*(φ)`,
где f\*(φ) – f(φ), «сглаженная» при помощи фильтра.
Для уменьшения погрешности был сформирован массив значений отклонения всех 4х диагоналей относительно исходных диагоналей соответственно (45о, 135о, 225о, 315о) (рис.11), далее было найдено среднее значение отклонений.
*Рис.11. Поиск углов отклонения диагоналей от заданных углов.*
Зная угол, на который повернуты диагонали, а так же то, что пересекаются диагонали в центре квадрата, можно повернуть все точки относительно этого центра на этот угол в сторону соответствующих диагоналей. Для этого необходимо вычислить восстанавливающую матрицу:
Получившееся распределение графически совпадает с исходным, что
наглядно показано на рис.12:
*Рис.12. Сравнение эталонного распределения S (а) и восстановленного Y (б).*
Для нахождения матрицы смешивания A’, необходимо использовать
процедуру, обратную процедуре декорелляции. Получившаяся матрица
имеет вид:
Ошибка взаимного влияния матриц А и А’:
Таблица 1. Значения коэффициентов эксцесса для матриц S, X, Y:
| | | | |
| --- | --- | --- | --- |
| | S | X | Y |
| kurt1 | -0.8365 | -0.7582 | -0.8379 |
| kurt2 | -0.8429 | -0.8341 | -0.8465 |
Коэффициент эксцесса:
##### 6. Выводы
* Проверенна возможность применения геометрического алгоритма histGEO к классу субгауссовых распределений.
* Несмотря на кажущуюся простоту, геометрические алгоритмы представляют собой эффективный механизм обучения ИНС в задачах адаптивной фильтрации.
* Разработанный оптимизированный вариант алгоритма histGEO применим к сигналам как супергауссового, так и субгауссового типа.
* С увеличением количества источников, входящих в смесь, делать правильную оценку матрицы смешивание становится труднее, т.к. экстремумы функции g(φ) становятся менее выраженными и не исключено попадание решения в один из локальных минимумов.
* Эффективность алгоритма в случае разделения сигналов с переполненным базисом (варианты неквадратной матрицы смешивания) требует проведения дополнительных исследований.
На данном этапе нельзя сказать, что алгоритм универсален и применим в случае неквадратных матриц смешивания для любого класса распределений, но с уверенностью можно отметить, что в случае квадратных матриц этот алгоритм справляется со своей задачей.
Список литературы:
1. Хайкин С. Нейронные сети: полный курс / С. Хайкин. – М.: Издательский дом «Вильямс», 2006. – 1104 с.
2. Бормонтов Е.Н., Клюкин В.И., Тюриков Д.А. Геометрические алгоритмы обучения в задаче анализа независимых компонент / Е. Н. Бормонтов, В. И. Клюкин, Д. А. Тюриков – Вестник ВГТУ, т.6, №7. – Воронеж: ВГТУ, 2010.
3. A. Jung, F.J. Theis, C.G. Puntonet E.W. Lang. Fastgeo — a histogram based approach to linear geometric ICA. Proc. of ICA 2001, pp. 418–423, 2001.
4. F.J. Theis. A geometric algorithm for overcomplete linear ICA. B. Ganslmeier, J. Keller, K.F. Renk, Workshop ReportI of the Graduiertenkolleg, pages 67-76, Windberg, Germany, 2001.
5. Г. Ф. Малыхина, А. В. Меркушева Робастные методы для разделения смеси сигналов и анализа независимых компонент при зашумленных данных / Г. Ф. Малыхина, А. В. Меркушева НАУЧНОЕ ПРИБОРОСТРОЕНИЕ, 2011, том 21, № 1, c. 114–127
6. XIX Международная научно-техническая конференция «Радиолокация, навигация, связь» (RLNC-2013) Секция 1. Оптимизация геометрического алгоритма обучения ИНС при анализе независимых компонент. Е. Н. Бормонтов, В. И. Клюкин, Д. А. Тюриков — 2013 | https://habr.com/ru/post/216225/ | null | ru | null |
# Цена JavaScript в 2019 году
За последние несколько лет в том, что называют «[ценой JavaScript](https://habr.com/ru/company/ruvds/blog/419369/)», наблюдаются серьёзные положительные изменения благодаря повышению скорости парсинга и компиляции скриптов браузерами. Сейчас, в 2019 году, главными составляющими нагрузки на системы, создаваемой JavaScript, являются время загрузки скриптов и время их выполнения.
[](https://habr.com/ru/company/ruvds/blog/459296/)
Взаимодействие пользователя с сайтом может быть временно нарушено в том случае, если браузер занят выполнением JavaScript-кода. В результате можно сказать, что сильное позитивное воздействие на производительность сайтов может оказать оптимизация узких мест, связанных с загрузкой и выполнением скриптов.
Общие практические рекомендации по оптимизации сайтов
-----------------------------------------------------
Что вышесказанное означает для веб-разработчиков? Дело тут в том, что затраты ресурсов на парсинг (разбор, синтаксический анализ) и компиляцию скриптов уже не так серьёзны, как раньше. Поэтому при анализе и оптимизации JavaScript-бандлов разработчикам стоит прислушаться к следующим трём рекомендациям:
1. Стремитесь снизить время, необходимое на загрузку скриптов.
* Постарайтесь, чтобы ваши JS-бандлы имели бы небольшой размер. Особенно это важно для сайтов, рассчитанных на мобильные устройства. Использование маленьких бандлов улучшает время загрузки кода, снижает уровень использования памяти, уменьшает нагрузку на процессор.
* Старайтесь, чтобы весь код проекта не был бы представлен в виде одного большого бандла. Если размер бандла превышает примерно 50-100 Кб — разделите его на отдельные фрагменты небольшого размера. Благодаря HTTP/2-мультиплексированию одновременно может выполняться отправка нескольких запросов к серверу и обработка нескольких ответов. Это снижает нагрузку на систему, связанную с необходимостью выполнения дополнительных запросов на загрузку данных.
* Если вы работаете над мобильным проектом — постарайтесь, чтобы код был бы как можно меньшего размера. Эта рекомендация связана с невысокими скоростями передачи данных по мобильным сетям. Кроме того, стремитесь к экономному использованию памяти.
2. Стремитесь снизить время, необходимое на выполнение скриптов.
* Избегайте использования [длительных задач](https://w3c.github.io/longtasks/), которые способны на долгое время нагружать главный поток и увеличивать время, необходимое на то, чтобы страницы оказывались бы в состоянии, в котором с ними могут взаимодействовать пользователи. В текущих условиях выполнение скриптов, происходящее после того, как они оказываются загруженными, вносит основной вклад в «цену JavaScript».
3. Не встраивайте большие фрагменты кода в страницы.
* Здесь стоит придерживаться следующего правила: если размер скрипта превышает 1 Кб — постарайтесь не встраивать его в код страницы. Одной из причин этой рекомендации является тот факт, что 1 Кб — это тот предел, после которого в Chrome начинает работать [кэширование](https://v8.dev/blog/code-caching-for-devs) кода внешних скриптов. Кроме того, учитывайте то, что разбор и компиляция встроенных скриптов всё ещё выполняются в главном потоке.
Почему так важно время загрузки и выполнения скриптов?
------------------------------------------------------
Почему в современных условиях важно оптимизировать время загрузки и выполнения скриптов? Время загрузки скриптов чрезвычайно важно в ситуациях, когда с сайтами работают через медленные сети. Несмотря на то, что в мире всё сильнее распространяются сети 4G (и даже 5G), свойство [NetworkInformation.effectiveType](https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation/effectiveType) во многих случаях использования мобильных соединений с Интернетом демонстрирует показатели, находящиеся на уровне 3G-сетей или даже на более низких уровнях.
Время, необходимое на выполнение JS-кода, важно для мобильных устройств с медленными процессорами. Из-за того, что в мобильных устройствах используются различные CPU и GPU, из-за того, что при перегреве устройств, ради их защиты, производительность их компонентов снижается, можно наблюдать серьёзный разрыв между производительностью дорогих и дешёвых телефонов и планшетов. Это сильно влияет на производительность JavaScript-кода, так как возможности по выполнению неким устройством такого кода ограничены возможностями процессора этого устройства.
На самом деле, если проанализировать общее время, тратящееся на загрузку и подготовку к работе страницы в браузере наподобие Chrome, то около 30% этого времени может быть потрачено на выполнение JS-кода. Ниже показан анализ загрузки весьма типичной по составу веб-страницы (reddit.com) на высокопроизводительном настольном компьютере.
*В процессе загрузки страницы около 10-30% времени тратится на выполнение кода средствами V8*
Если говорить о мобильных устройствах, то на среднем телефоне (Moto G4) на выполнение JS-кода reddit.com уходит в 3-4 раза больше времени, чем на устройстве высокого уровня (Pixel 3). На слабом устройстве (Alcatel 1X стоимостью менее $100) на решение той же задачи требуется, как минимум, в 6 раз больше времени, чем на чём-то вроде Pixel 3.
*Время, необходимое на обработку JS-кода на мобильных устройствах разных классов*
Обратите внимание на то, что мобильная и настольная версии reddit.com различаются. Поэтому здесь нельзя сравнивать результаты мобильных устройств и, скажем, MacBook Pro.
Когда вы пытаетесь оптимизировать время выполнения JavaScript-кода — обращайте внимание на [длительные задачи](https://web.dev/long-tasks-devtools/), которые могут надолго захватывать UI-поток. Эти задачи могут препятствовать выполнению других, чрезвычайно важных задач, даже тогда, когда внешне страница выглядит полностью готовой к работе. Длительные задачи стоит разбивать на более мелкие задачи. Деля код на части и управляя порядком загрузки этих частей можно добиться того, что страницы быстрее будут приходить в интерактивное состояние. Это, можно надеяться, приведёт к тому, что у пользователей будет меньше неудобств во взаимодействии со страницами.
*Длительные задачи захватывают главный поток. Их стоит разбивать на части*
Как улучшения V8 влияют на ускорение разбора и компиляции скриптов?
-------------------------------------------------------------------
Скорость синтаксического анализа исходного JS-кода в V8, со времён Chrome 60, повысилась в 2 раза. В то же время, парсинг и компиляция теперь вносят меньший вклад в «цену JavaScript». Это так благодаря другим работам по оптимизации Chrome, ведущим к параллелизации выполнения этих задач.
В V8 объём работ по разбору и компиляции кода, производимых в главном потоке, снижен в среднем на 40%. Например, для Facebook улучшение этого показателя составило 46%, для Pinterest — 62%. Наиболее высокий результат, составляющий 81%, получен для YouTube. Такие результаты возможны благодаря тому, что парсинг и компиляция вынесены в отдельный поток. И это — вдобавок к уже существующим улучшениям, касающимся потокового решения тех же задач за пределами главного потока.
*Время парсинга JS в различных версиях Chrome*
Ещё можно визуализировать то, как оптимизации V8, производимые в различных версиях Chrome, воздействуют на процессорное время, необходимое для обработки кода. За то же время, которое Chrome 61 нужно было для парсинга JS-кода Facebook, Chrome 75 теперь может разобрать JS-код Facebook и, вдобавок, 6 раз разобрать код Twitter.
*За то время, которое Chrome 61 было нужно для обработки JS-кода Facebook, Chrome 75 может обработать и код Facebook, и шестикратный объём кода Twitter*
Поговорим о том, как были достигнуты подобные улучшения. Если в двух словах, то скриптовые ресурсы могут быть разобраны и скомпилированы в потоковом режиме в рабочем потоке. Это означает следующее:
* V8 может выполнять парсинг и компиляцию JS-кода не блокируя главный поток.
* Потоковая обработка скрипта начинается с того момента, когда универсальный HTML-парсер встречает тег | https://habr.com/ru/post/459296/ | null | ru | null |
# О взаимосвязи между корутинами, потоками и проблемами параллелизма
«*Корутины - это легковесные потоки*», сколько раз вы слышали эту формулировку? Она что-нибудь вам говорит? Скорее всего не очень много. Если вы хотите узнать больше о том, **как на самом деле корутины выполняются в рантайме Android**, как они связаны с потоками, а также о **проблемах параллелизма**, которые неизбежны при использовании потоковой модели языка программирования Java, то эта статья для вас.
Корутины и потоки
-----------------
Корутины призваны упростить код, который выполняется асинхронно. Когда мы говорим о корутинах в рантайме Android, **блок кода, переданный в качестве лямбды в билдер корутин, в конечном итоге выполняется в определенном потоке**. Например, это простое вычисление [Фибоначчи](https://en.wikipedia.org/wiki/Fibonacci_number):
```
// Корутина, которая вычисляет 10-й элемент ряда Фибоначчи в фоновом потоке
someScope.launch(Dispatchers.Default) {
val fibonacci10 = synchronousFibonacci(10)
saveFibonacciInMemory(10, fibonacci10)
}
private fun synchronousFibonacci(n: Long): Long { /* … */ }
```
Вышеупомянутый асинхронный (`async`) блок кода корутины, который выполняет синхронное блокирующее вычисление фибоначчи и сохраняет его в памяти, **диспатчится и** **планируется для выполнения в пуле потоков (thread pool), управляемом библиотекой корутин**, настроенной для `Dispatchers.Default`. Код будет выполняться в потоке из пула потоков в какой-то момент в будущем в зависимости от его политик.
Обратите внимание, что приведенный выше код полностью выполняется в одном потоке, потому что его нельзя приостановить. Корутина может выполняться в разных потоках, если выполнение перемещается в другой диспатчер (dispatcher), или если блок содержит код, который можно передавать (yield)/приостанавливать (suspend) в диспtтчере, который использует пул потоков.
Точно так же вы можете выполнить приведенную выше логику без корутин с помощью прямого использования потоков следующим образом:
```
// Создаем пул из 4 потоков
val executorService = Executors.newFixedThreadPool(4)
// Планируем на выполнение этот код в одном из этих потоков
executorService.execute {
val fibonacci10 = synchronousFibonacci(10)
saveFibonacciInMemory(10, fibonacci10)
}
```
Хотя управление пулами потоков вручную возможно, **корутины являются рекомендуемым решением для асинхронного программирования на Android** благодаря встроенной поддержке отмены и упрощению обработки ошибок, *структурированному параллелизму,* снижающему вероятность утечек памяти, и его интеграции с библиотеками Jetpack.
### Под капотом
Что происходит с момента создания корутины до ее выполнения в потоке? Когда вы создаете корутину с помощью стандартных билдеров корутин, вы можете указать, на каком [CoroutineDispatcher](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/CoroutineDispatcher.kt) ее запускать; в противном случае используется `Dispatchers.Default` .
**CoroutineDispatcher отвечает за диспетчеризацию выполнения корутины в поток**. Под капотом, когда используется `CoroutineDispatcher`, он перехватывает корутину, используя метод [interceptContinuation](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/CoroutineDispatcher.kt#L99), который **оборачивает** `Continuation` **(то есть корутину) в** [**DispatchedContinuation**](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/internal/DispatchedContinuation.kt). Это возможно, потому что `CoroutineDispatcher` реализует [ContinuationInterceptor](https://github.com/Kotlin/kotlinx.coroutines/blob/master/stdlib-stubs/src/ContinuationInterceptor.kt) интерфейс.
*Если вы читали мою статью о* [*том, как корутины работают под капотом*](https://manuelvivo.dev/suspend-modifier)*, вы уже знаете, что компилятор создает стейтмашину, а информация о ней (например, что нужно выполнить дальше) хранится в объекте* [*Continuation*](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-continuation.html)*.*
Метод [resumeWith](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/internal/DispatchedContinuation.kt#L178) класса `DispatchedContinuation` отвечает за диспетчеризацию корутины к соответствующему диспатчеру в случае, если Continuation должна быть выполнена в другом диспатчере!
Кроме того, **DispatchedContinuation наследуется** отабстрактного класса [**DispatchedTask**](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/internal/DispatchedTask.kt), который в реализации языка программирования Java, является типом, реализующим интерфейс `Runnable`. Следовательно, `DispatchedContinuation` может выполняться в потоке! Разве это не круто? Когда указан `CoroutineDispatcher`, корутина преобразуется в `DispatchedTask`, который диспатчится для выполнения в потоке как `Runnable`!
А теперь… Как вызывается метод `dispatch` при создании корутины? Когда вы создаете корутину с использованием стандартных билдеров корутин, вы можете указать, как корутина запускается с помощью параметра `start` типа [CoroutineStart](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-start/index.html). Например, вы можете указать ей запускаться только тогда, когда это необходимо, с помощью `CoroutineStart.LAZY`. По умолчанию используется `CoroutineStart.DEFAULT`, который планирует выполнение корутины в соответствии с ее `CoroutineDispatcher`. Бинго!
Иллюстрация того, как блок кода в корутине попадает на выполнение в потокИллюстрация того, как блок кода в корутине попадает на выполнение в поток
### Диспатчеры и пулы потоков
Вы можете выполнять корутины в любом из пулов потоков вашего приложения, преобразовав их в `CoroutineDispatcher` с помощью функции расширения [Executor.asCoroutineDispatcher()](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/java.util.concurrent.-executor/as-coroutine-dispatcher.html). В качестве альтернативы вы можете использовать диспатчеры по умолчанию ([Dispatchers](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/src/Dispatchers.kt)), которые входят в библиотеку корутин.
Вы можете посмотреть, как `Dispatchers.Default` инициализируется в методе [createDefaultDispatcher](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/src/CoroutineContext.kt#L22). По умолчанию используется [DefaultScheduler](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/src/scheduling/Dispatcher.kt). Если вы ознакомитесь с реализацией [Dispatchers.IO](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/src/Dispatchers.kt#L118), он также использует `DefaultScheduler` и позволяет создавать по запросу не менее 64 потоков. `Dispatchers.Default` и `Dispatchers.IO` неявно связаны друг с другом, поскольку они используют один и тот же пул потоков, что плавно подводит меня к следующей теме. Каковы накладные расходы во время выполнения при вызове `withContext` с разными диспатчерами?
### Потоки и производительность withContext
Если в рантайме Android создано больше потоков, чем доступно ядер ЦП, переключение между потоками сопряжено с некоторыми накладными расходами во время выполнения. [*Переключение контекста*](https://en.wikipedia.org/wiki/Context_switch) не из дешевых! ОС должна сохранять и восстанавливать контекст выполнения, а ЦП должен тратить время на планирование потоков, а не на выполнение реальной работы приложения. Кроме того, переключение контекста может произойти, если поток выполняет блокирующий код. Если так обстоят дела с потоками, есть ли какое-либо снижение производительности при использовании `withContext` с разными диспатчерами?
К счастью, как вы могли догадаться, пулы потоков берут на себя всю сложность управления этим процессом, пытаясь оптимизировать работу, чтобы она выполнялась максимально эффективно (поэтому выполнение работы в пуле потоков лучше, чем выполнение в потоках вручную). От этого также выигрывают и корутины, поскольку они планируются в пулах потоков! Вдобавок ко всему, корутины не блокируют потоки, они вместо этого *приостанавливают* (*suspend*) их работу! Это еще эффективнее!
[**CoroutineScheduler**](https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/src/scheduling/CoroutineScheduler.kt), который является пулом потоков используемым в реализации языка программирования Java по умолчанию, **выполняет дистрибьюцию задиспатченых корутин рабочим потокам наиболее эффективным образом**. Поскольку `Dispatchers.Default` и `Dispatchers.IO` используют один и тот же пул потоков, переключение между ними оптимизировано, чтобы избежать переключения потоков, когда это возможно. Библиотека корутин может оптимизировать эти вызовы, оставаться в том же диспатчере и потоке и следовать fast-path.
Поскольку `Dispatchers.Main` обычно является другим потоком в приложениях пользовательского интерфейса, переключение между `Dispatchers.Default` и `Dispatchers.Main` в корутинах не сопряжено с большими потерями производительности, поскольку корутина просто приостанавливается (то есть перестает выполняться в одном потоке) и становится запланированной на выполнение в другом потоке.
Проблемы параллелизма в корутинах
---------------------------------
Корутины ДЕЙСТВИТЕЛЬНО упрощают асинхронное программирование из-за того, насколько простым становится планирование работы в разных потоках. С другой стороны, эта простота может быть палкой о двух концах: **поскольку корутины основаны на потоковой модели языка программирования Java, они не могут просто взять и избежать проблем параллелизма, которые влечет за собой эта многопоточная модель**. Таким образом, вы должны быть внимательны, чтобы самому их избегать.
За прошедшие годы хорошие практики, такие как иммутабельность, позволили смягчить некоторые проблемы, связанные с потоками, с которыми вы можете столкнуться на практике. Однако есть некоторые случаи, которых нельзя избежать с помощью иммутабельности. Мать всех проблем параллелизма - это управление состоянием! В частности, доступ к ***мутабельному состоянию*** в многопоточной среде.
Порядок операций в многопоточном приложении непредсказуем. Помимо оптимизации компилятора, которая может переупорядочить операции, запуск потоков в определенном порядке не гарантирован, а переключение контекста может происходить в любое время. Если при доступе к мутабельному состоянию не приняты необходимые меры предосторожности, потоки, помимо всего прочего, могут видеть устаревшие данные, потерять обновления или пострадать от [*состояния гонки*](https://en.wikipedia.org/wiki/Race_condition).
*Обратите внимание, что дискуссии на тему мутабельного состояния и порядка доступа не относятся исключительно к языку программирования Java. Они также влияют на корутины в других платформах.*
Приложение, использующее корутины, по своей природе является многопоточным. **Классы, которые используют корутины и содержат мутабельное состояние, должны принимать меры предосторожности для обеспечения предсказуемости**, то есть гарантировать, что код, выполняемый в корутинах, видит самую последнюю версию данных. Таким образом, разные потоки не будут мешать друг другу. Проблемы с параллелизмом могут привести к очень тонким ошибкам, которые очень сложно дебажить в ваших приложениях, даже к [*гейзенбагам*](https://en.wikipedia.org/wiki/Heisenbug)!
Подобные классы не редкость. Возможно, классу необходимо сохранить информацию о вошедшем в систему пользователю в памяти или кэшировать некоторые значения, пока приложение работает. Проблемы с параллелизмом могут возникать и в корутинах, если вы не будете осторожны! Не гарантировано, что функция приостановки (suspend) с использованием `withContext(defaultDispatcher)` всегда будет выполняться в одном и том же потоке!
Допустим, у нас есть класс, который кэширует транзакции пользователей. Если доступ к кэшу не происходит должным образом, как, например, ниже, могут возникнуть ошибки параллелизма:
```
class TransactionsRepository(
private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
) {
private val transactionsCache = mutableMapOf()
private suspend fun addTransaction(user: User, transaction: Transaction) =
// ОСТОРОЖНО! Доступ к кэшу не защищен.
// Возможны ошибки параллелизма: потоки могут видеть устаревшие данные
// и может возникнуть состояние гонки.
withContext(defaultDispatcher) {
if (transactionsCache.contains(user)) {
val oldList = transactionsCache[user]
val newList = oldList!!.toMutableList()
newList.add(transaction)
transactionsCache.put(user, newList)
} else {
transactionsCache.put(user, listOf(transaction))
}
}
}
```
*Даже если мы говорим о Kotlin, книга «*Параллелизм в Java на практике*» Брайана Гетца - отличный ресурс, чтобы узнать больше об этой теме и тонкостях параллелизма в системах языка программирования Java. Кроме того, у Jetbrains есть документация об* [*общем мутабельном состоянии и параллелизме*](https://kotlinlang.org/docs/reference/coroutines/shared-mutable-state-and-concurrency.html)*.*
Защита мутабельного состояния
-----------------------------
Как защитить мутабельное состояние или найти хорошую *политику* [*синхронизации*](https://en.wikipedia.org/wiki/Synchronization_(computer_science)), полностью зависит от природы данных и задействованных операций. В этом разделе рассказывается о проблемах параллелизма, с которыми вы можете столкнуться, вместо того, чтобы перечислять все различные способы и API для защиты мутабельного состояния. Тем не менее, вот несколько советов и API, с которых вы можете начать, чтобы сделать ваши мутабельные переменные потокобезопасными.
### Инкапсуляция
Мутабельное состояние должно быть инкапсулировано и *принадлежать* классу. Этот класс централизует доступ к состоянию и будет защищать операции чтения и записи с помощью политики синхронизации, которая лучше соответствует варианту использования.
### Привязка к потоку
Решением может быть ограничение доступа к чтению/записи всего до одного потока. Доступ к мутабельному состоянию может быть выполнен посредством производителя/потребителя (producer/consumer) с использованием очереди. У JetBrains есть [хорошая документация](https://kotlinlang.org/docs/reference/coroutines/shared-mutable-state-and-concurrency.html#thread-confinement-fine-grained) по этой теме.
### Не изобретайте колесо
В рантайме Android есть потокобезопасные структуры данных, которые можно использовать для защиты мутабельных переменных. Например, если вам нужен простой счетчик вы можете использовать [AtomicInteger](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html). Или, чтобы защитить map из фрагмента кода выше, вы можете использовать [ConcurrentHashMap](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html). `ConcurrentHashMap` - это потокобезопасная синхронизированная коллекция, которая оптимизирует пропускную способность чтения и записи в map.
Обратите внимание, что потокобезопасные структуры данных не защищают от проблем с упорядочением вызывающих объектов, они просто обеспечивают атомарный доступ к памяти. Они помогают избежать использования блокировок, если логика не слишком сложна. Например, их нельзя использовать в примере с `transactionCache`, показанном выше, потому что порядок операций и логика между ними требуют защиты потоков и доступа к данным.
Кроме того, данные в этих потокобезопасных структурах данных должны быть иммутабельными или защищенными, чтобы предотвратить состояние гонки при изменении уже хранящихся в них объектов.
### Индивидуальные решения
Если у вас есть сложные действия, которые необходимо синхронизировать, [@Volatile](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-volatile/) переменные или потокобезопасные структуры данных не помогут! И возможно, что встроенная аннотация [@Synchronized](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-synchronized/) недостаточно детализирована, чтобы сделать ваш вариант использования эффективным.
В этих случаях вам может потребоваться создать собственный механизм синхронизации с использованием параллельных утилит, таких как [защелки](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html) ([latches](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html)), [семафоры](https://en.wikipedia.org/wiki/Semaphore_(programming)) ([semaphores](https://en.wikipedia.org/wiki/Semaphore_(programming))) или [барьеры](https://en.wikipedia.org/wiki/Barrier_(computer_science)) ([barriers](https://en.wikipedia.org/wiki/Barrier_(computer_science))). В других случаях вы можете безоговорочно защитить многопоточный доступ к коду с помощью [блокировок](https://en.wikipedia.org/wiki/Lock_(computer_science)) ([locks](https://en.wikipedia.org/wiki/Lock_(computer_science))) или мьютексов (mutexes).
[Mutex](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/index.html) в Котлин имеет функции приостановки [lock](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/lock.html) и [unlock](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/-mutex/unlock.html), чтобы вы могли вручную защитить части кода вашей корутины. Удобно, что функция расширения [Mutex.withLock](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.sync/with-lock.html) упрощает нам работу:
```
class TransactionsRepository(
private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
) {
// Мьютекс, защищающий мутабельное состояние кэша
private val cacheMutex = Mutex()
private val transactionsCache = mutableMapOf()
private suspend fun addTransaction(user: User, transaction: Transaction) =
withContext(defaultDispatcher) {
// Мьютекс, защищающий мутабельное состояние кэша
cacheMutex.withLock {
if (transactionsCache.contains(user)) {
val oldList = transactionsCache[user]
val newList = oldList!!.toMutableList()
newList.add(transaction)
transactionsCache.put(user, newList)
} else {
transactionsCache.put(user, listOf(transaction))
}
}
}
}
```
Корутина, приостанавливающая выполнение до тех пор, пока оно не будет продолжено, с использованием `Mutex`, намного эффективнее, чем блокировка языка программирования Java, которая полностью блокирует поток. Будьте осторожны при использовании классов синхронизации языка программирования Java в корутинах, так как это может заблокировать поток, в котором выполняется корутина, и тем самым создать проблемы с [жизнеспособностью](https://en.wikipedia.org/wiki/Liveness).
Блок кода, переданный билдеру корутин, в конечном итоге выполняется в одном или нескольких потоках. Таким образом, корутины работают в потоковой модели рантайма Android со всеми ее ограничениями. С помощью корутин все еще можно написать неправильный уязвимый многопоточный код. Так что следите за доступом к общему мутабельному состоянию в вашем коде!
---
> ***Перевод статьи подготовлен в преддверии старта курса*** [***Android Developer. Basic***](https://otus.pw/QTcU/)***.***
>
> ***Также приглашаем всех желающих записаться на*** [***бесплатный демо-урок по теме: "Хранение данных. Room"***](https://otus.pw/QTcU/)
>
> ***Узнать подробнее о курсе*** [***Android Developer. Professional***](https://otus.pw/dHz3/)
>
> | https://habr.com/ru/post/546070/ | null | ru | null |
# Распознавание символов
Работа с изображениями — одна из самых распространенных задач в машинном обучении. Мы покажем пример обработки изображения, получение матриц (тензоров) чисел, подготовку данных обучающего множества, пример архитектуры нейронной сети.
Работа с изображениями является одной из самых распространенных задач в машинном обучении. Обычная картинка, воспринимаемая человеком однозначно, для компьютера не имеет никакого смысла и интерпретации, только если нет предварительно обученной нейронной сети, которая способна отнести изображение к одному определенному классу. Для работы такой нейронной сети необходимо ее обучение на тренировочных данных, изображениях предварительно обработанных и поданных на вход нейронной сети в виде матрицы чисел, характеризующих определенный тон (цвет) на определенной позиции в изображении. В этой статье приводится пример обработки изображения, получение матриц (тензоров) чисел, подготовка данных обучающего множества, пример архитектуры нейронной сети.
Постановка задачи: имеются цветные изображения букв и цифр (CAPTCHA). Необходимо распознать буквы и цифры, находящиеся на изображениях. Последовательность решения задачи:
* анализ изображений;
* подготовка данных;
* генерация данных;
* тренировка нейронной сети, предсказание ответов.
Рис.1 пример изображений (CAPTCHA)Проводим предварительный анализ 100 изображений в формате «.png». Изображения состоят из 29 уникальных символов «12345789абвгдежзиклмнопрстуфя». Символы могут быть повернуты на определенный угол (от -1° –+15°), могут быть смещены по горизонтали и вертикали, символы могут накладываться друг на друга. Символы представлены в цвете, все три символа могут иметь различные цвета. На фоне имеются более мелкие символы в светлых оттенках (шум на изображении). Для анализа, вывода и обработки изображений понадобятся библиотеки языка python 3 opencv, matplotlib, pillow. Определим положение символов на изображении путем подбора разделяющих линий:
```
import cv2 # импортируем библиотеку для раб.с графикой
image = cv2.imread('.\Captcha.png') # читаем изоб. Результат numpy array
# рисуем линию (img, (x1, y1), (x2, y2), (255, 255, 255), 4) –
# изображение на котором рисуем, точка начала линии, точка конца линии,
# цвет линии цветовая модель BGR, толщина линии.
image = cv2.line(image, (14, 0), (14, 50), (0, 0, 255), 1)
…
# для вывода можно задать функцию, параметры прочитанное иозбр., имя окна
def view_image(image, name_wind='default'):
cv2.namedWindow(name_wind, cv2.WINDOW_NORMAL) # # создаем окно вывода
cv2.imshow(name_wind, image) # # в окно передаем изображение image
cv2.waitKey(0) # # ждем нажатия любой клавиши, 0 нет таймера.
cv2.destroyAllWindows() # # уничтожение (закрытие) всех окон
view_image(image) # # вызов функции вывода с передачей прочитанного файла
```
Рис. 2 пример определение диапазона символаТак же для вывода удобно использовать matplotlib, особенность библиотеки в работе с моделью RGB: передав данные модели BGR вывод будет отличаться, интенсивный красный станет интенсивным синим и наоборот, зеленый не изменится. Для корректного вывода в matplotlib (если цвета имеют значения) необходимо поменять местами матрицы цветов синего и красного.
Перебором изображений с расстановкой разделяющих линий, определим место положение символов. На изображениях каждый символ находится в своем диапазоне. Для всех символов верхняя граница находится на 3 строке, нижняя на 47. Вертикальные границы (за которые символы не выходят): для первого символа 14–44 колонка, для второго символа: 32–62 колонка, для третьего символа: 48 –72. Изображение при чтении библиотекой opencv представляется в виде тензора numpy array, размерностью (50, 100, 3). Изображение представлено в 3 массивах, состоящих из 50 строк и 100 столбцов. Каждый из трех массивов отвечает за свой цвет BGR (blue синий, green зеленый, red красный), каждый из 3-х массивов находится в диапазоне от 0-255.
Рис.3 Цветовая модель RGBДанные такого вида не совсем удобны для дальнейшей обработки цветов. Так как символ имеет не четкий цвет, а сумму цветов, к краям более светлый тон, сумма цветов меняет свои значения. Для выделения символа определенного цвета необходимо будет указывать диапазоны для трех цветов B(n-m) G(k-l) R(y-z). Вместо этого проще представить изображение в другой цветовой модели HSV (Hue, Saturation, Value — тон, насыщенность, яркость). В библиотеке opencv единицы измерения Heu 0 – 179, S 0 – 255, V 0 –255. При данной цветовой модели достаточно указать сектор цвета Heu и для всех символов указать постоянные значения S 10 – 255, V 0 – 234, отсекая тем самым фон и шумовые изображения, представленные в более светлых тонах.
Рис.4 Цветовые модели RGB (BGR) и HSV
```
# # преобразование из BGR цветовой модели в HSV
image = cv2.imread('.\captcha_png')
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
```
HSV представляет собой тензор (50, 100, 3) (3 матрицы numpy array размерностью (50, 100), 50 одномерных массивов, содержащие 100 значений). Индексы матриц — [:, :, 0] Hue, [:, :, 1] Saturation, [:, :, 2] Value.
Исходное изображениеОтобразим матрицы в градиентах серого (0 – черный 255 – белый).
[:,:, 0] Тон, отсутствует белый т.к. диапазон до 179, приблизительный разброс цветов 160 – 179 и 0~30 красный цвет, 60 ~ 100 зеленый, 110 ~ 150 синий. На первом изображении цифра 9 более светлая т.к. оттенок красного попал в диапазон от 160, на втором изображении буква «м» черная т.к. оттенок попал в диапазон 0~30
[:,:, 1] Насыщенность, фон и шум на изображении представлен в светлых, пастельных тонах значения 0~10, символы имеют более выраженный цвет >10
[:,:, 2] Яркость, изображение светлое следовательно яркость фона 240 ~ 255, символы более темнее имеют значения < 240.
На основании матриц S и V (насыщенность и яркость), можно получить фильтры для отделения символов от фона и от шума в матрице Hue (тон).
```
mask_S = image[:, :, 1]< 10; mask_V = image[:, :, 1] > 240
```
Результат: две матрицы булевых значений (50, 100) [[True, False, ..,], …, [..]]. Значению истина соответствует фон и шум. Если применить эти фильтры к матрице тон (Hue) и придать значениям, соответствующим истина 255, матрица будет содержать значения 0-179, 255 – удобно для дальнейшей фильтрации (дальнейшая работа только с матрицей тон, Hue).
```
# значение 255 не попадает в диапазон матрицы 0 - 179
image[:, :, 0][mask_S] = 255 ; image[:, :, 0][mask_V] = 255
```
Рис.5 Результат фон и часть шума имеют значения 255Следующий этап — отделение символов друг от друга. Задаем диапазон, в котором находится символ.
Рис.6 Разделение символов по определенном диапазонам
```
img_char1 = image[3: 47, 14: 44, 0].copy()
img_char2 = image[3: 47, 32: 62, 0].copy()
img_char3 = image[3: 47, 48: 78, 0].copy()
```
Для выделения каждого символа и удаления части соседнего символа, отсекаем область нахождения соседнего символа, находим количество значений соответствующих тонам в матрице (максимальное количество значений имеет число 255 фон (500 – 800 значений в матрице), следующее по количеству значений будет основной тон символа, единичные значения будет иметь оставшийся не отфильтрованный шум). На основании основного тона символа находим диапазон оттенков N -10, N + 10.
Рис.7 Определение областей 1 и 3 символа, где нет данных 2-го символаОставляем часть 1 и 3 символа не попадающее в область 2 символа. Получаем матрицы, отвечающие за тон.
```
# преобразуем матрицу в массив значений, посчитаем количество значений
val_count_1 = img_char1[3: 47, 14: 32, 0].copy().reshape(-1)
val_color_hue_1 = pd.Series(val_count_1).value_counts()
# val_color_hue_1 ->255 – 741, 106 – 11, 104 – 11, 20 – 1, 99 – 1.
val_color_hue_1 = pd.Series(val_count_1).value_counts().index[1]
# числа тонов являются индексами, устанавливаем сектор тона Hue -10, +10.
val_color_char_hue_1_min = val_base_hue_1 – 10 = 106 - 10 = 96
val_color_char_hue_1_max = val_base_hue_1 + 10 = 106+ 10 = 116
```
На матрицы Hue для символов 1, 3 накладываем фильтр, значения где тон попадает в указанный диапазон равны 0, иначе 255.
```
mask_char1 = (img_char1> 96) & (img_char1<116)
img_char1[~mask_char1] = 255 # где не символ (полная область определения) img_char1[mask_char1] = 0 # где символ
```
Рис.8 Отображение результата в виде pandas dataframeНеобходимо привести значения к 0 и 1 и инвертировать матрицу.
```
img_char1[img_char1 == 0] = 1; img_char1[img_char1 == 255] = 0
```
Из 2-го символа, находящегося в центре изображения, удаляем части 1 и 3 символа путем определения частей матриц, пересекающих 2-й символ и приравнивании к 255 тех значений матрицы 2, где матрицы 1 и 3 не равны нулю.
Рис.9 Удаление из 2-го символа данных 1 и 3-го символовПроводим аналогичные преобразования матрицы символа 2. Результат матрицы символов 1, 2, 3 – со значениями 0, 1. При выводе изображения имеют пропуски, остатки шума. Проводим фильтрацию, дополнительное преобразование инструментами opencv, указываем ядро (окно матрицы) которое проходит по матрице символов и при нахождении рядом заполненных пикселей и пропусков, заполняет пропуски
```
kernel = np.ones((3, 3), np.uint8)
closing = cv2.morphologyEx(np_matrix, cv2.MORPH_CLOSE, kernel)
```
Рис.10 Корректировка данных, заполнение пропусковОпределяем центры символов, перемещаем символы в центр массива добавляя и удаляя строки, столбцы, заполненные нулями.
Рис.11 Расположение символов в средине матрицыРазработан алгоритм выделения символов из изображения. Для дальнейшего определения значения символа построим и обучим нейронную сеть. Для обучения нейронной сети скачиваем ~100 экземпляров картинок выделяем из них символы, размечаем картинки вручную. Получаем 300 экземпляров размеченных данных (массивы 44×30 содержащие числа 0 и 1). Этого количества данных недостаточно. Определяем и скачиваем шрифт, которым отображаются символы на картинках. Воспользовавшись библиотекой pillow языка python, размещаем символы шрифта на изображении 44×30, задаем смещение и поворот символов случайным выбором из заданных значений, преобразуем в массив nympy array. Формируем выборку данных из сгенерированных данных и данных размеченных вручную.
```
shift_x = [1, 1, -1, -1, -2, 2, 0, 0, 0]
shift_y = [1, 1, -1, -1, -2, 2, 0, 0, 0]
rotor_char = [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1]
char = '12345789абвгдежзиклмнопрстуфя'
# в цикле генерируем данные – ~10_000 – 60_000
shift _x_r = random.choice(shift_x)
shift _y_r = random.choice(shift_y)
rotor_r = random.choice(rotor_char)
char_r = random.choice(char)
```
Рис.13 Пример подобранного текста и размещение символов в матрицах
```
train_x = []
train_x.append(char)
train_x = np.array(train_x)
train_x = train_x.reshape(train_x.shape[0], train_x[1], train_x[2], 1)
```
Тренировочный набор данных представляет собой тензор размерностью (50000, 44, 30, 1), дополнительная размерность (1) для нейронной сети.
Каждому экземпляру тренировочной выборки соответствует экземпляр из массива ответов: char\_y = [0, 4, …, 29] – 50\_000 (цифры 0-29 ключи словаря символов
```
char = '12345789абвгдежзиклмнопрстуфя' # 29 позиций
dict_char = {char[i]: i for i in range(len(char))}
dict_char_reverse = {i[1]: i[0] for i in dict_char.items()}
```
Приведем данные предсказания к виду унитарный код (one-hot encoding). Преобразуем численные значения в массив, имеющий длину 29. Массив состоит из нулей и одной единицы. Позиция единицы соответствует кодируемому символу. Например, буква «а» будет иметь вид ‘000000000100000000000000000000’.
```
Img_y = utils.to_categorical(Img_y)
# пример 1 -> (array( [1, 0, 0, 0, …, 0, 0], dtype=float32)
# пример 2 -> (array( [0, 1, 0, 0, …, 0, 0], dtype=float32)
```
Разбиваем полученные данные на тренировочный набор и тестовый.
```
x_train, x_test, y_train, y_test = sklearn.train_test_split(
out_train_x_rsh, out_train_y_sh,
test_size=0.1, shuffle=True)
```
Для распознавания символов необходимо построить нейронную сеть, так как данные похожи на учебный набор mnist (рукописные цифры 28×28) на ресурсе kaggle находим примеры архитектуры нейронной сети дающие хороший результат. Архитектура нейронной сети:
```
# Определим простую модель
Import tensorflow as tf
def model_detection():
model=tf.keras.models.Sequential([
tf.keras.layers.Conv2D(input_shape=(44,30, 1), filters=32,
kernel_size=(5, 5), padding='same', activation='relu'),
tf.keras.layers.Conv2D( filters=32, kernel_size=(5, 5),
padding='same', activation='relu'),
tf.keras.layers.MaxPool2D(pool_size=(2, 2)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Conv2D( filters=64, kernel_size=(3, 3),
padding='same', activation='relu'),
tf.keras.layers.Conv2D( filters=64, kernel_size=(3, 3),
padding='same', activation='relu'),
tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(29, activation=tf.nn.softmax)])
model.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
returnmodel
# создадим экземпляр модели
model = model_detection()
```
Зададим параметр, при улучшении которого модель сохраняется (val*accuracy).*
```
checkpoint = ModelCheckpoint('captcha_1.hdf5', monitor='val_accuracy',
save_best_only=True, verbose=1)
model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test),
verbose=1, callbacks=[checkpoint])
```
*После тренировки сохраняются веса модели с наилучшими показателями val*accuracy, доли верных ответов. Дальнейшая работа программы: на вход подается изображение, которое обрабатывается ранее описанным алгоритмом. Результат обработки — numpy array (массив). Далее инициализируется модель, загружаются веса ранее обученной модели. На вход модели подают данные (1, 2, 3 символ). В результате модель выдает вероятность того или иного символа. Приняв за верный ответ позицию с наибольшей вероятностью из словаря «значение – символ» получаем символьное предсказание модели.
```
model2 = model_detection() # инициализируем
model2.load_weights('captcha_1.hdf5') # загружаем веса
prediction_ch_1 = model2.predict(char_1) # массив 29 значений вероятностей
# позиция на которой наибольшая вероятность, ключ к словарю ответов
prediction_ch_1 = np.argmax(prediction_ch_1, axis=1)
# из словаря ключ число, значение цифра или буква получаем ответ
dict_char_reverse[prediction_ch_1]
```
Данный алгоритм обрабатывает цветные изображения, на которых находятся символы букв и цифр, результат распознавания символов нейронной сетью 95% (точность), распознавание каптчи 82% (точность). На примере разбора алгоритма распознавания символов можно заметить, что основную долю разработки занимает подготовка, обработка и генерация данных. Выбор архитектуры и обучение нейронной сети является важней частью задачи, но не самой затратной по времени. Вариантов решения задачи распознавания цифр, букв, изображений предметов и т.п. множество, в данной статье приведен лишь один из примеров решения, показаны этапы решения, трудности, с которыми можно столкнуться в результате работы и примеры их преодоления. А как Вы работаете с каптчами? | https://habr.com/ru/post/541742/ | null | ru | null |
# Релиз CLion 2017.1: C++14, C++17, код на дизассемблере в отладчике, Catch, MSVC и многое другое
Привет, Хабр! Спешим поделиться радостной новостью – мы выпустили первый в этом году релиз нашей кросс-платформенной IDE для C и C++, **CLion 2017.1**!
Наши планы, как обычно, немного превосходят наши возможности и ресурсы. Но в этот релиз нам удалось успеть почти все из [запланированного](https://confluence.jetbrains.com/display/CLION/Roadmap+for+CLion+2017.1). Если вкратце:
* Поддержка C++14 (всё кроме *constexpr*)
* Начальная поддержка C++17 (мы начали с самой востребованной возможности – *nested namespaces*)
* Возможность конвертировать тип переменной в *auto*
* Во время отладки программы, при отсутствии файлов с исходным кодом можно переходить на код на дизассемблере (disassembly view)
* Поддержка фреймворка для юнит-тестирования Catch
* Значительное ускорение отклика редактора при печати кода (Zero Latency Typing)
* И, наконец, экспериментальная поддержка компилятора Microsoft Visual C++!
И это еще не все! Читайте подробности ниже.
Кстати, попробовать все новые возможности можно на небольшом [демо-проекте](https://github.com/anastasiak2512/CLion2017_1Demo), который мы специально подготовили для этих целей.
C++14 и C++17
-------------
Уже совсем скоро стандарт [C++17 будет официально принят](https://habrahabr.ru/company/yandex/blog/323972/) и C++ сообщество примется активно обсуждать и строить планы на C++19/20. Поэтому в версии 2017.1 мы постарались полностью поддержать все текущие (и официально принятые) стандарты современного C++.
Сначала мы закончили с *constexpr* из C++11, а затем принялись за C++14, а именно поддержали следующие возможности:
* *auto return type*,
* *generic lambdas*,
* *variable templates*, and
* *generalized lambda captures*.
Поддержка в данном случае заключается в корректном парсинге и резолве соответствующих конструкций языка (как вы помните, [парсер](https://blog.jetbrains.com/blog/2015/08/06/jetbrains-way-to-cpp-the-inside-story-of-our-journey/#parser) у CLion свой) и, как следствие, в корректной подсветке кода, навигации, рефакторингах, автодополнении и корректной работе анализатора кода.
Типичный пример – использование *generalized lambda captures*, которое раньше приводило к тому, что весь код лямбды некорректно подсвечивался как неиспользуемый. Теперь, как видите, все хорошо:
Еще один пример – это использование *auto* для возвращаемого типа. В предыдущих версиях CLion не мог корректно вывести тип переменной `vec`, а значит и предложить корректное автодополнение:
Таким образом, из непокрытых возможностей стандарта C++14 остался только *constexpr*. И уже начата работа в направлении C++17: поддержаны *nested namespaces*. Полный список поддерживаемых в CLion возможностей современных стандартов C++ можно найти по [ссылке](https://www.jetbrains.com/help/clion/2017.1/cpp_support.html).
Make auto
---------
С появлением современных стандартов в C++ произошло много значительных изменений. Код на современном C++ существенно отличается от кода на C++ образца 98-го или даже 2003 года. И чем активнее язык развивается, тем актуальнее встает вопрос преобразования кода “старого” в “новый”. А что как не IDE может помочь справиться с этой задачей? Рефакторинги и другие преобразования кода – это как раз то, что мы в JetBrains очень любим.
Работа в этом направлении только началась, и идей у нас много. А пока что мы добавили возможность конвертации типа переменной в *auto*:
Обратная замена тоже может быть реализована и даже есть в планах ([CPP-8555](https://youtrack.jetbrains.com/issue/CPP-8555)).
PCH
---
Precompiled headers (PCH) – это общепринятый способ сэкономить на времени компиляции, если в проекте используются большие заголовочные файлы или просто какой-то набор таких файлов используется очень часто. Притом эти файлы меняются редко. В такой ситуации есть смысл скомпилировать их единожды и в дальнейшем просить компилятор переиспользовать имеющуюся информацию.
В такой ситуации IDE должна разобраться, какие PCH передаются при компиляции, найти их и прочитать символы из этих заголовочных файлов, которые могут понадобиться для основного кода проекта.
Теперь CLion так умеет. Относится это как к PCH, так и к заголовочным файлам, передаваемым через опцию компиляции *-include*. То есть соответствующие классы, функции, и т. п. из таких заголовочных файлов корректно понимаются:
Обратите внимание, что для GCC есть небольшие [ограничения](https://blog.jetbrains.com/clion/2017/02/clion-2017-1-eap-pch/), связанные с техническими особенностями реализации.
Дизассемблирование в отладчике
------------------------------
Один из самых популярных запросов в нашем [трекере](https://youtrack.jetbrains.com/issues/CPP) – возможность показа ассемблерного кода при отладке. В версии 2017.1 мы реализовали две важные возможности, связанные с этим запросом:
* Подсветка синтаксиса кода на Ассемблере в редакторе (работает только для диалекта AT&T) для файлов с расширением *.s* и *.asm*, или любых других, сконфигурированных в Settings | Editor | File Types | Assembly Language.
* Показ кода на дизассемблере (disassembly view) во время отладки при переходе на вызов, для которого нет исходных текстов программы.
Работает disassembly view пока только для GDB. По коду на дизассемблере можно походить, чтобы лучше понять, что именно делает программа и, возможно, найти проблему, ради которой и запускался отладчик. Поставить точки останова в таком коде пока нельзя.
На будущее запланирована возможность показа кода на дизассемблере даже в том случае, когда исходные коды программы имеются ([CPP-9091](https://youtrack.jetbrains.com/issue/CPP-9091)).
Catch
-----
Для C++ существует [огромное множество](https://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B) тестовых фреймворков: Google Test, CppUnit, CppTest, Boost, QtTest и другие. CLion поддерживает Google Test уже довольно давно. А в версии 2017.1 появилась поддержка Catch. Почему именно Catch?
* Catch очень легко начать использовать. Чтобы подключить Catch к своему проекту, достаточно скачать и добавить в проект один единственный заголовочный файл. Удобно, не правда ли?
* Тест-кейсы в Catch достаточно гибкие и удобные.
* Автор фреймворка Catch, [Phil Nash](https://twitter.com/phil_nash), с осени прошлого года работает с нами в компании JetBrains в роли девелопер-адвоката C++ продуктов компании. Так что параллельно с поддержкой Catch в CLion дорабатывался и сам фреймворк. Что, конечно, существенно помогло разработке.
Основное в поддержке – специальное окно с выводом результатов тестов (test runner). Если для запуска используется специальная Run/Debug конфигурация – Catch – то вывод результатов будет осуществляться туда:
Помимо удобного представления результатов, в этом окне можно:
* перезапустить все тесты или только упавшие;
* сортировать тесты по имени или по длительности прохождения;
* посмотреть/перейти на код конкретного теста;
* посмотреть вывод каждого конкретного теста и сообщения об ошибках;
* перенести результаты текущего запуска тестов в файл;
* посмотреть предыдущие запуски тестов по истории, которая сохраняется автоматически.
Кстати, в конфигурациях работает автодополнение для тегов, которые используются в тестах. Это помогает быстрее настроить набор тестов, которые надо запускать в рамках конфигурации.
Подробнее об особенностях и преимуществах Catch и его интеграции в CLion можно [почитать в нашем англоязычном блоге](https://blog.jetbrains.com/clion/2017/03/to-catch-a-clion/).
Компилятор Microsoft Visual C++
-------------------------------
Вероятно, одна из самых интересных возможностей этой версии. По-крайней мере, для пользователей на Windows. Дело в том, что раньше CLion работал только с GCC/Clang и на Windows приходилось устанавливать MinGW, MinGW-w64 или Cygwin. А они, в свою очередь, не всегда легко и понятно конфигурируются при установке, да и имеют ряд неудобств в целом. Так что пользователи на Windows вполне резонно просили нас поддержать компилятор Microsoft Visual C++. Что мы и сделали в 2017.1, правда пока в *экспериментальном режиме*.
Чтобы попробовать, надо включить соответствующую опцию в Registry:
* Откройте диалог Find Action (`Shift+Ctrl+A` на Linux/Windows, `⇧⌘A` на macOS)
* Введите *Registry*
* Выберите и откройте редактор Registry
* Начните вводить *clion.enable.msvc* – CLion найдет подходящую опцию в списке
* Включайте и пользуйтесь MSVC!
Теперь в настройках тулчейнов у вас появится возможность выбрать компилятор Microsoft Visual C++:
Поддерживаемые версии Visual Studio – 2013, 2015, 2017 – находятся и определяются автоматически.
Тут стоит оговориться, что работает MSVC по-прежнему через CMake (в качестве генератора в котором используется NMake вместе обычных Makefiles). То есть *msbuild* не поддержан. CLion предоставляет настройки архитектуры, платформы и версии в Build, Execution, Deployment | CMake:
Из важных ограничений стоит еще отметить: отсутствие отладчика и отсутствие поддержки специфических расширений языка от Microsoft. В остальном, мы будем рады, если те, кто был заинтересован в поддержке компилятора Microsoft Visual C++, попробуют его и поделятся с нами своими отзывами.
Zero-latency typing
-------------------
Про zero-latency typing рассказывать можно довольно долго. Но мы лучше предложим читателям ознакомится с [детальным исследованием](https://pavelfatin.com/typing-with-pleasure/) этого вопроса от нашего коллеги.
В версии 2017.1 по умолчанию включили соответствующий режим, который до этого (в течение полугода) был в тестовом режиме. Само же решение позволяет уменьшить количество перерисовок редактора, тем самым уменьшая задержку между непосредственно печатью кода и его отрисовкой на экране.
Плагины
-------
Версия CLion 2017.1 включает в себя полезные обновления таких плагинов как Swift, Go, Settings Repository и не только.
Если говорить про [Swift](https://blog.jetbrains.com/clion/2015/12/swift-plugin-for-clion/), то на изменения стоит обратить внимание тем, кто использует или планирует использовать CLion в качестве Swift IDE на Linux. Благодаря команде [AppCode](https://www.jetbrains.com/objc/) в плагине появились новые возможности:
* шаблон для создания нового Swift проекта, с предварительно заполненным файлом CMake и Package.swift;
* ошибки, предупреждения и возможные исправления от анализатора кода на основе SourceKit;
* возможность генерации типа переменной уже после ее использования.
Изменения [Go плагина](https://plugins.jetbrains.com/plugin/9568-go) были направлены на приведение его в соответствие с [Gogland](https://www.jetbrains.com/go/), отдельно стоящей IDE на базе платформы IntelliJ для этого языка.
А [плагин для хранения настроек](https://github.com/develar/settings-repository) IDE в репозитории, наконец, был “забандлен” в саму IDE.
И многое другое
---------------
В версии 2017.1 произошло еще немало других изменений. Так, например, Find in Path (текстовый поиск по проекту или любому выбранному скоупу) доступен в виде popup-окна с удобным предпросмотром результата:
А в окне логов от системы контроля версий (для Git и Mercurial) появилась возможность использовать регулярные выражения и выбирать учитывать ли или наоборот игнорировать регистр.
Вот здесь небольшая демонстрация новых возможностей CLion 2017.1:
Если вам стало интересно, качайте 30-дневную [бесплатную пробную версию](https://www.jetbrains.com/clion/download/), а в разделе цен можно узнать о [стоимости подписки](http://www.jetbrains.com/clion/buy/).
Следите также за статьями и обновлениями в нашем [англоязычном блоге](https://blog.jetbrains.com/clion/). Мы будем рады ответить на любые ваши вопросы в комментариях.
*Ваша команда JetBrains CLion
The Drive to Develop* | https://habr.com/ru/post/325372/ | null | ru | null |
# Из ничего к ЦОД с VXLAN/EVPN или как готовить Cumulus Linux. Часть 2
Всем привет. Вот и подошло продолжение [первой части](https://habr.com/ru/post/526022/). Как и обещал, в данной статье, я хочу затронуть основные варианты реализации фабрики на VXLAN/EVPN, и рассказать почему мы решили выбрать то или иное решение в нашем ЦОД.
Выбираем дизайн Underlay
------------------------
#### Предисловие
Первое, с чем приходится сталкиваться при строительстве фабрики, это проработка дизайна Underlay - как мы хотим строить наши VXLAN туннели (точнее организовать поиск VTEP)?
Варианта у нас 3:
1.Статические туннели, в которых мы задаем каждый VTEP руками - это сразу не наш вариант, но, скажу по секрету, все еще есть провайдеры, которые ручками строят RSVP-TE туннели под каждый сервис. Так что не удивлюсь, если есть такие реализации в промышленном масштабе. Ну и никто не отменял SDN.
2.Multicast - в целом, простая реализация, но для нас вариант отпал сразу, т.к. Cumulus не умеет в подобную реализацию, да и Juniper в своих материалах говорит о его resource-intensive и медленной сходимости.
3.BGP или BGP, или все-таки BGP? Как обычно, в случае когда нам нужен какой-нибудь широкий функционал, который был бы гибким, мы приходим к BGP, точнее в нашем случае к EVPN с сигнализацией по BGP. На нем и остановимся подробней. Так как бывает iBGP и eBGP, то и реализации underlay могут быть с каждым из них.
#### iBGP
При использовании iBGP у нас сразу же появляется потребность в IGP, будь то OSPF или IS-IS (хоть статика), т.к. строить мы будем до Loopback, а сообщать маршруты о том, как дойти до них, нам кто-то должен. Так же не забываем о том, как iBGP распространяет маршруты, что вынуждает нас строить full-mesh (в такой реализации Spine совсем ничего не знает о существовании BGP).
Или можем сделать Spine в роли Route-Reflector.
По итогу мы получаем как минимум 2 протокола маршрутизации и плюсом к этому full-mesh или RR. Это, конечно, не самое худшее что могло бы быть, но следующий вариант мне нравится больше.
#### eBGP
Данная реализация, на мой взгляд, самая понятная и надежная, и в итоге мы остановились на ней. Как только мы переходим к eBGP, потребность в Route-Reflector отпадает (надеюсь, все понимают почему), и продолжать использовать IGP тоже не имеет большого смысла, т.к. мы можем начинать строить соседства с p2p адресов. Так же в данном дизайне MLAG имеют более понятную реализацию. Про нее бы я остановился подробней. Оба MLAG свича помещаются в одну AS, т.к. при правильной реализации для всего остального VXLAN/EVPN домена они будут казаться одним устройством, что делает логичным их помещение в одну AS. Само соседство мы строим на peerlink'e, и это действительно необходимо, т.к. в случае, если у одного коммутатора упадут линки в сторону Spine, то он начнет дропать весь входящий трафик из-за того, что не будет маршрутов.
Единственное, что может кого-то спугнуть, это то, что нужно вести адресный план с номерами AS. Но счастливые обладатели Cumulus с версией 4.2(т.к. именно в ней это вышло) могут пойти другим путем, т.к. он теперь умеет автоматическое назначение AS, основываясь на MACе, что гарантирует вам уникальность (берет он из приватного пула 32-bit AS).
Так же стоит затронуть почему оба Spine находятся в одной AS. Т.к. каждый Spine имеет прямой линк к каждому Leaf, то трафик через него не может пройти дважды. Следовательно, мы можем использовать одинаковый номер AS на всех Spine, что собственно и советует Cumulus.
P.S. при использовании коротких AS можно все грамотно и красиво разделить, чтобы по номеру AS было понятно где был создан префикс. Так что использовать 32-bit AS совсем необязательно.
#### BGP Unnumbered
Думаю, многие не очень любят сталкиваться с адресным планированием p2p сетей, и как бы хотелось иметь только loopback и больше ничего. Если такие мысли вас когда-либо посещали, то стоит присмотреться к использованию Unnumbered. Реализация данного функционала в Cumulus отличается от Cisco, где у вас происходит заимствование адреса с интерфейса. Вместо этого у Cumulus выделен отдельный пул IPv6 адресов, которые динамически назначаются на интерфейс и по факту на них строится eBGP соседство. Так же на самом соседстве обязательно должен быть настроен extended-nexthop (для того, чтобы вы могли маршрутизировать IPv4 Family поверх IPv6 сессии).
P.S. Если на интерфейсах уже назначен какой-либо IPv4 /30 или /31 адрес, то BGP пиринг будет с них. Так же он не может работать в broadcast сетях, только p2p.
#### BGP+BFD
Как бы вы не хотели, но в любом случае таймеры самого BGP всегда будут измеряться секундами. И с учетом того, что сейчас появляются iSCSI, VSAN и т.д. такие задержки никто не может себе позволить. Как и во всех других протоколах маршрутизации нас спасает BFD. У Cumulus минимальные значения это 2x50 мс, насколько я знаю Cisco уже умеет 2х33 мс, так что данный функционал нам обязателен.
**Что имеем в итоге?**
1.Маршрутизация на eBGP с автоназначением AS + iBGP для MLAG пары
2.Из адресации нужны только loopback, все остальное нам заменяет Unnumbered
3.BFD
#### Настало время все настроить и посмотреть как оно работает
1.Как выглядит автоназначение AS у Cumulus
```
#Вариации у Cumulus при выборе AS
#P.S. Как и говорил выше, для всех Spine мы можем использовать одну AS
cumulus@Switch1:mgmt:~$ net add bgp autonomous-system
<1-4294967295> : An integer from 1 to 4294967295
leaf : Auto configure a leaf ASN in the 4-byte private range 4200000000 - 4294967294 based on the switch
MAC
spine : Auto configure a spine AS-number in the 4-byte private ASN range. The value 4200000000 is always
used
#Что по факту происходит при выборе "net add bgp autonomous-system leaf"
cumulus@Switch1:mgmt:~$ net add bgp autonomous-system leaf
cumulus@Switch1:mgmt:~$ net pending
+router bgp 4252968529 #Процесс BGP с автоматически сгенерированным AS
+end
```
2.Конфигурация BGP+Unnumbered
```
#loopback
net add loopback lo ip address 10.223.250.1/32
#При MLAG добавляется общий lo для пары(Он как раз и будет светится в маршрутах)
net add loopback lo clag vxlan-anycast-ip 10.223.250.30
#AS+Router ID
net add bgp autonomous-system leaf
net add bgp router-id 10.223.250.1
#Создаем стандартную конфигу для соседей через peer-group
net add bgp neighbor fabric peer-group #Создаем саму peer группу
net add bgp neighbor fabric remote-as external #Обозначаем что это eBGP
net add bgp neighbor fabric bfd 3 50 50 #Классический BFD
net add bgp neighbor fabric capability extended-nexthop # IPv4 over IPv6
#Задаем соседей через интерфейсы(Unnumbered)
net add bgp neighbor swp2 interface peer-group fabric
net add bgp neighbor peerlink.4094 interface remote-as internal #iBGP на Peerlink
net add bgp ipv4 unicast neighbor peerlink.4094 next-hop-self #У нас всетаки iBGP
net add bgp ipv4 unicast redistribute connected #Отдаем в BGP все свои сетки
#EVPN
net add bgp l2vpn evpn neighbor fabric activate #Активируем family для eBGP
net add bgp l2vpn evpn neighbor peerlink.4094 activate #iBGP
net add bgp l2vpn evpn advertise-all-vni #Сообщаем BGP соседям о своих VNI
```
3.BGP Summary
```
cumulus@Switch1:mgmt:~$ net show bgp summary
#IPv4
show bgp ipv4 unicast summary
=============================
BGP router identifier 10.223.250.1, local AS number 4252968145 vrf-id 0
BGP table version 84
RIB entries 29, using 5568 bytes of memory
Peers 3, using 64 KiB of memory
Peer groups 1, using 64 bytes of memory
#Как видим вместо адресов соседей у нас указаны интерфейсы
Neighbor V AS MsgRcvd MsgSent TblVer InQ OutQ Up/Down State/PfxRcd
Switch3(swp2) 4 4252424337 504396 484776 0 0 0 02w0d23h 3
Switch4(swp49) 4 4208128255 458840 485146 0 0 0 3d12h03m 9
Switch2(peerlink.4094) 4 4252968145 460895 456318 0 0 0 02w0d23h 14
Total number of neighbors 3
#EVPN
show bgp l2vpn evpn summary
===========================
BGP router identifier 10.223.250.1, local AS number 4252968145 vrf-id 0
BGP table version 0
RIB entries 243, using 46 KiB of memory
Peers 3, using 64 KiB of memory
Peer groups 1, using 64 bytes of memory
Neighbor V AS MsgRcvd MsgSent TblVer InQ OutQ Up/Down State/PfxRcd
Switch3(swp2) 4 4252424337 504396 484776 0 0 0 02w0d23h 237
Switch4(swp49) 4 4208128255 458840 485146 0 0 0 3d12h03m 563
Switch2(peerlink.4094) 4 4252968145 460895 456318 0 0 0 02w0d23h 807
Total number of neighbors 3
```
4.net show route
```
cumulus@Switch1:mgmt:~$ net show route
show ip route
=============
Codes: K - kernel route, C - connected, S - static, R - RIP,
O - OSPF, I - IS-IS, B - BGP, E - EIGRP, N - NHRP,
T - Table, v - VNC, V - VNC-Direct, A - Babel, D - SHARP,
F - PBR, f - OpenFabric,
> - selected route, * - FIB route, q - queued route, r - rejected route
#Как видим все IPv4 адреса доступны через IPv6
#И да у Cumulus есть weight, аналогичный Cisco
C>* 10.223.250.1/32 is directly connected, lo, 02w0d23h #Loopback
B>* 10.223.250.2/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d23h
B>* 10.223.250.6/32 [20/0] via fe80::fe70:e5c, swp49, weight 1, 3d12h19m
B>* 10.223.250.7/32 [20/0] via fe80::fe70:e5c, swp49, weight 1, 3d12h19m
B>* 10.223.250.9/32 [20/0] via fe80::fe70:e5c, swp49, weight 1, 3d12h19m
C>* 10.223.250.30/32 is directly connected, lo, 02w0d23h #MLAG Loopback
B>* 10.223.250.101/32 [20/0] via fe80::fe9e:67ec, swp2, weight 1, 02w0d23h
B>* 10.223.250.102/32 [20/0] via fe80::fe9e:67ec, swp2, weight 1, 02w0d23h
B>* 10.223.250.103/32 [20/0] via fe80::fe9e:67ec, swp2, weight 1, 02w0d23h
B>* 10.223.252.11/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
B>* 10.223.252.12/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
B>* 10.223.252.20/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
B>* 10.223.252.101/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
B>* 10.223.252.102/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
B>* 10.223.252.103/32 [200/0] via fe80::fe70:e50, peerlink.4094, weight 1, 02w0d
```
5.traceroute + BFD
```
#traceroute полностью линуксовый, при желании можно делать трассировку по TCP
cumulus@Switch1:mgmt:~$ traceroute -s 10.223.250.1 10.223.250.6
vrf-wrapper.sh: switching to vrf "default"; use '--no-vrf-switch' to disable
traceroute to 10.223.250.6 (10.223.250.6), 30 hops max, 60 byte packets
# Все ответы идут с loopback интерфейсов
1 10.223.250.7 (10.223.250.7) 1.002 ms 1.010 ms 0.981 ms
2 10.223.250.6 (10.223.250.6) 0.933 ms 0.917 ms 1.018 ms
#Проверяем BFD
cumulus@Switch1:mgmt:~$ net show bfd
----------------------------------------------------------------------------------
port peer state local type diag vrf
----------------------------------------------------------------------------------
swp2 fe80::1e34:daff:fe9e:67ec Up fe80::1e34:daff:fea6:b53d singlehop N/A N/A
swp49 fe80::ba59:9fff:fe70:e5c Up fe80::1e34:daff:fea6:b510 singlehop N/A N/A
```
На данном этапе Underlay уже полностью готов к использованию, теперь можем перейти к Overlay.
### Выбираем дизайн Overlay
Как понятно из названия статьи, Overlay у нас на VXLAN с поиском VTEP через EVPN. Но и тут не все так просто. Существуют 3 основных дизайна маршрутизации трафика между SVI, на них как раз и остановимся.
#### Centralized IRB
В данной реализации у нас появляется единая точка выхода из подсети, это centralized switch. Зачастую это несколько отдельных коммутаторов (active-active пара), которые занимаются только L3 форвардингом, а все остальные Leaf коммутаторы занимаются только L2. Дополнительно ко всему в такой реализации сentralized switch должен анонсировать EVPN type-2 маршрут (MAC+IP) c расширенным Default Gateway community(0x03). Так же не забываем что на centralized switch должны присутствовать VNI со всей фабрики.
\*Все Leaf коммутаторы в MLAG пареВ моем понимании, данный дизайн выглядит хорошо только в том случае, когда взаимодействие между разными подсетями минимальны, или Leaf не умеют в L3. Но т.к. у нас в целевой фабрике планировалось очень много L3 взаимодействия, данный дизайн был отброшен сразу, чтобы не гонять лишний раз трафик.
#### Asymmetric IRB
Очень схожая по настройке реализация с Symmetric IRB (о которой ниже), но с одним исключением. Вся маршрутизация происходит на первом же VTEP, и последующим устройствам остаётся только отдать пакет по L2. При такой реализации необходимо, чтобы на каждом Leaf были все VNI+Vlan, что является платой за отказ от L3VNI.
P.S. На самом деле, средствами автоматизации можно прийти к тому, что конфигурация у всех устройств фабрики всегда одинаковая (следовательно, есть все VNI). При таких условиях данный дизайн может быть очень даже не плох, с учетом избавления от необходимости выделения VLAN под каждый VRF. Но в условиях того, что на текущий момент автоматизация у нас только в зачаточном состоянии, вероятноcть человеческой ошибки слишком высока.
#### Symmetric IRB
При симметричной модели для всех L3 коммуникаций у нас создается отдельная сущность L3VNI, с которой ассоциируется VLAN. Именно данный функционал избавляет нас от необходимости иметь все VNI на каждом VTEP.
Для того, чтобы было понятно что происходит, давайте рассмотрим то, как пойдет пакет с VM3 на VM4. При попадании пакета на Leaf03/04, он делает route-lookup, в котором видит что VM4 доступна через Leaf05/06, а nexthop является L3VNI интерфейс. Далее Leaf05/06 получает данный пакет, снимает VXLAN заголовок и передает уже чистый пакет в SVI20. То есть помещение в нужный SVI идет именно на конечном устройстве, что как раз и избавляет нас от необходимости иметь его на всех устройствах, но L3VNI у нас должен быть везде.
Как итог мы выбрали именно этот дизайн для Overlay.
Заканчиваем с настройкой фабрики
--------------------------------
Пора настроить уже сам Overlay и посмотреть, как у нас будет работать поиск VTEP и распространение маршрутов.
1.Создаем L3VNI
```
#VRF+VNI
net add vrf Test vrf-table auto #Cоздаем VRF и автоматически назначаем RD+RT
net add vrf Test vni 200000 #Добавляем VNI к VRF
net add vxlan vniTest vxlan id 200000 #Создаем L3VNI
net add vxlan vniTest bridge learning off #Изученением MAC занимается EVPN
net add vxlan vniTest vxlan local-tunnelip 10.223.250.1 #Source Адрес туннеля
#VLAN
net add vlan 2000 hwaddress 44:38:39:BE:EF:AC #Делается только для MLAG
net add vlan 2000 vlan-id 2000 #Номер влана
net add vlan 2000 vlan-raw-device bridge #Добавление в bridge
net add vlan 2000 vrf vniTest #Ассоциация с VRF
net add vxlan vniTest bridge access 2000 #Ассоциируем VLAN с L3VNI
```
2.Создаем VNI
```
#VNI
net add vxlan vni-20999 vxlan id 20999
net add vxlan vni-20999 bridge arp-nd-suppress on #Включаем ARP-supress,уменьшаем BUM
net add vxlan vni-20999 bridge learning off #Изученением MAC занимается EVPN
net add vxlan vni-20999 stp bpduguard # Включаем bpduguard
net add vxlan vni-20999 stp portbpdufilter # Включаем bpdufilter
net add vxlan vni-20999 vxlan local-tunnelip 10.223.250.1 #Source Адрес туннеля
#Создаем VLAN
net add vlan 999 ip address 10.223.255.253/24 # IP на VLAN
#Создаем виртуальный IP, для того что бы сделать один Gateway на всю сеть
net add vlan 999 ip address-virtual 44:39:39:ff:01:01 10.223.255.254/24
net add vlan 999 vlan-id 999 #Номер влана
net add vlan 999 vlan-raw-device bridge #Добавление в bridge
net add vlan 999 vrf Test #Ассоциация с VRF
net add vxlan vni-20999 bridge access 999 #Ассоциируем VLAN с VNI
#P.S. Это конфига если нам нужен L2 only vlan (Конфигурация VNI не меняется)
net add vlan 999 ip forward off
net add vlan 999 vlan-id 999
net add vlan 999 vlan-raw-device bridge
```
3.Настройка соседства с внешней инфраструктурой
```
#Создаем самый обычный BGP процесс в VRF
net add bgp vrf Test autonomous-system 4252424337
net add bgp vrf Test router-id 10.223.250.101
net add bgp vrf Test neighbor 100.64.1.105 remote-as 65083
net add bgp vrf Test ipv4 unicast redistribute connected
net add bgp vrf Test ipv4 unicast redistribute static
#Конфига для корректной работы MLAG+VSS через BGP+SVI.
net add bgp vrf Test ipv4 unicast neighbor 100.64.1.105 route-map Next-Hop-VRR_Vl997 out
#P.S. Стоит так же заметить что в инфру будут отдаваться /32 от EVPN
#В нашем случая я их фильтровал на принимающей стороне.
net add bgp vrf Test l2vpn evpn advertise ipv4 unicast #Отдаем маршруты в EVPN
```
На данном этапе с конфигурацией мы закончили, теперь предлагаю посмотреть как это все выглядит:
```
#VNI
cumulus@Switch1:mgmt:~$ net show evpn vni
VNI Type VxLAN IF MACs ARPs Remote VTEPs Tenant VRF
20995 L2 vni-20995 5 3 1 default #VNI, без L3SVI
20999 L2 vni-20999 26 24 4 Test #VNI
200000 L3 vniTest 3 3 n/a Test #Сам L3VNI
#VNI подробней
cumulus@Switch1:mgmt:~$ net show evpn vni 20999
VNI: 20999
Type: L2
Tenant VRF: Test
VxLAN interface: vni-20999
VxLAN ifIndex: 73
#При наличии MLAG, будет использоватся vxlan-anycast-ip
Local VTEP IP: 10.223.250.30
Mcast group: 0.0.0.0 #Не используется
Remote VTEPs for this VNI: #Те у кого так же есть данный VNI
10.223.250.9 flood: HER #Используем Head-end Replication
10.223.252.103 flood: HER
10.223.252.20 flood: HER
10.223.250.103 flood: HER
Number of MACs (local and remote) known for this VNI: 26
Number of ARPs (IPv4 and IPv6, local and remote) known for this VNI: 24
Advertise-gw-macip: No #Community при centralized IRB
```
```
#Таблица с тем откуда изучены маки
cumulus@Switch3:mgmt:~$ net show evpn mac vni 20999
Number of MACs (local and remote) known for this VNI: 28
Flags: B=bypass N=sync-neighs, I=local-inactive, P=peer-active, X=peer-proxy
MAC Type Flags Intf/Remote ES/VTEP VLAN Seq #'s
0c:59:9c:b9:d8:dc remote 10.223.250.30 0/0
0c:42:a1:95:79:7c remote 10.223.250.30 0/0
#Таблица MAC,где видим Interface VNI
cumulus@Switch3:mgmt:~$ net show bridge macs vlan 999
VLAN Master Interface MAC TunnelDest State Flags
---- ------ --------- ----------------- ---------- --------- ------------
999 bridge bridge 1c:34:da:9e:67:68 permanent
999 bridge bridge 44:39:39:ff:01:01 permanent
999 bridge peerlink 1c:34:da:9e:67:48 permanent
999 bridge peerlink 1c:34:da:9e:67:e8 static sticky
999 bridge vni-20999 00:16:9d:9e:dd:41 extern_learn
999 bridge vni-20999 00:21:1c:2e:86:42 extern_learn
999 bridge vni-20999 00:22:0c:de:30:42 extern_learn
#Маки самих VTEP
cumulus@Switch3:mgmt:~$ net show evpn rmac vni all
VNI 200000 RMACs 3
RMAC Remote VTEP
44:38:39:be:ef:ac 10.223.250.30
44:39:39:ff:40:94 10.223.252.103
44:38:39:be:ef:ae 10.223.250.9
#Arp-cache
cumulus@Switch3:mgmt:~$ net show evpn arp-cache vni 20999
Number of ARPs (local and remote) known for this VNI: 28
Flags: I=local-inactive, P=peer-active, X=peer-proxy
Neighbor Type Flags State MAC Remote ES/VTEP
10.223.255.242 local active 1c:34:da:9e:67:68
10.223.255.13 remote active 0c:42:a1:96:d2:44 10.223.250.30
10.223.255.243 local inactive 06:73:4a:02:27:8a
10.223.255.7 remote active 0c:59:9c:b9:f8:fa 10.223.250.30
10.223.255.14 remote active 0c:42:a1:95:79:7c 10.223.250.30
```
```
#Таблица маршрутизации
cumulus@Switch1:mgmt:~$ net show route vrf Test | grep "10.3.53"
//Как видим все next-hop vlan2000, который мы отдали раньше под L3VNI
C * 10.223.255.0/24 [0/1024] is directly connected, vlan999-v0, 03w3d04h
C>* 10.223.255.0/24 is directly connected, vlan999, 03w3d04h
B>* 10.223.255.1/32 [20/0] via 10.223.250.30, vlan2000 onlink, weight 1, 02w5d04h
B>* 10.223.255.2/32 [20/0] via 10.223.250.30, vlan2000 onlink, weight 1, 02w5d04h
B>* 10.223.255.3/32 [20/0] via 10.223.250.30, vlan2000 onlink, weight 1, 02w5d04h
#Пример вывода EVPN маршрута
cumulus@Switch3:mgmt:~$ net show bgp evpn route vni 20999
BGP table version is 1366, local router ID is 10.223.250.101
Status codes: s suppressed, d damped, h history, * valid, > best, i - internal
Origin codes: i - IGP, e - EGP, ? - incomplete
EVPN type-1 prefix: [1]:[ESI]:[EthTag]:[IPlen]:[VTEP-IP]
EVPN type-2 prefix: [2]:[EthTag]:[MAClen]:[MAC]:[IPlen]:[IP]
EVPN type-3 prefix: [3]:[EthTag]:[IPlen]:[OrigIP]
EVPN type-4 prefix: [4]:[ESI]:[IPlen]:[OrigIP]
EVPN type-5 prefix: [5]:[EthTag]:[IPlen]:[IP]
Network Next Hop Metric LocPrf Weight Path
*> [2]:[0]:[48]:[00:16:9d:9e:dd:41]
10.223.250.30 0 4252968145 i
RT:9425:20999 RT:9425:200000 ET:8 Rmac:44:38:39:be:ef:ac
*> [2]:[0]:[48]:[00:22:56:ac:f3:42]:[32]:[10.223.255.1]
10.223.250.30 0 4252968145 i
RT:9425:20999 RT:9425:200000 ET:8 Rmac:44:38:39:be:ef:ac
```
Заключение
----------
Как итог, мы получили готовую VXLAN/EVPN фабрику. В Underlay у нас Unnumbered BGP и больше ничего, а в качестве Overlay мы имеем VXLAN/EVPN c Symmetric IRB, чего для решения наших задач в ЦОД более чем достаточно. Данный дизайн так же можно растянуть и на сами сервера, чтобы строить туннели непосредственно с них.
Конечно, я не затронул всех возможных дизайнов по типу маршрутизации на Spine, но такой цели и не преследовалось. Надеюсь, статья кому-нибудь придётся по душе и будет полезна в планировании или эксплуатации собственного ЦОД. В случае, если есть идеи по улучшению или заметили критическую ошибку, прошу в комментарии.
[Часть 1](https://habr.com/ru/post/526022/) | https://habr.com/ru/post/527830/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.