text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Что нового в Rails 5.0. Можно планировать переезд
На 16 марта запланирован релиз Rails 5.0, самое время разобраться, что же нового и вкусного будет в новой версии рельсов (кроме нового логотипа и дизайна их официального сайта, я имею в виду).
Изначально релиз Rails 5.0 был запланирован на весну 2015 года и много раз сдвигался, последний раз с 23 февраля на [16 марта 2016](http://weblog.rubyonrails.org/2016/2/27/Rails-5-0-beta3/). То есть, возможно, это не последний перенос сроков. Тем не менее, Rails 5.0 на сегодня имеет статус beta3 и работает на продакшене [Basecamp](http://basecamp.com/)
##### Сначала формальные изменения
* Поддерживается только ruby 2.2.2+
* Веб-сервер Webrick заменен на Puma на 16 потоков по умолчанию
* Все rake команды заменены на rails, например: `rails db:migrate`
##### И большие куски функционала
##### Turbolinks 5
Текущая версия turbolinks обновляет содержимое всей страницы через ajax без повторного обращения к статическим файлам css,js и т.д. Новая же версия позволяет выборочно изменять содержимое отдельных частей веб-страницы (через partials), причем делать это можно по инициативе сервера.
##### Action Cable
Наконец-то реализована поддержка Websockets, теперь можно делать полноценные single page application без танцев с бубном. Каналы, подписчики к ним на стороне клиента и так далее. Очень удобно.
Прекрасный видео [туториал](http://hectorperezarenas.com/2015/12/26/rails-5-tutorial-how-to-create-a-chat-with-action-cable/) об использовании Action Cable – веб чат на Rails без обновления страницы.
##### API режим
Теперь есть возможность сделать приложение без HTML и JS частей по умолчанию – существенно быстрее и легче.
`rails new backend --api`
Создается приложение, которое сразу cконфигурировано для работы с JSON, а не HTML
##### Sprockets 4
Добавлен файл app/assets/config/manifest.js для управления прекомпиляцией статических файлов.
`// JS and CSS bundles
//
//= link_directory ../javascripts .js
//= link_directory ../stylesheets .css
// Images and fonts so that views can link to them
//
//= link_tree ../fonts
//= link_tree ../images`
Еще обсуждается его конечно расположение и формат (js или yml), с финальным релизом будет понятно.
##### Немного сахара
Его на самом деле много, как много и мелких изменений, но мне приглянулись вот эти несколько:
* `params` в контроллере больше не хэш, а объект
* Теперь можно писать вот так: `User.where(users[:name].eq(‘bob’).or(users[:age].lt(25)))`
* Мелкие методы Integer#positive? и Integer#negative?
* объекты с отношением belongs\_to теперь по умолчанию должны иметь родителя, иначе будет exception
##### Результат
Обещают 20-30% прироста производительности. Как я понял, в основном, за счет массового использования замороженных строк (и массовой оптимизации кода, конечно же).
##### Установка последней beta
```
git clone --depth 1 http://github.com/rails/rails
cd rails
bundle
railties/exe/rails new --edge appname
cd appname
bundle
bundle exec rails s
```
##### Почитать
<http://blog.michelada.io/whats-new-in-rails-5>
<https://medium.com/evil-martians/the-rails-5-post-9c76dbac8fc#.9p0fpry5o>
[Самый новый видео подкаст об изменениях](http://alltutsfree.com/?s=rails) (с примерами) | https://habr.com/ru/post/278969/ | null | ru | null |
# Ожидаемое исключение JUnit 5
> Это продолжение туториала по JUnit 5. Введение опубликовано [здесь](https://habr.com/ru/post/590607/).
>
>
В JUnit 5, чтобы написать тестовый код, который, как ожидается, вызовет исключение, мы должны использовать [Assertions.assertThrows()](http://junit.org/junit5/docs/current/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function.Executable-).
В данном примере ожидается, что тестовый код в комментированном блоке вызовет исключение типа `ApplicationException`.
**Использование Assertions.assertThrows()**
```
@Test
void testExpectedException() {
ApplicationException thrown = Assertions.assertThrows(ApplicationException.class, () -> {
//Code under test
});
Assertions.assertEquals("some message", exception.getMessage());
}
```
**Оглавление**
1. Assertions API assertThrows ().
* Синтаксис
* Вывод теста
2. Ожидаемое исключение генерируется в тесте.
3. Сгенерировано исключение другого типа, или не сгенерировано исключение
### 1. Assertions API assertThrows ()
#### 1.1. Синтаксис
Метод `assertThrows()` утверждает, что выполнение прилагаемого исполняемого блока или [лямбда - выражения](https://howtodoinjava.com/java8/lambda-expressions/) вызывает исключение типа `expectedType`. Это перегруженный метод, который принимает следующие параметры.
```
static T assertThrows(Class expectedType, Executable executable)
static T assertThrows(Class expectedType, Executable executable, String message)
static T assertThrows(Class expectedType, Executable executable, Supplier messageSupplier)
```
* `expectedType`- ожидается, что тестовый код вызовет исключение этого типа.
* `message` - если исполняемый код не вызывает никаких исключений, это сообщение будет напечатано вместе с результатом FAIL.
* `messageSupplier` - сообщение будет извлечено из него в случае неудачи теста.
#### 1.2. Вывод теста
Если в блоке не было генерировано исключение, `executable`, то `assertThrows()` вернет `FAIL`.
Если выбрасывается исключение другого типа, `assertThrows()` будет `FAIL`.
Если блок кода вызывает исключение класса, который является подтипом исключения `expectedType`, только тогда `assertThrows()` вернет `PASS`.
Например, если мы ожидаем, `IllegalArgumentException` и тест выдает *ошибку* `NumberFormatException,` тогда и вывод теста будет `PASS`потому что *NumberFormatException расширяет* класс *IllegalArgumentException*.
Кроме того, если мы передадим `Exception.class` в качестве ожидаемого типа исключения, любое исключение, выброшенное из исполняемого блока, сделает результат assertion равным `PASS`, поскольку `Exception` является супертипом для всех исключений.
### 2. Ожидаемое исключение генерируемое в тесте
Ниже приведен очень простой тест, который ожидает, что исключение `NumberFormatException` будет сгенерировано при выполнении предоставленного блока кода.
Оба теста выдаютPASS
```
@Test
void testExpectedException() {
NumberFormatException thrown = Assertions.assertThrows(NumberFormatException.class, () -> {
Integer.parseInt("One");
}, "NumberFormatException was expected");
Assertions.assertEquals("For input string: \"One\"", thrown.getMessage());
}
@Test
void testExpectedExceptionWithParentType() {
Assertions.assertThrows(IllegalArgumentException.class, () -> {
Integer.parseInt("One");
});
}
```
* В тесте `testExpectedException`, исполняемый код `Integer.parseInt("One")` генерирует исключение `NumberFormatException,` если аргумент метода не является допустимым текстовым представлением числа. Метод `assertThrows()` ожидает это исключение, так что результат теста `PASS`.
* В тесте `testExpectedExceptionWithParentType`, мы выполняем тот же код, но на этот раз мы принимаем исключение `IllegalArgumentException`, родительское для `NumberFormatException`. Этот тест тоже проходит.
### 3. Сгенерировано исключение другого типа, или не сгенерировано исключение
Если исполняемый код вызывает исключение любого другого типа, то результат теста будет `FAIL`.
И даже если исполняемый код не вызывает никаких исключений**,** результат теста тоже будет `FAIL`.
Например, в приведенном ниже примере `"1"`это допустимое число, поэтому исключение не возникает. Этот тест завершится ошибкой с сообщением в консоли.
```
@Test
void testExpectedExceptionFail() {
NumberFormatException thrown = Assertions
.assertThrows(NumberFormatException.class, () -> {
Integer.parseInt("1");
}, "NumberFormatException error was expected");
Assertions.assertEquals("Some expected message", thrown.getMessage());
}
```
В этом посте мы узнали, как написать тест, ожидающий возникновение исключений. Эти тесты полезны при тестировании кода, написанного в блоках [catch](https://howtodoinjava.com/java/exception-handling/try-catch-finally/).
Хорошего изучения!!!
[Скачать исходный код](https://github.com/lokeshgupta1981/Junit5Examples/tree/master/JUnit5Examples) | https://habr.com/ru/post/591305/ | null | ru | null |
# Почему оптимизатор запросов не анализирует содержимое буферного пула
В SQL Server используется стоимостной оптимизатор запросов (cost-based optimizer), который ищет оптимальный план в течение времени, выделенного для компиляции запроса. При оптимизации плана учитывается информация о таблицах, участвующих в запросе, существующих индексах, а также статистика распределения данных. Поиск оптимального плана также включает в себя минимизацию количества физических чтений.
Иногда возникает вопрос, почему оптимизатор не учитывает содержимое буферного пула, ведь это, безусловно, может помочь ускорить выполнение запроса. В этой статье разберемся почему.
Чтение содержимого буферного пула
---------------------------------
Одна из причин, по которой оптимизатор игнорирует буферный пул, состоит в том, что его структура не позволяет простым способом выяснить его содержимое. Страницы файла данных в буферном пуле представлены небольшими структурами данных, называемых "буферами" (buffer), в которых хранится следующая информация (список неполный):
* идентификатор страницы Page ID (номер файла : номер страницы в файле);
* время последнего обращения к странице (используется lazy writer'ом для реализации алгоритма least-recently-used для вытеснения значений, которые дольше всего не запрашивались);
* расположение страницы в буферном пуле;
* признак того является страница грязной (dirty) или нет (грязная страница содержит изменения, которые еще не были записаны в долговременное хранилище);
* единица распределения (allocation unit), к которой принадлежит страница (подробнее [здесь](https://www.sqlskills.com/blogs/paul/inside-the-storage-engine-iam-pages-iam-chains-and-allocation-units/)). Идентификатор единицы распределения (allocation unit ID) можно использовать для определения к какой таблице и индексу относится страница.
Для каждой базы данных со страницами в буферном пуле, также есть хэш-список страниц, упорядоченных по идентификаторам (page ID), используя который можно быстро определить, находится страница в памяти или нет, то есть понять, потребуется ли выполнить физическое чтение. Однако не так просто выяснить, какой процент страниц листового уровня индекса находится в памяти. Придется сканировать весь буферный пул базы данных в поисках буферов нужной единицы распределения. И чем больше страниц в памяти, тем больше времени это займет. Что будет очень дорого в рамках компиляции запроса.
О том как получить информацию о буферном пуле с помощью DMV sys.dm\_os\_buffer\_descriptors можно посмотреть в [этом посте](https://www.sqlskills.com/blogs/paul/performance-issues-from-wasted-buffer-pool-memory/).
Почему использование содержимого буферного пула может быть опасным
------------------------------------------------------------------
Давайте представим, что все-таки существует эффективный механизм анализа содержимого буферного пула, которым может воспользоваться оптимизатор при выборе индекса. Проверим следующую гипотезу: если оптимизатор знает, что в памяти уже находится менее эффективный большой индекс, по сравнению с более эффективным меньшего размера, но находящимся на диске, то он должен выбрать индекс в памяти, потому что это уменьшит количество физических операций, и запрос будет выполняться быстрее.
Рассмотрим пример таблицы **BigTable** с двумя некластеризованными индексами **Index\_A** и **Index\_B**. Для запроса, рассматриваемого далее, оба индекса будут покрывающими, а для получения результатов потребуется полное сканирование листового уровня индекса. Вставим в таблицу один миллион строк, тогда в индексе **Index\_A** на листовом уровне будет 200 000 страниц, а в **Index\_B** — 1 000 000, поэтому для полного сканирования **Index\_B** потребуется обработать в пять раз больше страниц.
Эксперимент я проводил на ноутбуке с 8 ядрами, 32 ГБ памяти, SSD-дисками и SQL Server 2019.
```
CREATE TABLE BigTable (
c1 BIGINT IDENTITY,
c2 AS (c1 * 2),
c3 CHAR (1500) DEFAULT 'a',
c4 CHAR (5000) DEFAULT 'b'
);
GO
INSERT INTO BigTable DEFAULT VALUES;
GO 1000000
CREATE NONCLUSTERED INDEX Index_A ON BigTable (c2) INCLUDE (c3);
-- 5 записей на странице = 200 000 страниц
GO
CREATE NONCLUSTERED INDEX Index_B ON BigTable (c2) INCLUDE (c4);
-- 1 запись на страницу = 1 миллион страниц
GO
CHECKPOINT;
GO
```
Измерим длительность запросов:
```
DBCC DROPCLEANBUFFERS;
GO
-- Index_A не в памяти
SELECT SUM (c2) FROM BigTable WITH (INDEX (Index_A));
GO
-- CPU time = 796 ms, elapsed time = 764 ms
-- Index_A в памяти
SELECT SUM (c2) FROM BigTable WITH (INDEX (Index_A));
GO
-- CPU time = 312 ms, elapsed time = 52 ms
DBCC DROPCLEANBUFFERS;
GO
-- Index_B не в памяти
SELECT SUM (c2) FROM BigTable WITH (INDEX (Index_B));
GO
-- CPU time = 2952 ms, elapsed time = 2761 ms
-- Index_B в памяти
SELECT SUM (c2) FROM BigTable WITH (INDEX (Index_B));
GO
-- CPU time = 1219 ms, elapsed time = 149 ms
```
Когда в памяти нет ни одного индекса, то **Index\_A** более эффективен — время выполнения запроса 764 мс против 2761 мс при использовании **Index\_B**, и то же самое происходит, если оба индекса находятся в памяти. Однако если **Index\_B** находится в памяти, а **Index\_A** — нет, то при использовании **Index\_B** запрос будет выполняться быстрее (149 мс), чем при **Index\_A** (764 мс).
Теперь давайте позволим оптимизатору сделать выбор на основе содержимого памяти…
Если **Index\_A** отсутствует в памяти, а **Index\_B** присутствует, то эффективнее было бы использовать **Index\_B**. Несмотря на то что размер индекса **Index\_B** больше и потребуется больше циклов процессора для обработки запроса, но физических операций чтения будет меньше, а они намного медленнее, чем дополнительные циклы процессора. Более эффективный план запроса содержит меньшее количество физических чтений.
План "использовать **Index\_B**" лучше плана "использовать **Index\_A**", только если **Index\_B** находится в памяти, а **Index\_A** нет. Как только большая часть **Index\_A** окажется в памяти, план "использовать **Index\_A**" будет эффективнее плана "использовать **Index\_B**".
Если мы скомпилируем и закэшируем план "использовать **Index\_B**", то получится следующая картина:
* Если оба индекса, и **Index\_A** и **Index\_B** находятся в памяти, то скомпилированный план займет почти в три раза больше времени.
* Если индексов нет в памяти — скомпилированный план выполняется в 3,5 раза дольше.
* Если **Index\_A** находится в памяти, а **Index\_B** — нет, то для получения данных необходимо выполнить физические чтения с диска, и запрос будет выполняться в 53 раза дольше.
### Резюме
Хотя в нашем мысленном эксперименте оптимизатор может использовать информацию о буферном пуле для поиска наиболее эффективного плана запроса, но это может быть опасным при использовании скомпилированного плана из-за постоянного изменения буферного пула, и это может влиять на эффективность кэшированного плана.
Помните, что задача оптимизатора быстро найти хороший план, но он не обязательно будет единственно лучшим для 100% случаев. На мой взгляд, оптимизатор SQL Server поступает правильно, игнорируя фактическое содержимое буферного пула и полагаясь на различные правила вычисления стоимости без попыток создать самый лучший план для всех ситуаций.
*Данный материал подготовили для будущих студентов курса "MS SQL Server Developer". Скоро пройдет* [***открытый урок***](https://otus.pw/HEQS6/) *этого курса на тему* ***«Основы анализа производительности и оптимизации запросов в MS SQL Server»****, на который приглашаем всех желающих. На занятии рассмотрим основы анализа производительности и оптимизации запросов в MS SQL Server.* | https://habr.com/ru/post/649573/ | null | ru | null |
# Документация к cms Fine Cut Engine
Всем доброй пятницы!
[](http://finecut.info)
Может быть кому-нибудь пригодится: [Fine Cut Engine](http://finecut.info)?
Это админка для сайта-визитки.
В настоящий момент документация Fine Cut Engine есть только на английском, топик предназначен для исправления этого недочета. **Upd**: для удобства ссылка на [downloads](http://finecut.info/download/).
Заявленные Фичи:
— Keep it Simple: настолько, насколько было возможно
— **Без базы данных o\_0**
— Free from Fat: практически отсутствует back-end
— Free to Use: [MIT](http://en.wikipedia.org/wiki/MIT_License) или [GPL](http://en.wikipedia.org/wiki/GNU_General_Public_License)
— Хорошо интегрируется: можно включить всё что угодно в шаблон
— Без попкорна: это не кино
— Там нет ложки: мы помним [The Matrix](http://en.wikipedia.org/wiki/The_Matrix) :)
**UPD 1**: элементарная файловая «CMS» с одно-страничным web 2.0 UI, ни малейшего намёка на излишества, и силу этой же специфики — весьма шустро отдающая запросы (как, впрочем, и множество подобных), спасибо [heathen](https://habrahabr.ru/users/heathen/) за [комментарий](http://habrahabr.ru/post/150582/#comment_5100465). В работе с подобными движками лично меня постоянно не устраивала необходимость переходов по ссылкам при создании содержимого, а так же не хватало дерева в котором будет виден URL редактируемой страницы и структура сайта в целом.
**UPD 2**: в [самой глубине](http://finecut.info/documentation/resources/) документации есть ссылка на [Google Grops](https://groups.google.com/forum/#!forum/finecutcms).
**UPD 3**: [сайт](http://finecut.info) проекта это его же дефолтный шаблон ([Twitter Bootstrap](http://twitter.github.com/bootstrap/)) с дефолтным же содержимым.
В админке используется [jQuery](http://jquery.com/) с разными компонентами, а так же [elFinder](http://elfinder.org/) и [ACE Editor](http://ace.ajax.org/) (тот самый что и в [Cloud9 IDE](https://c9.io/)), [knokout.js](http://knockoutjs.com/), замечательный [плагин для JSON](http://www.daviddurman.com/flexi-json-editor/jsoneditor.html) (перечень «всего» [тут](http://finecut.info/about/screenshots/) ).
#### Требования
Fine Cut был разработан с использованием:
PHP 5.3.6.
Apache HTTP Server 2.x version.
Скорее всего возможно использовать и другой web-сервер, просто посмотрите на «.htaccess» корневой директории для того, чтобы сделать такие же настройки.
Если использовать Apache, то нужно помнить что:
«**rewrite\_module**»: **строгая зависимость**
«deflate\_module»: будет работать но без gzip
«env\_module»: будет работать, смотрите «.htaccess»
«expires\_module»: будет работать, смотрите «.htaccess»
«filter\_module»: будет работать, смотрите «.htaccess»
«headers\_module»: будет работать, смотрите «.htaccess»
«mime\_module»: будет работать, смотрите «.htaccess»
«setenvif\_module»: будет работать, смотрите «.htaccess»
**Да, нам не нужна база данных, чтобы работать с Fine Cut.**
Для использования админки Fine Cut «\_adm» будет необходим современный browser, например:
**Internet Explorer 9+**
Firefox 3.6+
Google Chrome
Opera 12 (or, may be older, we didn't make tests)
Safari 5
В общем требование можно сократить до: последний WebKit или Gecko движок.
#### Установка
Fine Cut распространяется как архив. И нет никакого установочного скрипта, потому, что сделано просто.
Распаковать архив в любую директорию web-сайта, доступную для просмотра, это всё что нужно.
По шагам:
1. Загрузите последнюю версию Fine Cut: [ZIP](https://github.com/wentout/Fine-Cut-Engine/zipball/master) или [TAR.BZ](https://github.com/wentout/Fine-Cut-Engine/tarball/master)
2. Решите, в какую папку будете устанавливать.
3. Распакуйте архив в эту папку. **При этом пожалуйста помните, что внутри скачанного архива Fine Cut расположен не в корневом каталоге: один каталог вглубь для ZIP, и два каталога для TAR.BZ. Необходимо будет скопировать файлы в выбранную папку после распаковки.**
4. Перейдите к этой директории в браузере, вы должны увидеть сайт, если этого не произошло, значит что-то пошло не так, скорее всего не установлен **mod\_rewrite**.
5. Перейдите в " \_adm ", это админка.
##### Настройка
Обычно после установки всё сразу нормально.
Но, вам, всё же, может потребоваться некоторая настройка Fine Cut Engine.
Поэтому, вот перечень свойств, которые могут быть сконфигурированы непосредственно:
* Путь к папке, в которой будет располагаться содержимое — content.
* Использовать ли файловый cache, по умолчанию " использовать ".
* Путь к папке где будет располагаться cache.
* Права на доступ к файлам и папкам.
* Кодировка имен файлов на сервере, по умолчанию " UTF-8 ".
* Выводить ли время обработки запроса в комментарии к странице, по умолчанию " выводить ".
Эти настройки можно поправить в админке на вкладке " Settings ".
Там так же находятся кнопки сохранения настроек, очистки кеша и пара чекбоксов для настройки админки.
##### Подпапки
Если вы собираетесь работать с Fine Cut в относительной директории, а не в " document root " вам будет необходимо всегда помнить, что вы «не в корне сайта».
По умолчанию всё в Fine Cut независимо, компоненты и дефолтные шаблоны сделаны без привязки к пути файловой системы.
Советы:
Не используйте прямые ссылки ( http:// ) между страничками. Используйте относительные. Относительные это то, что вы видите на вкладке «Pages Manager» в " Дереве " (расположено слева).
Там есть кнопка " Copy this Leaf Path ", используйте её, чтобы быть уверенными, что ссылка сделана правильно.
Да, админок одновременно можно открыть сколько угодно.
Все это же справедливо не только для ссылок, но и для картинок и прочих ресурсов внутри директории Fine Cut.
Если всё же необходимо детальное описание: мы используем простейший pre-processor основанный на regular expressions для того, чтобы переименовать каждую ссылку внутри содержимого страницы или в дополнительной части .
Пре-процессоры это два компонента с именами " content\_parser " и " head\_additional ". Эти компоненты просто изменяют все, что начинается с
`http="/ or src="/`
Добавляя к ним путь относительный от корневой директории до директории установки. Поэтому, когда ваша ссылка находится внутри Fine Cut, просто будьте уверены, что она относительна директории установки.
Да, создавая свой шаблон, пожалуйста используйте эти компоненты для совместимости.
##### Пароль
По умолчанию админка не защищена…
И нет никакого " управления пользователями", потому, что мы подозреваем, что в большинстве случаев Fine Cut будет использоваться «персонажем», создающим маленький сайт.
Поэтому мы предпочти использовать Apache Authentification для защиты админики.
Вы можете убедиться, что последние четыре строчки " \_adm/.htacces " закомментированы:
`#AuthType basic`
`#AuthName "auth requred"`
`#AuthUserFile /home/www/your_site_directory/.htpasswd`
`#Require valid-user`
Вам нужно создать свой " .htpasswd ".
Гуглите…
#### Странички
Все, что представлено в дереве редактора **[Pages Manager][Pages Editor]**, это " URL ".
Например "**about**" это:
`YourWebSite.url/YourFineCutDir about`
А **forkus** и **screenshots** это:
`YourWebSite.url/YourFineCutDir about / forkus`
`YourWebSite.url/YourFineCutDir about / screenshots`
Последнее, но **очень важное дополнение о структуре URL'ов**, это то, что страница с именем " **\_index** ", расположенная на первом уровне дерева, является «корневой» для всего сайта.
Сам редактор, это непревзойденный [ACE Editor](http://ace.ajax.org/).
Hotkeys preset:
* Ctrl + 1, Ctrl + 2… Ctrl + 6: заголовки , …
===
* Ctrl + P: новый абзац
* Ctrl + B, Ctrl + I: ****bold** and **italic****
* Ctrl + L: новая [ссылка](/)
Мы используем эту вкладку для задания необходимых свойств.
Свойства это иерархическая структура, которая может быть использована, например, для описания характеристик чего-нибудь на странице, геренации меню и т.п…
При работе с ними помните, там немного странное поведение, после редактирования свойства не сохраняйте страницу сразу, для начала кликните где-нибудь на пустом месте, чтобы изменения попали в модель свойств.
##### Header
Всё как обычно.
Только две вещи, о которых необходимо сказать: " that checkbox " и " Head Additional " textarea.
— **checkbox** означает, должна ли страничка всё время создаваться, или можно её положить в файловый cache. Поэтому если на странице нужно динамическое содержимое, включающее [Ваш любимый PHP Engine], используйте его.
— **Head Additional** необходим для подключения дополнительных компонент страницы, CSS или JavaScript в ситуации когда нет необходимости вставлять это в основной шаблон.
Например, есть шаблон с кучей подключенных библиотек.
Возникает ситуация, когда нужно подключить ещё парочку, но только для конкретной страницы. Вот для этого оно и используется. Например, мы так подключаем LightBox CSS и JS для страницы [screenshots](http://finecut.info/about/screenshots/).
Да, конечно, можно создать ещё один шаблон. Но зачем? Вам будет всегда необходимо помнить, что есть ещё один шаблон, который почти такой же как оригинал, и в случае необходимости правки нужно будет править оба.
#### Файловый Менеджер
Их существует много, но мы любим [этот](http://elfinder.org/).
**Огромное спасибо команде [ElFinder](http://elfinder.org/)**.
Но, тем не менее, мы сделали некоторые правки.
Во-первых мы используем версию 1.3, она проще интегрируется с нашим CSS.
Во-вторых в его редакторе доступен Ctrl + S.
И, самое главное, мы постарались сделать совместимость с [Twitter Bootstrap](http://twitter.github.com/bootstrap/).
#### Шаблоны
Мы используем папку
`/templates/`
для хранения шаблонов.
Не храните другие файлы в этой папке, потому, что каждый шаблон, исключая шаблон «по умолчанию» может быть удален. Хотя, вы можете «выстрелить себе в ногу» удалив даже его из File Manager.
Каждая папка непосредственно внутри папки шаблонов является «именем» шаблона.
**Меняя шаблон**: просто измените код и нажмите " Save ".
**Добавление шаблона**: немножко сложнее, потому, что когда вы нажимаете " Add " оно просто делает копию выбранного, но мы считаем, что это очень удобно, не нужно заново создавать разметку и вписывать необязательные вещи.
**Удаление шаблона**: тоже просто, оно просто стирает его папку. Но, мы надеемся, что понятно: если на страничке была зависимость от шаблона, то его удаление обрушит «движок» при её генерации.
Каждый шаблон содержит: свой код и сниппеты свойств и header страницы.
Во время создания страницы каждый шаблон получает переменную **$success** от движка.
В ней вы найдёте:
+ **$success [ ' header ' ]** — массив:
'title', 'description', 'keywords', 'template', 'pageIsCode' и 'header addition'.
+ **$success [ ' info ' ]** — JSON свойств.
для которого мы обычно используем
`php include( $success["components"]["json_info"] ); ?`
для перевода из строки в свойство.
+ **$success [ ' content ' ]** — путь к файлу содержимого.
И тут мы используем
`php include( $success["components"]["content_parser"] ); ?`
для вставки его в страницу.
+ **$success [ ' deep ' ]** — путь относительно Document Root до папки установки Fine Cut.
+ **$success [ ' path ' ]** — путь к папке хранения страницы.
+ **$success [ ' pagesPath ' ]** — путь к папке хранения страниц (общей).
+ **$success [ ' pagesName ' ]** — имя папки хранения страниц.
+ **$success [ ' isMain ' ]** — признак, главная страница или нет.
+ **$success [ ' components ' ]** — массив ссылок на доступные компоненты.
+ **$success [ ' fileNameEncoding ' ]** — кодировка файловой системы.
Да, по умолчанию, админка находится:
`http:// YourHost / YourInstallDir / _adm`
Но это можно изменить.
Во-первых переименуйте "\_adm" в файле
`_engine \ index.php`
на строке 3.
Затем переименуйте саму папку "\_adm".
Это может быть сделано непосредственно изнутри админки, если вы так и поступили, то незамедлительно перезагрузите админку, потому, что скрипты админки «смотрят» сейчас на другую папку.
Источник: <http://finecut.info/documentation/>
Ссылка для загрузки: [downloads](http://finecut.info/download/). | https://habr.com/ru/post/150582/ | null | ru | null |
# Вышел минималистичный Linux-дистрибутив Bottlerocket для запуска контейнеров. Самое главное о нём
Компания Amazon [объявила](https://aws.amazon.com/blogs/opensource/announcing-the-general-availability-of-bottlerocket-an-open-source-linux-distribution-purpose-built-to-run-containers/) о финальном релизе [Bottlerocket](https://github.com/bottlerocket-os/bottlerocket) — специализированного дистрибутива для запуска контейнеров и эффективного управления ими.
Bottlerocket (кстати, так называют мелкие самодельные ракеты на дымном порохе) — не первая ОС для контейнеров, но вполне вероятно, что она получит широкое распространение благодаря дефолтной интеграции с сервисами AWS. Хотя система ориентирована на облако Amazon, открытый исходный код позволяет собрать её где угодно: локально на сервере, на Raspberry Pi, в любом конкурирующем облаке и даже в среде без контейнеров.
Это вполне достойная замена дистрибутиву CoreOS, который похоронила Red Hat.
Вообще, у подразделения Amazon Web Services уже есть Amazon Linux, который недавно вышел во второй версии: это дистрибутив общего назначения, который можно запустить в контейнере Docker или с гипервизорами Linux KVM, Microsoft Hyper-V и VMware ESXi. Он был оптимизирован для работы в облаке AWS, но с выходом Bottlerocket всем рекомендуется сделать апгрейд на новую систему, которая более безопасная, современная и потребляет меньше ресурсов.
AWS анонсировала Bottlerocket [в марте 2020 года](https://aws.amazon.com/blogs/containers/bottlerocket-a-special-purpose-container-operating-system/). Она сразу признала, что это не первый «Linux для контейнеров», упомянув в качестве источников вдохновения CoreOS, Rancher OS и Project Atomic. Разработчики написали, что операционная система является «результатом уроков, которые мы извлекли за долгое время работы производственных служб в масштабе Amazon, и с учётом опыта, который мы получили за последние шесть лет о том, как запускать контейнеры».
Экстремальный минимализм
========================
Linux очищен от всего, что не нужно для запуска контейнеров. Такой дизайн, по словам компании, сокращает поверхность атаки.
Это означает, что в базовой системе устанавливается меньше пакетов, что упрощает поддержку и обновление ОС, а также снижает вероятность возникновения проблем из-за зависимостей, снижает использование ресурсов. В принципе, здесь всё работает внутри отдельных контейнеров, а базовая система практически голая.
Amazon также удалила все оболочки и интерпретаторы, исключив риск их использования или случайного повышения привилегий пользователями. В базовом образе ради минимализма и безопасности отсутствует командная оболочка, сервер SSH и интерпретируемые языки типа Python. Инструменты для администратора вынесены в отдельный служебный контейнер, который отключён по умолчанию.
Управление системой предусмотрено двумя способами: через API и оркестровку.
Вместо менеджера пакетов, который обновляет отдельные части программного обеспечения, Bottlerocket загружает полный образ файловой системы и перезагружается в него. В случае сбоя загрузки он автоматически откатывается, а сбой рабочей нагрузки может инициировать откат вручную (команда через API).
Фреймворк [TUF](https://github.com/theupdateframework/specification/) (The Update Framework) загружает обновления на основе образов в альтернативные или «размонтированные» разделы. Под систему выделяется два дисковых раздела, один из которых содержит активную систему, а на второй копируется обновление. При этом корневой раздел монтируется в режиме только для чтения, а раздел `/etc` монтируется с файловой системой в оперативной памяти [tmpfs](https://www.kernel.org/doc/Documentation/filesystems/tmpfs.txt) и восстанавливает исходное состояние после перезапуска. Прямое изменение конфигурационных файлов в `/etc` не поддерживается: для сохранения настроек следует использовать API или выносить функциональность в отдельные контейнеры.
*Схема обновления через API*
Безопасность
============
Контейнеры создаются штатными механизмами ядра Linux — cgroups, пространства имён и seccomp, а в качестве системы принудительного контроля доступа, то есть для дополнительной изоляции используется [SELinux](https://github.com/SELinuxProject) в режиме "enforcing".
По умолчанию включены политики для разделения ресурсов между контейнерами и ядром. Бинарники защищены флагами, чтобы пользователи или программы не могли их выполнять. И если кто-то добрался до файловой системы, Bottlerocket предлагает инструмент для проверки и отслеживания любых внесённых изменений.
Режим «проверенной загрузки» реализован через функцию device-mapper-verity ([dm-verity](https://www.kernel.org/doc/html/latest/admin-guide/device-mapper/verity.html)), которая проверяет целостность корневого раздела во время загрузки. AWS описывает dm-verity как «функцию ядра Linux, обеспечивающую проверку целостности, чтобы предотвратить работу зловредов в ОС, таких как перезапись основного системного программного обеспечения».
Также в системе присутствует фильтр [eBPF](https://lwn.net/Articles/740157/) (extended BPF, [разработка Алексея Старовойтова](https://lwn.net/Articles/598545/)), который позволяет заменять модули ядра более безопасными программами BPF для низкоуровневых системных операций.
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| | Модель выполнения | Задаётся пользователем | Компиляция | Безопасность | Режим сбоя | Доступ к ресурсам |
| **Юзер** | задача | да | любая | права пользователей | прерывание выполнения | системный вызов, fault |
| **Ядро** | задача | нет | статическая | нет | паника ядра | прямой |
| **BPF** | событие | да | JIT, CO-RE | верификация, JIT | сообщение об ошибке | ограниченные хелперы |
*Отличие BPF от обычного кода уровня пользователя или ядра, [источник](https://d1.awsstatic.com/events/reinvent/2019/REPEAT_1_BPF_performance_analysis_at_Netflix_OPN303-R1.pdf)*
AWS заявила, что Bottlerocket «применяет операционную модель, которая ещё больше повышает безопасность, препятствуя подключению к продакшн-серверам с привилегиями администратора», и «подходит для больших распределённых систем, в которых ограничен контроль над каждым отдельным хостом».
Для системных администраторов предусмотрен контейнер администратора. Но AWS не думает, что админу часто придется работать внутри Bottlerocket: «Акт входа в отдельный инстанс Bottlerocket предназначен для нечастых операций: расширенной отладки и устранения неполадок», — [пишут](https://aws.amazon.com/blogs/opensource/announcing-the-general-availability-of-bottlerocket-an-open-source-linux-distribution-purpose-built-to-run-containers/) разработчики.
Язык Rust
=========
Инструментарий ОС поверх ядра в основном написан на Rust. Этот язык по своей природе [уменьшает вероятность небезопасного доступа к памяти](https://habr.com/ru/post/438288/), а также [устраняет условия гонки между потоками](https://habr.com/ru/post/441370/).
При сборке по умолчанию применяются флаги `--enable-default-pie` и `--enable-default-ssp` для включения рандомизации адресного пространства исполняемых файлов ([position-independent executable](https://en.wikipedia.org/wiki/Position-independent_code), PIE) и защиты от переполнения стека.
Для пакетов на C/C++ дополнительно включаются флаги `-Wall`, `-Werror=format-security`, `-Wp,-D_FORTIFY_SOURCE=2`, `-Wp,-D_GLIBCXX_ASSERTIONS` и `-fstack-clash-protection`.
Кроме Rust и C/C++, некоторые пакеты написаны на языке Go.
Интеграция с сервисами AWS
==========================
Отличие от аналогичных контейнерных операционных систем заключается в том, что Amazon оптимизировала Bottlerocket для работы на AWS и интеграции с другими сервисами AWS.
Самым популярным оркестратором контейнеров является Kubernetes, поэтому AWS внедрила интеграцию с собственным Enterprise Kubernetes Service (EKS). Инструменты для оркестровки идут в отдельном управляющем контейнере [bottlerocket-control-container](https://github.com/bottlerocket-os/bottlerocket-control-container), который включён по умолчанию и управляется через API и AWS SSM Agent.
Будет интересно посмотреть, взлетит ли Bottlerocket, учитывая провал некоторых подобных инициатив в прошлом. Например, PhotonOS от Vmware оказалась невостребованной, а RedHat купила CoreOS и [закрыла проект](https://coreos.com/os/eol/), который считался пионером в данной области.
Интеграция Bottlerocket в сервисы AWS делает эту систему в своём роде уникальной. Возможно, это главная причина, почему некоторые пользователи могут предпочесть Bottlerocket другим дистрибутивам, таким как CoreOS или Alpine. Система изначально спроектирована для работы с EKS и ECS, но повторим, что это не обязательно. Во-первых, Bottlerocket можно [собрать самостоятельно](https://github.com/bottlerocket-os/bottlerocket/blob/develop/BUILDING.md) и использовать, например, как hosted-решение. Во-вторых, пользователи EKS и ECS по-прежнему сохранят возможность выбора ОС.
Исходный код Bottlerocket опубликован на GitHub под лицензией Apache 2.0. Разработчики уже [реагируют на баг-репорты и запросы фич](https://github.com/orgs/bottlerocket-os/projects/1).
---
#### На правах рекламы
**VDSina** предлагает [VDS с посуточной оплатой](https://vdsina.ru/cloud-servers?partner=habr96). Возможно установить любую операционную систему, в том числе из своего образа. Каждый сервер подключён к интернет-каналу в 500 Мегабит и бесплатно защищён от DDoS-атак!
[](https://vdsina.ru/cloud-servers?partner=habr96) | https://habr.com/ru/post/518290/ | null | ru | null |
# Julia и клеточные автоматы
Сегодня мы отправимся в красочное путешествие по миру клеточных автоматов, попутно изучая некоторые хитрые приемы их реализации, а также попытаемся понять, что скрывается за этой красотой — любопытная игра для праздного ума или глубокая философская концепция, находящая отклики во многих моделях.
Для практики и лучшего понимания следует попытаться самому реализовать приведенные ниже алгоритмы. Ну а если лень, или просто из интереса, можно поиграться с различными имплементациями:
* [Golly](http://golly.sourceforge.net) — небольшая программка использующая оптимальнейшие методы для моделирования клеточных автоматов с различными правилами и сетками. В комплекте есть база шаблонов и предустановок.
* [Lenia](https://github.com/Chakazul/Lenia) — набор инструментов для изучения непрерывного варианта "жизни".
* [Онлайн симулятор](http://lpcs.math.msu.su/~zolin/ant/) для муравья Лэнгтона. Особо примечательна возможность выбора триангулярной сетки, в которой стандартные правила ведут себя как генератор пиксельных космических кораблей
Одномерный случай
-----------------
Одномерный клеточный автомат представляет с собой отрезок разбитый на равные части — ячейки. Каждая ячейка может принимать одно из двух состояний, условно 0 или 1, черный или белый, живой или мертвый и т. д. Состояние каждой ячейки меняется по определенному правилу, учитывающему состояние соседей. Если принимать во внимание только ближайших соседей, то мы получим комбинацию из восьми состояний искомой ячейки и пары соседей. Каждой из этих комбинаций можно поставить в соответствие одно новое состояние для искомой ячейки, из чего следует общее количество правил равное 256 (количество 8-битных слов).
Чтобы надежно закрепить образ в своей нейросети, реализуем функцию визуализирующую одномерные клеточные автоматы.
Для начала следует установить и подгрузить все необходимые пакеты:
**Код**
```
using Pkg
pkgs = ["Images", "ColorSchemes", "FFTW"]
for p in pkgs
Pkg.add(p)
end
using Images, ColorSchemes, FFTW, LinearAlgebra: kron
using Random: bitrand
cd("C:\\Users\\User\\Desktop\\Mycop")
```
Правила для одномерных клеточных автоматов выражают числами от 0 до 255 (десятичные представления восьмибитных слов). Значит наша функция должна уметь представлять номер правила в двоичном виде, и составлять для него паттерн. Затем, при наивной реализации, происходит проход по всем ячейкам с заменой состояний:
**Код**
```
# размеры, правило, множитель для масштаба картинки
function cellauto( n::Int64, m::Int64, rule::Int64, s::Int64 = 1 )
ptrn = digits(Bool, rule, base = 2, pad = 8)
bt = [ bitstring(i)[end-2:end] for i = 0:7 ]
d = Dict( bt[i] => ptrn[i] for i = 1:8 ) # словарь
M = falses(n,m)
M[1,m ÷ 2] = true
#M[1,:] .= bitrand(m)
for i = 1:n-1, j = 2:m-1
key = "$(M[i, j-1]*1)$(M[i, j]*1)$(M[i, j+1]*1)"
M[i+1,j] = d[key]
end
kron(M, ones(Int,s,s) ) # произведение Кронекера
end
M0 = cellauto(100, 200, 30, 4)
Gray.( M0 )
```
Это правило 30, одно из любимых Стивена Вольфрама. Он, кстати, назначил денежные призы за [решения задач](https://habr.com/ru/company/wolfram/blog/470425/) связанных с этим правилом. Действительно, в этом что-то есть: периодичность граничащая с хаосом, плюс спонтанное зарождение упорядоченных структур… Но лично меня зацепили треугольники Серпинского, которые часто встречаются [здесь и там](https://habr.com/ru/post/471908/#comment_20786518). А для одномерных КА они довольно частое явление:
```
Arr = cellauto.(40, 40, [0:23;], 2);
Imgs = [ Gray.(a) for a in Arr ]
reshape(Imgs, 4,6)
```
### В кругах и в цвете
Приверженцам объектно ориентированного программирования можно предложить [вариант](https://github.com/YermolenkoIgor/Julia_tutorial_rus/blob/master/Toyz/automata.ipynb), где клеточный автомат выполнен в виде структуры. В этом случае будет удобно реализовать варьирование цвета и даже круглые поля:
Визуализация выполнена с помощью пакета Luxor, который мы [разбирали ранее](https://habr.com/ru/post/459842/).
Игра в жизнь
------------
"Жизнь" Конвея — самый популярный из двумерных (да и трехмерных) клеточных автоматов. Эта модель отдаленно напоминает копошение бактерий в чашке Петри, и обладая Тьюринг полнотой, может послужить основой для чего угодно: [моделирования мышления](https://habr.com/ru/post/308370/), компьютеров ([архитектуры тетриса](https://habr.com/ru/post/338584/)) и [самой себя](https://www.youtube.com/watch?time_continue=3&v=xP5-iIeKXE8&feature=emb_logo).
*[играбельно](https://copy.sh/life/?gist=f3413564b1fa9c69f2bad4b0400b8090&step=512)*
Множество энтузиастов находят [все новые структуры](https://www.youtube.com/watch?feature=player_detailpage&v=C2vgICfQawE): осцилляторы, глайдеры, корабли ([на гусеничном ходу!](https://www.conwaylife.com/wiki/Caterpillar)) и фабрики. То есть, вся прелесть здесь заключается в том, что на основе простых правил можно создавать сложные структуры, откуда возникает соблазн попытаться распространить данную модель на фундаментальные законы Естества. В частности С. Вольфрам балует нас [подобными высказываниями](https://habr.com/ru/company/wolfram/blog/303836/). Вопрос, на сколько это правдоподобно и, главное, полезно, всегда вызывает споры, так что, не будем на нем заостряться. Лучше реализуем "Жизнь" использующую преобразования Фурье.
### Жизнь без Фурье и не жизнь вовсе
Тем, кто занимался [обработкой изображений](https://habr.com/ru/company/yandex/blog/254249/), работа с [БПФ](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5) в таком аспекте должна быть знакома. Остальным можно посоветовать попробовать заняться обработкой изображений, так как это очень интересно, и снабдит вас полезными абстракциями для понимания линейной алгебры.
За основу использовался алгоритм из [хабровской статьи](https://habr.com/ru/post/180135/)
**Код**
```
function makefilter(N::Int64)
filter = zeros(Complex, N, N);
IDX(x, y) = ( (x + N) % N ) + ( (y+N) % N ) * N + 1
filter[IDX(-1, -1)] = 1. ;
filter[IDX( 0, -1)] = 1. ;
filter[IDX( 1, -1)] = 1. ;
filter[IDX(-1, 0)] = 1. ;
filter[IDX( 1, 0)] = 1. ;
filter[IDX(-1, 1)] = 1. ;
filter[IDX( 0, 1)] = 1. ;
filter[IDX( 1, 1)] = 1. ;
return fft( real.(filter) )
end
function fftlife(N = 16, steps = 100, dx = 0, glider = true)
if glider
state = falses(N, N)
state[4,5] = state[5,6] = state[6,6] = true
state[6,5] = state[6,4] = true
else
state = bitrand(N, N)
end
filter = makefilter(N)
for i in 1:steps
tmp = fft( real.(state) ) # forward
tmp .*= filter
summ = ifft(tmp) # reverse
for i in eachindex(state)
t = round( Int, real(summ[i]) ) >> dx
state[i] = ( state[i] ? t == 2 || t == 3 : t == 3 )
end
save("KonLife_$(N)x$(N)_$i.png", kron( Gray.(state), ones(8,8) ) )
end
end
fftlife(16, 60)
```
Приятные бонусы этого подхода — это сравнительно быстрая отработка БПФ в силу его отполированности, и закольцованность граничных условий (действо происходит как бы на поверхности тора). Собственно, теперь можно обобщить "жизнь" непрерывным случаем.
### Гладкая жизнь
* [Репозиторий проекта](https://github.com/duckythescientist/SmoothLife)
* [Доступное объяснение](https://0fps.net/2012/11/19/conways-game-of-life-for-curved-surfaces-part-1/)
* [Дисер с доскональными исследованиями](https://www.csun.edu/~kme52026/thesis.html)
Вот так в общем виде выглядит модель:
Состояние теперь описывается не 1 и 0, а сигмоидой, соседи учитываются в некотором радиусе, а еще понадобится решать дифуры.
**Код****Начальные условия**
```
function clamp(x)
y = copy(x)
y[x.>1] .= 1
y[x.<0] .= 0
y
end
function func_linear(X, a, b)
Y = [ (x-a + 0.5b)/b for x in X ]
Y[X.a+0.5b] .= 1
return Y
end
function splat!(aa, ny, nx, ra)
x = round(Int, rand()\*nx ) + 1
y = round(Int, rand()\*ny ) + 1
c = rand() > 0.5
for dx = -ra:ra, dy = -ra:ra
ix = x+dx
iy = y+dy
if ix>=1 && ix<=nx && iy>=1 && iy<=ny
aa[iy,ix] = c
end
end
end
function initaa(ny, nx, ra)
aa = zeros(ny, nx)
for t in 0:((nx/ra)\*(ny/ra))
splat!(aa, ny, nx, ra);
end
aa
end
```
**Сигмоиды**
```
func_smooth(x::Float64, a, b) = 1 / ( 1 + exp(-4(x-a)/b) )
sigmoid_a(x, a, ea) = func_smooth(x, a, ea)
sigmoid_b(x, b, eb) = 1 - sigmoid_a(x, b, eb)
sigmoid_ab(x, a, b, ea, eb) = sigmoid_a(x, a, ea) * sigmoid_b(x, b, eb)
sigmoid_mix(x, y, m, em) = x - x * func_smooth(m, 0.5, em) + y * func_smooth(m, 0.5, em)
function snm(N, M, en, em, b1, b2, d1, d2)
[ sigmoid_mix( sigmoid_ab(N[i,j], b1, b2, en, en),
sigmoid_ab(N[i,j], d1, d2, en, en), M[i,j], em )
for i = 1:size(N, 1), j = 1:size(N, 2) ]
end
```
**Главная функция**
```
function smoothlife(NX = 128, NY = 128, tfin = 10, scheme = 1)
function derivative(aa)
aaf = fft(aa)
nf = aaf .* krf
mf = aaf .* kdf
n = real.(ifft(nf)) / kflr # irfft
m = real.(ifft(mf)) / kfld
2snm(n, m, alphan, alpham, b1, b2, d1, d2) .- 1
end
ra = 10
ri = ra/3
b = 1
b1 = 0.257
b2 = 0.336
d1 = 0.365
d2 = 0.551
alphan = 0.028
alpham = 0.147
kd = zeros(NY,NX)
kr = zeros(NY,NX)
aa = zeros(NY,NX)
x = [ j - 1 - NX/2 for i=1:NY, j=1:NX ]
y = [ i - 1 - NY/2 for i=1:NY, j=1:NX ]
r = sqrt.(x.^2 + y.^2)
kd = 1 .- func_linear(r, ri, b) # ones(NY, NX)
kr = func_linear(r, ri, b) .* ( 1 .- func_linear(r, ra, b) )
#aa = snm (ix/NX, iy/NY, alphan, alpham, b1, b2, d1, d2);
kflr = sum(kr)
kfld = sum(kd)
krf = fft(fftshift(kr))
kdf = fft(fftshift(kd))
#for td in 2 .^(10:-1:3)
for td = 64
aa = initaa(NY,NX,ra)
dt = 1/td;
l = 0
nx = 0
for t = 0:dt:tfin
# 1=euler 2=improved euler 3=adams bashforth 3 4=runge kutta 4
if scheme==1
aa += dt*derivative(aa)
elseif scheme==2
da = derivative(aa);
aa1 = clamp(aa + dt*da)
for h = 0:20
alt = aa1
aa1 = clamp(aa + dt*(da + derivative(aa1))/2)
if maximum(abs.(alt-aa1))<1e-8
break
end
end
aa = copy(aa1)
elseif scheme==3
n0 = 1+mod(l,3)
n1 = 1+mod(l-1,3)
n2 = 1+mod(l-2,3)
f = zeros(NY, NX, 3) # ?
f[:,:,n0] = derivative(aa)
if l==0
aa += dt*f[:,:,n0]
elseif l==1
aa += dt*(3*f[:,:,n0] - f[:,:,n1])/2
elseif l>=2
aa += dt*(23*f[:,:,n0] - 16*f[:,:,n1] + 5*f[:,:,n2])/12
end
elseif scheme==4
k1 = derivative(aa)
k2 = derivative(clamp(aa + dt/2*k1))
k3 = derivative(clamp(aa + dt/2*k2))
k4 = derivative(clamp(aa + dt*k3))
aa += dt*(k1 + 2*k2 + 2*k3 + k4)/6
end
aa = clamp(aa)
if t >= nx
save("$(scheme)\\$(td)_$t.png", Gray.(kron(aa, ones(2, 2) ) ) )
nx += 1;
end
l += 1;
end
end # for td
end
@time smoothlife(256, 256, 20, 3)
```
В модели много свободных параметров, а также можно поиграться с разными методами для дифуров. В общем, есть простор для исследований. Также анимации всегда можно украсить шейдерами.
Тьюрмиты
--------
Еще один интересный вид машин Тьюринга это [тьюрмиты](https://en.wikipedia.org/wiki/Turmite) — клеточные автоматы, состояние которых определяется неким агентом, который будет перемещаться по полю в зависимости от этих самых состояний. Наиболее известный представитель этого вида — [муравей Лэнгтона](https://ru.wikipedia.org/wiki/%D0%9C%D1%83%D1%80%D0%B0%D0%B2%D0%B5%D0%B9_%D0%9B%D1%8D%D0%BD%D0%B3%D1%82%D0%BE%D0%BD%D0%B0).
На клеточное поле, каждая ячейка которого может быть либо черной либо белой, сажается мураш, который будет действовать по следующему алгоритму:
* На чёрном квадрате — повернуть на  влево, изменить цвет квадрата на белый, сделать шаг вперед на следующую клетку.
* На белом квадрате — повернуть на  вправо, изменить цвет квадрата на чёрный, сделать шаг вперед на следующую клетку.
На rosetta code есть [довольно хитрая реализация](http://rosettacode.org/wiki/Langton%27s_ant), где направление муравья задается комплексным числом:
```
function ant(width, height)
y, x = fld(height, 2), fld(width, 2)
M = trues(height, width)
dir = im
for i in 0:1000000
x in 1:width && y in 1:height || break
dir *= M[y, x] ? im : -im
M[y, x] = !M[y, x]
x, y = reim(x + im * y + dir)
i%100==0 && save("LR//zLR_$i.png", Gray.( kron(M,ones(4,4) ) ) )
end
Gray.(M)
end
ant(100, 100)
```
Поначалу, поведение агента кажется хаотичным. Но потом появляется магистраль — система выходит на стационар. Прекраснейший пример рождения порядка из кажимого хаоса!
Но самый смак начинается если расширить состояние ячейки за пределы одного бита:
**Код**
```
function ant(width, height, comnds;
steps = 10, cxema = reverse(ColorSchemes.hot),
savevery = 100, pixfactor = 20)
ma3x2pix() = [ clrs[k%n+1] for k in M ]
bigpix() = kron( ma3x2pix(), ones(Int64,m,m) )
save2pix(i) = save("$(comnds)_$i.png", bigpix() )
m = pixfactor
n = length(comnds)
colorsinscheme = length(cxema)
M = zeros(Int64, height, width)
y, x = fld(height, 2), fld(width, 2)
st = colorsinscheme ÷ n
clrs = [ cxema.colors[i] for i in 1:st:colorsinscheme ]
dir = im
for i in 0:steps
x in 1:width && y in 1:height || (save2pix(i); break)
j = M[y, x] % n + 1
dir *= comnds[j] == 'L' ? -im : im
M[y, x] += 1
x, y = reim(x + im * y + dir)
i % savevery==0 && save2pix(i)
end
ma3x2pix()
end
@time ant(16, 16, "LLRR", steps = 100, savevery = 1, pixfactor = 20)
```
Послойными наращиваниями получаем симметричную структуру, похожую на мозг! Для некоторых цветовых схем получается довольно футуристично
Правда потом он вырождается в ~~жопу~~ [кардиоиду](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D0%B4%D0%B8%D0%BE%D0%B8%D0%B4%D0%B0). Кстати, ничего еще не напоминает? А если добавить фрактальных наростов?..
**Код**
```
# http://rosettacode.org/wiki/Mandelbrot_set
function hsv2rgb(h, s, v)
c = v * s
x = c * (1 - abs(((h/60) % 2) - 1) )
m = v - c
r,g,b =
if h < 60
(c, x, 0)
elseif h < 120
(x, c, 0)
elseif h < 180
(0, c, x)
elseif h < 240
(0, x, c)
elseif h < 300
(x, 0, c)
else
(c, 0, x)
end
(r + m), (b + m), (g + m)
end
function mandelbrot()
w, h = 1000, 1000
zoom = 1.0
moveX = 0
moveY = 0
img = Array{RGB{Float64}, 2}(undef,h, w)
maxIter = 30
for x in 1:w
for y in 1:h
i = maxIter
c = Complex(
(2*x - w) / (w * zoom) + moveX,
(2*y - h) / (h * zoom) + moveY
)
z = c
while abs(z) < 2 && (i -= 1) > 0
z = z^2 + c
end
r,g,b = hsv2rgb(i / maxIter * 360, 1, i / maxIter)
img[y,x] = RGB{Float64}(r, g, b)
end
end
save("mandelbrot_set2.png", img)
end
mandelbrot()
```
и еще ряд интересных правил:
Магистрали довольно частое явление
Мозг в ящике — довольно стабильная структура. Здесь результат тридцати миллиардов шагов:
Короче, с такого рода экспериментами можно засесть надолго. И это мы только комбинировали два направления (лево-право), а ведь можно добавить еще вперед-назад, к тому же, никто не говорил, что муравей обязан продвигаться на одну клетку! Держу пари, что такого рода расширение стандартных правил породит еще много интересных закономерностей!
### Эпилог
К слову о жизни. Немало интереса вызывают самовоспроизводящиеся структуры, а ля [циклы Лэнгтона](https://en.wikipedia.org/wiki/Langton%27s_loops)
Можно почитать [статью](https://www.researchgate.net/publication/4249781_Sexyloop_Self-Reproduction_Evolution_and_Sex_in_Cellular_Automata), где данную модель расширяют наличием пола и передачей генов. *(Тут уж передаю эстафету кому-нибудь другому. Очень хотелось бы посмотреть на реализацию подобной штуки)*
Тема клеточных автоматов с ростом вычислительных мощностей и улучшением алгоритмов становится все популярней. У Вольфрама в блоге [небольшой отчет](https://writings.stephenwolfram.com/2012/05/its-been-10-years-whats-happened-with-a-new-kind-of-science/) по этой теме, да и каждый может [сам убедиться](https://arxiv.org/search/?query=) — статей много, причем самых разнообразных: там вам и дружба с нейронными сетями, и генераторы случайных чисел, и квантовые точки, и сжатие и много всякого другого...
Ну и напоследок самокопирующаяся структура созданная Тэдом Коддом [на спор за пинту пива](https://timhutton.github.io/2010/03/10/30984.html)
 | https://habr.com/ru/post/490454/ | null | ru | null |
# Начинаем работать с BACnet
Многие из нас, наверное, смотрели боевики и видели, как герои, сидя в темной комнате, удаленно управляют дверями в зданиях, открывая и закрывая их. Управляли освещением, лифтами, чтобы помочь кому-то куда-то пройти или, наоборот, помешать – ну и думали, что да, в теории такое возможно, и в каких-то зданиях, вероятно, есть какая-то автоматизация, но больше это кажется какой-то выдумкой. Так получилось, что в устройство, которое мы делаем, заказчик захотел добавить поддержку BACnet. Так я познакомился с тем, что, оказывается, существует [специализированный протокол для автоматизации зданий](https://en.wikipedia.org/wiki/BACnet), который развивается аж с 1987 года.
### О протоколе
В этой статье я хочу немножко рассказать о самом протоколе в общем, и как можно самим что-то попробовать собрать из исходников, какие инструменты есть, возможно, кому-то придется добавлять поддержку протокола в свои устройства – и эта статья окажется полезной.
Протокол поддерживает разные среды передачи данных, из самого популярного, пожалуй — RS-485, Ethernet и ZigBee. Наше устройство поддерживает BACnet протокол, работающий поверх Ethernet (Annex J в спецификации BACnet).
Протокол интересен тем, что не нужно ничего особенно настраивать, в том смысле, что если взять, например, Modbus, то там будет просто набор входов, выходов и регистров, и как это все соотносится с реальным оборудованием, можно выяснить только при помощи документации, а потом вручную это нужно настроить, начиная с адреса устройства и заканчивая конкретными входами и выходами, или вот датчик температуры — он может быть представлен в виде целого значения в регистре, и кто-то его представляет в градусах Цельсия, кто-то в десятых долях градуса Цельсия, кто-то еще в чем. В BACnet же, новое подключенное оборудование находится средствами самого протокола, вручную нужно задать только уникальный идентификатор устройства Device Instance.
Идея в том, что вся структура устройства представлена в виде коллекции объектов, а каждый объект имеет набор свойств, которые можно читать, а некоторые и писать, т.е. устройство — это объект, который имеет как одно из свойств список других свойств, которые он содержит, а также как одно из свойств — список других объектов, которые находятся внутри него. Таким образом можно узнать все об устройстве, только зная то, что оно существует в сети. И если говорить про тот же датчик температуры, то это будет объект аналогового входа с текстовым описанием в description, что это температура в комнате, например, и что важно с единицами измерения, будь то градусы Цельсия или Фаренгейта.
Объекты, которые могут быть описаны протоколом, разнообразны, начиная от дискретных входов и выходов (прям как в Modbus, с тем исключением, что эти входы и выходы можно подписать нормальным текстом в самом объекте) и заканчивая календарями, освещением, лифтами и эскалаторами. Можно делать такие интересные вещи, как убавить яркость света в коридоре в нерабочее время, или, если нужно выключать освещение совсем, то предупредительно моргнуть светом, перед тем как оставить задержавшихся на рабочем месте людей в полной темноте, и все это средствами самого протокола, просто настраивая свойства объектов.
Да, про асинхронность протокола, тут все довольно гибко, можно вручную читать свойства объектов, когда они нужны, т.е. можно просто посмотреть значение температуры с датчика, а можно задать пределы допустимых значений для этого датчика, подписаться на события и получать сообщения только при выходе температуры за установленные пределы, или, как вариант, получать новые значения, когда текущее значение изменится на заданную величину от переданного до этого, или просто периодически.
Ну и в целом, протокол благодаря объектной модели очень гибкий, есть объекты и свойства, которые обязательны для поддержки устройством, но большинство свойств и объектов опциональны. А так как гибкость имеет и обратную сторону – взяв новое устройство в руки, может быть непонятно, а подойдет оно вообще сюда, то придумали несколько градаций соответствия – профилей, ну как пример: дисплей оператора (B-OD), умный сенсор (B-SS), или, что как раз мы реализовали в нашем проекте, — специальный контроллер B-ASC (BACnet Application Specific Controller). В спецификации даже имеется специальная форма: BACnet Protocol Implementation Conformance Statement, заполнив которую получится документ с описанием соответствия вашего устройства (прям как у Гермеса Конрада – бюрократа 36 уровня).
### Проект
Наша железка представляет собой что-то вроде агрегатора разных протоколов от разных устройств, и внутри все представлено, как набор некоторых абстрактных сенсоров и объектов управления – контролов. И, как я упоминал ранее, появилась задача прикрутить BACnet так, чтобы наше устройство представляло все то, что к нему подключено (ну и некоторые свои внутренности) как устройство в BACnet сети (к слову не только BACnet, у нас есть еще и web-интерфейс, и командная строка, и SNMP, и AWS). Так как стандарт описан чуть менее чем на 1400 страницах и продолжает развиваться, то было понятно, что лучше за основу взять что-то готовое и желательно открытое.
Мы использовали библиотеку [bacnet-stack](https://github.com/bacnet-stack/bacnet-stack) – она написана на чистом C. Библиотека довольно компактная и может компилироваться под множество платформ: под Windows, под Linux и, даже для микроконтроллеров (PIC18, atmega8, stm32).
Так как наше устройство использует Linux и работает на ARM, то для сборки библиотеки мы пользовались кросс-компиляцией, надо отдать должное разработчикам библиотеки – все собралось нормально без необходимости какой-либо доработки.
Архитектурно поддержка протокола в нашем проекте выполнена в виде отдельного демона, взаимодействующего с основным приложением посредством API.
Кстати, примеры, которые идут вместе с библиотекой, вполне годные, и их можно взять как основу для своего проекта. Но если вы захотите что-то сделать на основе библиотечных примеров, есть такая особенность – объекты выделены статически, да-да, просто глобальные массивы объектов фиксированного размера. Для простых устройств на микроконтроллерах – это скорее плюс, в том смысле, что если структура объектов зафиксирована (а для простого устройства скорее всего так) то динамическое выделение памяти создаст только проблемы.
В нашем же случае кол-во устройств и объектов может меняться, а весь проект написан на C++ (и грех не воспользоваться контейнерами), поэтому работу с библиотекой мы, конечно, переделали.
### Как собрать и запустить сервер и клиент
Если вам уже стало интересно, и захотелось попробовать BACnet в деле, то дальше описан небольшой туториал, как собрать библиотеку bacnet-stack со всем инструментарием, и запустить сервер и клиент у себя.
Проект bacnet-stack состоит из, собственно, библиотеки, и набора инструментария (можно сказать — примеров), который эту библиотеку использует.
Для запуска нам потребуются две Linux машины в одном сегменте сети – на одной будет запущен BACnet-сервер, а на второй мы будет запускать утилиты, которые будут выступать в роли клиента.
Процесс сборки я описал для Windows 10 с установленной в WSL Ubuntu 20.04, идея была такая, что у многих сейчас стоит десятка и поставить туда через Microsoft Store Ubuntu совсем не сложно, а у некоторых и так стоит Ubuntu, так что описание должно быть более-менее универсальным.
Нужно установить GCC и Git, если у вас уже установлены эти инструменты, то это можно пропустить.
```
sudo apt install build-essential
sudo apt-get install git
```
После этого склонировать репозиторий bacnet-stack к себе при помощи команды:
```
git clone https://github.com/bacnet-stack/bacnet-stack.git
```
Затем запустить сборку:
```
cd bacnet-stack
make clean all
```
Вот, собственно и все. После сборки в директории ”bacnet-stack\bin\” появится набор исполняемых файлов, также там лежит текстовый документ “readme.txt ” с описанием что есть что. Эти шаги можно повторить и на второй машине, а можно просто, как поступил я, скопировать каталог с уже собранными утилитами с первой на вторую.
Перед тем как запустить сервер, нужно создать переменную окружения с указанием интерфейса, на котором будет запущен сервер, без этого BACnet сервер запустится на первом попавшемся сетевом интерфейсе (если интерфейс всего один, то это может быть как раз то, чего вы хотите, а может быть и нет). Я проводил эксперимент на двух ноутбуках, подключенных к Wi-Fi роутеру, поэтому и там и там указывал Wi-Fi адаптер ноутбука (если что, то список всех адаптеров с IP адресами можно посмотреть командой “ip address”).
Ставим переменную окружения, с указанием интерфейса на первой машине:
```
export BACNET_IFACE=wifi0
```
После этого уже можно запустить BACnet сервер:
```
cd bacnet-stack/bin
./bacserv
BACnet Server Demo
BACnet Stack Version 1.0.0
BACnet Device ID: 260001
Max APDU: 1476
BACnet Device Name: SimpleServer
```
Сервер с этого момента запущен и устройство, которое он представляет, имеет Device ID = 260001, это значение выбрано по-умолчанию в утилите сервера, но вы можете указать в опциях при запуске сервера какое-то свое значение.
Теперь можно перейти ко второй машине и попробовать что-то прочитать с запущенного сервера.
Перед этим нужно, так же как и в случае с сервером, сконфигурировать интерфейс, путем инициализации переменной окружения BACNET\_IFACE:
```
export BACNET_IFACE=wifi0
```
После настройки интерфейса можно запросить список видимых устройств при помощи BACnet службы Who Is:
```
./bacwi
;Device MAC (hex) SNET SADR (hex) APDU
;-------- -------------------- ----- -------------------- ----
260001 C0:A8:00:D5:BB:C3 0 00 1476
;
; Total Devices: 1
```
Тут мы видим в сети одно устройство с Device ID 260001 – это наш сервер, отлично!
Теперь можно прочитать свойства устройства, для этого нужно воспользоваться утилитой bacrp (Read Property), формат ее использования такой:
```
Usage: bacrp device-instance object-type object-instance property [index]
[--dnet][--dadr][--mac]
[--version][--help]
```
Т.е. для чтения списка объектов нужно указать device-instance – 260001, object-type – “device” или если указывать числом, то — 8, object-instance – в данном случае он равен device-instance 260001, и свойство, которое мы читаем — object-list (или если указывать через номер свойства, то это будет 76):
```
./bacrp 260001 8 260001 76
```
или, что то же самое:
```
./bacrp 260001 device 260001 object-list
```
**Список объектов**
```
{(device, 260001),(network-port, 1),(analog-input, 0),(analog-input, 1),
(analog-input, 2),(analog-input, 3),(analog-output, 0),(analog-output, 1),
(analog-output, 2),(analog-output, 3),(analog-value, 0),(analog-value, 1),
(analog-value, 2),(analog-value, 3),(binary-input, 0),(binary-input, 1),
(binary-input, 2),(binary-input, 3),(binary-input, 4),(binary-output, 0),
(binary-output, 1),(binary-output, 2),(binary-output, 3),(binary-value, 0),
(binary-value, 1),(binary-value, 2),(binary-value, 3),(binary-value, 4),
(binary-value, 5),(binary-value, 6),(binary-value, 7),(binary-value, 8),
(binary-value, 9),(characterstring-value, 0),(command, 0),(command, 1),
(command, 2),(command, 3),(integer-value, 1),(notification-class, 0),
(notification-class, 1),(life-safety-point, 0),(life-safety-point, 1),
(life-safety-point, 2),(life-safety-point, 3),(life-safety-point, 4),
(life-safety-point, 5),(life-safety-point, 6),(load-control, 0),
(load-control, 1),(load-control, 2),(load-control, 3),
(multi-state-input, 0),(multi-state-input, 1),(multi-state-input, 2),
(multi-state-input, 3),(multi-state-output, 0),(multi-state-output, 1),
(multi-state-output, 2),(multi-state-output, 3),(multi-state-value, 0),
(multi-state-value, 1),(multi-state-value, 2),(multi-state-value, 3),
(trend-log, 0),(trend-log, 1),(trend-log, 2),(trend-log, 3),(trend-log, 4),
(trend-log, 5),(trend-log, 6),(trend-log, 7),(lighting-output, 1),
(lighting-output, 2),(lighting-output, 3),(lighting-output, 4),
(lighting-output, 5),(lighting-output, 6),(lighting-output, 7),
(lighting-output, 8),(channel, 1),(file, 0),(file, 1),(file, 2),
(octetstring-value, 0),(octetstring-value, 1),(octetstring-value, 2),
(octetstring-value, 3),(positive-integer-value, 0),
(positive-integer-value, 1),(positive-integer-value, 2),
(positive-integer-value, 3),(schedule, 0),(schedule, 1),(schedule, 2),
(schedule, 3),(accumulator, 0),(accumulator, 1),(accumulator, 2),
(accumulator, 3),(accumulator, 4),(accumulator, 5),(accumulator, 6),
(accumulator, 7),(accumulator, 8),(accumulator, 9),(accumulator, 10),
(accumulator, 11),(accumulator, 12),(accumulator, 13),(accumulator, 14),
(accumulator, 15),(accumulator, 16),(accumulator, 17),(accumulator, 18),
(accumulator, 19),(accumulator, 20),(accumulator, 21),(accumulator, 22),
(accumulator, 23),(accumulator, 24),(accumulator, 25),(accumulator, 26),
(accumulator, 27),(accumulator, 28),(accumulator, 29),(accumulator, 30),
(accumulator, 31),(accumulator, 32),(accumulator, 33),(accumulator, 34),
(accumulator, 35),(accumulator, 36),(accumulator, 37),(accumulator, 38),
(accumulator, 39),(accumulator, 40),(accumulator, 41),(accumulator, 42),
(accumulator, 43),(accumulator, 44),(accumulator, 45),(accumulator, 46),
(accumulator, 47),(accumulator, 48),(accumulator, 49),(accumulator, 50),
(accumulator, 51),(accumulator, 52),(accumulator, 53),(accumulator, 54),
(accumulator, 55),(accumulator, 56),(accumulator, 57),(accumulator, 58),
(accumulator, 59),(accumulator, 60),(accumulator, 61),(accumulator, 62),
(accumulator, 63)}
```
Тут мы видим длинный список объектов, которые содержатся в объекте «устройство 260001»: первым идет, собственно, объект, описывающий само устройство, представленное сервером, потом объект сетевого подключения, аналоговые входы и выходы, дискретные входы и выходы, ну и множество других объектов.
Попробуем прочитать сначала список свойств нашего устройства:
```
./bacrp 260001 device 260001 property-list
{system-status,vendor-name,vendor-identifier,model-name,
firmware-revision,application-software-version,protocol-version,
protocol-revision,protocol-services-supported,
protocol-object-types-supported,object-list,max-apdu-length-accepted,
segmentation-supported,apdu-timeout,number-of-APDU-retries,
device-address-binding,database-revision,description,local-time,
utc-offset,local-date,daylight-savings-status,location,
active-cov-subscriptions,time-synchronization-recipients,
time-synchronization-interval,align-intervals,interval-offset}
```
А теперь и некоторые из этих свойств:
```
./bacrp 260001 device 260001 vendor-name
"BACnet Stack at SourceForge"
./bacrp 260001 device 260001 model-name
"GNU"
./bacrp 260001 device 260001 location
"USA"
./bacrp 260001 device 260001 description
"server"
./bacrp 260001 device 260001 object-name
"SimpleServer"
```
Ну, USA так USA… что-то про само устройство мы выяснили, теперь прочитаем описание, скажем, аналогового входа 0, и что там у него собственно на входе.
В принципе все точно так же, как и для объекта device, только object-instance уже не равен device-instance, читаем список всех свойств объекта:
```
./bacrp 260001 analog-input 0 property-list
{present-value,status-flags,event-state,out-of-service,units,description,
reliability,cov-increment,time-delay,notification-class,high-limit,low-limit,
deadband,limit-enable,event-enable,acked-transitions,notify-type,
event-time-stamps,9997,9998,9999}
```
А теперь сами значения основных свойств:
```
./bacrp 260001 analog-input 0 description
"ANALOG INPUT 0"
./bacrp 260001 analog-input 0 present-value
0.000000
./bacrp 260001 analog-input 0 units
percent
```
Видно, что единицы измерения тут проценты, а входное значение равно нулю.
Читать объекты, конечно интересно, но как на счет того чтобы чем-то поуправлять (виртуально, конечно, у нас же просто демо-сервер).
В списке объектов есть “lighting-output” – это, как раз, объект для управления освещением с диммированием (для светильников без диммирования в BACnet существует просто “binary-lighting-output”). Если почитать спецификацию, то можно увидеть, что управлять яркостью можно разными способами: или записью в свойство “present-value”, или записью команды в “lighting-command”, воспользуемся первым вариантом.
Читаем список свойств объекта “lighting-output”:
```
./bacrp 260001 lighting-output 1 property-list
{present-value,tracking-value,lighting-command,in-progress,status-flags,
out-of-service,blink-warn-enable,egress-time,egress-active,
default-fade-time,default-ramp-rate,default-step-increment,
priority-array,relinquish-default,lighting-command-default-priority}
```
Потом читаем текущую яркость:
```
./bacrp 260001 lighting-output 1 present-value
0.000000
```
Яркость 0%, это значит, что свет не горит, попробуем записать новое значение при помощи утилиты bacwp (Write Property):
```
./bacwp 260001 lighting-output 1 present-value 16 -1 4 100
WriteProperty Acknowledged!
```
А вот тут, видимо, нужно пояснить – если сначала все параметры идут точно такие же, как и у утилиты bacrp, то после указания записываемого свойства “present-value”, уже может быть не все понятно: 16 – это приоритет записываемого значения, т.е. можно последовательно записать несколько значений с разным приоритетом, но действовать будет то, что с высшим (таким же образом, записанное значение с указанным приоритетом, можно как бы отменить, если указать тип данных 0, и действовать будет то, из оставшихся значений, что имеет более высокий приоритет); в данном случае 16 – это низший приоритет (ну, а 0 соответственно — высший), дальше: -1 – тут должен быть индекс в случае записи массива, но поскольку у нас просто одно значение, то “-1” значит то, что никакого индекса и нет, потом 4 – тип данных – “real “, и, наконец, 100 – собственно само значение, которое мы записываем.
Проверяем, записалось ли значение:
```
./bacrp 260001 lighting-output 1 present-value
100.000000
```
Да, все как и ожидалось — записалось, теперь по идее свет должен гореть.
Ну, вот, как-то так – теперь вы тоже немного умеете управлять зданием!
Если вас заинтересовало, что за объект такой “accumulator”, которых почему-то очень много в примере сервера – так в BACnet называется объект, представляющий счетчик, в данном случае это электросчетчики (но могут быть и счетчики воды или тепла), так что все это дело можно сразу интегрировать в систему АСКУЭ.
### Инструменты
Что еще есть из инструментария в открытом доступе? Ну, я бы отметил программу с графическим интерфейсом [Yabe](https://sourceforge.net/projects/yetanotherbacnetexplorer/) (расшифровывается как Yet Another BACnet Explorer, видимо отсылка к YACC), программа написана на C#, и довольно таки функциональна, даже в сравнении с коммерческими аналогами. Так что, если вы собрали сервер и уже наигрались с клиентскими утилитами в командной строке, то можно запустить Yabe и посмотреть на свое BACnet устройство из графического интерфейса, только не надо запускать сразу и консольные клиентские утилиты и Yabe – они, скорее всего, не смогут поделить один физический интерфейс и нормально работать вместе не будут.
Хотелось бы рассказать про некоторые неочевидные (по крайней мере для меня) моменты использования Yabe. Сразу после запуска приложения, оно не начнет искать устройства, для этого нужно добавить интерфейс, через который это следует делать. Для этого нужно нажать на иконку “Add device”, и там выбрать интерфейс, через который будет происходить общение, т.е. под device создатели программы почему-то подразумевают Ethernet или serial порт, а вовсе не BACnet устройство как могло бы показаться.
**Окно выбора интерфейса**
Если устройство находится в одной подсети (ну, например, на второй машине остался работать сервер из предыдущего примера), то оно уже появится в списке устройств. Если же сервер находится с вами в разных сегментах (например, у меня возникли сложности с подключением при работе через VPN), то можно задействовать возможность устройств к трансляции сообщений. Для этого сначала нужно добавить BACnet Device ID для самого клиента Yabe через Options/Settings и там найти параметр YabeDeviceId и поставить его в какое-нибудь значение, пусть это будет 3630000. IP адрес в меню Add Device при подключении должен быть указан тот, который, ваш внешний. После этого нужно нажать на иконку UDP соединения и через меню выбрать Functions/IP Services/Foreign Device Registration и там указать IP адрес и порт существующего устройства, которое будет использовано как мост для трансляции широковещательных BACnet пакетов.
Нажать Register и указанное устройство появится в списке устройств вместе с устройствами, которые находятся с ним в одном сегменте сети.
Примерно так выглядит окно Yabe, когда все сделано правильно.
В левой верхней части находится панель с устройствами, чуть ниже — список объектов в выбранном устройстве, справа — свойства выбранного объекта. На скриншоте выбран один из температурных сенсоров. Некоторые свойства могут быть отредактированы, если они поддерживают возможность записи значений, например можно добавить свое описание этого сенсора в поле Description.
Если вы решили делать какое-то BACnet устройство на базе bacnet-stack и у вас есть какие-то тесты (ручные или автоматические), основанные на этой же библиотеке, и все замечательно функционирует, то все равно неплохо бы запустить Yabe и посмотреть как это выглядит там, потому что всегда полезно попробовать как работают между собой реализации протокола не основанные на одной библиотеке (а Yabe как раз не основана на bacnet-stack).
Ну и напоследок — что делать, если что-то работает, а что-то никак не хочет, хотя все вроде сделано правильно? Где ошибка в реализации клиента или сервера? Оказывается, многим известный инструмент – Wireshark, вполне себе понимает протокол BACnet и позволяет посмотреть, что передается внутри пакетов, а потом уже можно свериться со спецификацией протокола и посмотреть что же там не так.
### Заключение
Ну вот и все, надеюсь, что смог вкратце рассказать о BACnet. Конечно тяжело уместить все в одну статью, но то что есть, должно помочь начать работать с протоколом тому, кто строит свой «умный дом», занимается интеграцией, или создает устройства автоматики. | https://habr.com/ru/post/680790/ | null | ru | null |
# Скорость флешек
Здравствуйте уважаемые любители железа!
#### Проблема
В сети невозможно найти информацию о скорости конкретной модели USB Flash накопителя(в простонародии флешки). Причина секретности этой информации мне не известна.
#### Наше решение
Была разработана утилита для проведения тестирования флешки и отсылки результатов на сайт.
#### Бенчмарк
Приложение написанно на .NET Framework 2.0. Для низкоуровневых операций написан .dll модуль на C++.
Целью было оценить скорость чтения и записи на карточку блоков разных размеров. Для решения этой задачки я воспользовался WinAPI функциями: CreateFile, WriteFile и ReadFile. При создании файла устанавливался флажок FILE\_FLAG\_NO\_BUFFERING, который указывает ОС, что не следует использовать всякого рода файловые кэши.
Вот так выглядит тест на запись блоков:
> `\_\_declspec(dllexport) double WriteBench(LPCSTR path, long size, long count, char\* ErrorMessage)
>
> {
>
> HRTimer timer; int i;
>
> double elapsed;
>
> HANDLE hFile; DWORD dwResult;
>
> void\* buffer = malloc(size);
>
> memset(buffer, -1, size);
>
> hFile = CreateFileA(path,
>
> GENERIC\_WRITE,
>
> FILE\_SHARE\_WRITE,
>
> NULL,
>
> CREATE\_ALWAYS,
>
> FILE\_FLAG\_NO\_BUFFERING,
>
> NULL);
>
>
>
> if (hFile == INVALID\_HANDLE\_VALUE)
>
> {
>
> sprintf((char\*)ErrorMessage, "Could not open file (error %d)\n", GetLastError());
>
> return 0;
>
> }
>
>
>
> timer.StartTimer();
>
> for (i =0 ; i< count; i++){
>
> if(!WriteFile(hFile, buffer, size, &dwResult, NULL))
>
> {
>
> sprintf((char\*)ErrorMessage, "Could not write to file (error %d)\n", GetLastError());
>
> return 0;
>
> }
>
> }
>
> elapsed = timer.StopTimer();
>
>
>
> CloseHandle(hFile);
>
> DeleteFileA(path);
>
> free(buffer);
>
> return elapsed;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Буду очень признателен, если вы посмотрите мой проект [UsbFlashSpeed.com](http://UsbFlashSpeed.com) и укажете на обнаруженные недостатки.
**Это пост для предварительного тестирования сервиса и сбора критических замечаний! Анонс сервиса будет позже.** | https://habr.com/ru/post/95384/ | null | ru | null |
# 6 применений в «умном доме» платы USBasp. Нестандартное использование USBasp
[](http://homes-smart.ru/upload/habr/usb-nrf.jpg)
Иногда дешевле купить готовое устройство, чем собирать его самому. Да и самодельное устройство не всегда и не у всех будет выглядеть аккуратно- это зависит от наличия оборудования/материалов и прямоты рук.
Пользователи, знакомые с микроконтроллерами Atmel или хотя бы с Arduino скорее всего знают о дешевом программаторе USBasp, цена которого на Ebay около $ 3. Распространены две версии программатора:
USBasp 2.0 — с стабилизатором на 3.3 вольта.
USBasp 3.0 — плата поменьше, без стабилизатора. Так же у него не выведены на разъем порты PD0 и PD1(Аппаратный UART).В руках не держал и соответственно рассматривать его тут не будем.
Ниже мы рассмотрим как превратить программатор USBasp в I2C-USB переходник, научимся читать датчики влажности и температуры, получим простой набор портов ввода/вывода (PIO), RS232-USB, а так же попытаемся создать устройство nRF24L01-USB для чтения беспроводных датчиков и управления устройствами. Ну и для любителей Arduino — будем программировать в среде Arduino IDE используя USBasp как макетную плату.Проекты используют популярную библиотеку [V-USB](http://www.obdev.at/products/vusb/index.html) для работы с USB в программной реализации.
Архив с прошивками можно скачать в конце статьи. Я намеренно не публикую тут прямые ссылки на свои проекты -вы их найдете в архиве.
#### Устройство программатора USBasp
Программатор состоит из небольшого числа деталей. Мозгом программатора является микроконтроллер Atmega8, который имеет всего 8 кб флеш памяти и 1 кб ОЗУ(SRAM).Вроде и слабенький микроконтроллер по современным меркам, но столько всего можно на нем сделать.Из-за особенностей работы программного USB м/к работает на частоте 12мгц. Соответственно, при написании своей прошивки необходимо учитывать это.
USBasp имеет 10 контактный разъем, на который выведены 6 выводов микроконтроллера: PB5 (SCK), PB4 (MISO), PB3 (MOSI, PWM), PB2(PWM), PD0 (RXD), PD1 (TXD).Питание 5в или 3.3в, которое переключается перемычкой JP1.
Плата имеет два встроенных светодиода на выводах PC0 и PC1.Выводы м/к PB0,PB1 и PD2 используются для программного USB,PC2 выведен на перемычку JP3.Остальные выводы микроконтроллера не распаяны.
Со схемой устройства можно ознакомится в архиве в конце статьи.
#### Установка загрузчика на плату
Для быстрой смены прошивки, без сторонних программаторов можно установить загрузчик USBaspLoader.Официальная страница проекта [USBaspLoader](http://www.obdev.at/products/vusb/usbasploader.html)
К сожалению загрузчик отнимает 2 кб флеш памяти, но для большинства применений нам хватит оставшихся 6 кб.
##### Установка загрузчика:
Команда программирования используя Arduino как программатор:
```
avrdude -c avrisp -P COM1 -b 19200 -p m8 -U flash:w:boot_m8.hex -U hfuse:w:0xc0:m -U lfuse:w:0x9f:m -U lock:w:0x2f:m
```
Команда программирования через другую USBasp:
```
avrdude -c usbasp -p m8 -U flash:w:boot_m8.hex -U hfuse:w:0xc0:m -U lfuse:w:0x9f:m -U lock:w:0x2f:m
```
После этого уже можно заливать свою прошивку без программатора стандартной командой
```
avrdude -c usbasp -p m8 -U flash:w:имя_файла.hex
```
Для того, чтобы «залить» прошивку в устройство с установленным USBaspLoader необходимо установить перемычку JP3, которая переводит устройство в режим программирования и сбросить устройство, замкнув контакт ближний к перемычке выбора питания(JP1) на перемычке JP2 на землю.
#### Использование USBasp как макетную плату в Arduino IDE
Для прошивки в среде Arduino IDE (проверено на версиях 1.0.х) необходимо в файл board.txt вписать следущий текст:
```
atmega8usb.name=ATmega8 USB 12 MHz
atmega8usb.upload.protocol=arduino
atmega8usb.upload.maximum_size=6144
atmega8usb.upload.speed=19200
atmega8usb.bootloader.low_fuses=0x9f
atmega8usb.bootloader.high_fuses=0xc0
atmega8usb.bootloader.path=atmega8
atmega8usb.bootloader.file=boot_m8.hex
atmega8usb.bootloader.unlock_bits=0x3F
atmega8usb.bootloader.lock_bits=0x2F
atmega8usb.build.mcu=atmega8
atmega8usb.build.f_cpu=12000000L
atmega8usb.build.core=arduino
atmega8usb.build.variant=standard
```
После этого в среде Arduino IDE можно выбрать появившуюся плату ATmega8 USB 12 MHz. Прошивка осуществляется через меню «загрузка с помощью программатора».
Доступные пины по нумерации Arduino: 13 (SCK),12 (MISO),11 (MOSI,PWM),10 PB2(PWM) ,1 (TXD),0 (RXD).Так же доступны цифровые выводы 14 и 15 для управления светодиодами на плате.
Можно задействовать и интерфейс USB, используя библиотеку для Arduino V-USB, но возможностей тут меньше, чем на Си.
#### nRF24L01-USB
Позволяет обмениваться данными между nRF24L01/nRF24LE1 и компьютером с устройством nRF24L01-USB. Теоретически поддерживается до 22 клиентов(при пакете передачи 32 байта) на базе nRF24L01/nRF24LE1, но пока на практике проверено до 3. Ограничение связано с тем, что для приема и отправки данных используется буфер в ОЗУ устройства, а его как известно у Atmega8 всего 1кб.Размер приемного пакета может быть до 32 байт, а отправки — 4 байта, это ограничение связано со способом реализации работы с библиотекой V-USB.
Работа nRF24L01-USB адаптера основана на временном разделении, когда клиенты отправляют/принимают данные в разное время. При большом количестве клиентов время опроса должно быть бОльшим. Для обмена данными в реальном времени количество клиентов должно быть наименьшим. Пока у устройства имеются некоторые недостатки, но думаю это решаемо.
Клиентская утилита управления, чтения и отправки данных работает как в Linux, так и Windows, но пока, к сожалению, требуется компиляция для настройки принятых данных. Для удобства настройки и отладки через утилиту можно менять канал, скорость и включать/выключать аппаратное подтверждение, работать напрямую с регистрами радио модуля.
Устройство можно применить для беспроводных датчиков или управления в системах умного дома.
Кстати, ранее был разработан и испытан вариант беспроводных датчиков влажности и температуры на базе attiny13 на частоте 315 или 433 мгц, но это уже другая тема.
#### RS232-USB
На основе программатора USBasp можно создать устройство-переходник RS232-USB на базе проекта [cdc-232](http://www.recursion.jp/avrcdc/cdc-232.html).
Подойдет для программирования плат Arduino, на которых нет микросхемы FT232RL или другого преобразователя usb-uart.
#### PIO-USB
6 выводов, которые выведены на разъеме программатора могут использоватся как обычные PIO выводы, для «дерганья» светодиодами и релюшками, а так же считывания логического состояния порта. В архиве в конце статьи имеется мой вариант PIO-USB, который так же позволяет считывать датчик влажности DHT11/DHT22, а так же транслировать код для управления розетками/люстрами, если подключить радио перадтчик на 433/315 мгц. Планируется новая версия, в которой увеличится количество подключаемых датчиков влажности и исправлены ошибки.
#### DS18B20-USB
Программатор можно «научить» работать с несколькими датчиками температуры DS18B20.Например использовать проект [USBTemp](http://code.google.com/p/mikrowerk/wiki/USBTemp).
Возможны и другие варианты реализации схемы и прошивки устройства, а так же интеграция с PIO-USB.
К сожалению из-за размера прошивки загрузка не возможна через USBaspLoader.
#### I2C-USB
Устройство позволяет подключить практически любые устройства i2c к компьютеру.Проверено как на Linux так и в Windows XP.Прошивка основана на известном проекте [i2c tiny usb](http://www.harbaum.org/till/i2c_tiny_usb/index.shtml).
Мои примеры использования устройства:
Чтение датчика давления BMP085.
Управление микросхемой расширителем портов MCP23017, получив тем самым почти тот же PIO на компьютере.
Вариантов применения масса: программирование EEPROM памяти, чтение спецефичных разных датчиков, управление FM приемником.
Это конечно же далеко не все варианты использования программатора в нестандартном функционировании.
Все исходные коды сторонних проектов можно найти на их официальных сайтах. В архиве в конце статьи имеются прошивки, которые адаптированы под выводы платы USBasp.
Архив с прошивками: [usbasp.zip](http://homes-smart.ru/upload/habr/usbasp.zip)
UPD: Ещё одно применение USBasp в статье [«Программируем nRF24LE1 через Raspberry PI и USBasp»](http://habrahabr.ru/post/210974/). | https://habr.com/ru/post/208470/ | null | ru | null |
# MVP и Dagger 2 – скелет Android-приложения – часть 2
*Данная статья является результатом изысканий, побочным продуктом которых стало воплощение давней идеи в одном очень полезном и очень не хватавшем мне когда-то Android-приложении – [My Location Notifier](https://play.google.com/store/apps/details?id=com.caesar84mx.mylocationnotifier), предназначенном для автоматического оповещения адресата о прибытии пользователя (см. подробное описание по [ссылке](https://play.google.com/store/apps/details?id=com.caesar84mx.mylocationnotifier)).*
Итак, [в первой части](https://habr.com/post/434498/) мы построили основной скелет Android-приложения в соответствии с архитектурой MVP. Теперь начнем прикручивать к нему Dagger 2.
**2.1. Предварительная настройка**
Для начала, перейдем в файл build.gradle (Project: mymvcapp) и добавим в раздел buildscript следующую строчку:
```
ext.dagger2_version = "2.8"
```
На момент написания этой статьи это последняя версия Dagger 2. Далее, перейдем в файл build.gradle (Module: app) и добавим в начало строчку:
```
apply plugin: 'kotlin-kapt'
```
Это нужно для того, чтобы в Dagger 2 мог генерировать свой код при компиляции. Позже поймете зачем.
Теперь добавим необходимые зависимости:
```
implementation "com.google.dagger:dagger:$dagger2_version"
kapt "com.google.dagger:dagger-compiler:$dagger2_version"
```
**2.2. Подготовка к инъекции**
Синхронизируем проект и вернемся к компоненту MainScreen. Создадим в пакете backstage класс di.MainScreenModule и пометим его аннотацией [Module](https://habr.com/users/module/). В новом классе объявим и имплементируем метод providesPresenter(): MainScreenPresenter = MainScreenPresenter и пометим его аннотациями [Provides](https://habr.com/users/provides/) и [Singleton](https://habr.com/users/singleton/). Так теперь будет выглядеть наш класс:
```
@Module
class MainScreenModule {
@Provides
@Singleton
fun providesPresenter(): MainScreenPresenter = MainScreenPresenter()
}
```
Теперь перейдем в класс MainScreenCompatActivity и заменим модификаторы переменной presenter на lateinit var, удалим присвоение значения и пометим ее аннотацией [Inject](https://habr.com/users/inject/):
```
class MainScreen : BaseCompatActivity(), MainScreenContract.View {
@Inject
lateinit var presenter: MainScreenPresenter
override fun init(savedInstanceState: Bundle?) {
setContentView(R.layout.activity_main_screen)
presenter.attach(this)
}
}
```
Заметьте, вопросительный знак нам теперь при обращении к этой переменной не нужен.
Может показаться, что все, инъекция произведена, задача выполнена. А вот и нет. Теперь нам необходимо заставить Dagger сгенерировать необходимый код для внедрения нашей первой зависимости. Именно для этого мы выше добавляли в скрипт сборки плагин kotlin-kapt. В пакете com.caesar84mx.mymvcapp создаем пакет di.config, в котором создадим интерфейс AppDiComponent.
Теперь, объявим интерфейс компонентом и синглтоном ~~и мизераблем~~, зарегистрируем в нем наш модуль, а внутри интерфейса объявим метод inject(mainScreenActivity: MainScreen):
```
@Component(
modules = [
MainScreenModule::class
]
)
@Singleton
interface AppDiComponent {
fun inject(mainScreenActivity: MainScreen)
}
```
А теперь, необходимо, наконец, заставить Dagger сгенерировать весь необходимый код. Для этого, создадим в пакете config.di класс MyMvpApp, унаследуем его от класса Application, зарегистрируем класс в AndroidManifest.xml, прописав в теге application строчку android:name=".config.di.MyMvpApp". Далее, объявляем переменную lateinit var injector: AppDiComponent, устанавливаем ей приватный сеттер, переопределяем метод onCreate(). И начинаем магию:
```
class MyMvpApp: Application() {
lateinit var injector: AppDiComponent
private set
override fun onCreate() {
super.onCreate()
injector = DaggerAppDiComponent.builder()
.mainScreenModule(MainScreenModule())
.build()
}
}
```
Как вы успели заметить, класса DaggerAppDiComponent еще не существует, он будет сгенерирован при билде приложения. Равно как и имплементация нашего компонента. Имя класса составляется из слова “Dagger” + названия интерфейса, помеченного как компонент. Метод mainScreenModule() тоже будет сгенерирован при билде проекта, имя должно составляться из имени класса инъектируемого модуля в lowerCamelCase.
Собираем проект (Build → Make Project). Наслаждаемся автоматической кодогенерацией и продолжаем.
**2.3. Инъекция**
Внимание: далее, будут представлены некоторые пляски с бубном с элементами порно. Просьба убрать от экрана детей и нервных личностей.
Нам, для успешных инъекций будет необходима ссылка на переменную injector. Согласитесь, создавать экземпляр MyMvpApp в каждом классе, где мы производим инъекцию – не самое удачное решение. Поэтому, мы сделаем следующее:
```
class MyMvpApp: Application() {
lateinit var injector: AppDiComponent
private set
override fun onCreate() {
super.onCreate()
INSTANCE = this
injector = DaggerAppDiComponent.builder()
.mainScreenModule(MainScreenModule())
.build()
}
companion object {
private var INSTANCE: MyMvpApp? = null
@JvmStatic
fun get(): MyMvpApp = INSTANCE!!
}
}
```
Выдохнули, вернулись в класс MainScreen. Тепепь, в метод init() инжектим наш презентер. Не забудьте, что это действие необходимо выполнять до первого обращения к инъектируемой переменной. Так теперь выглядит наш класс:
```
class MainScreen : BaseCompatActivity(), MainScreenContract.View {
@Inject
lateinit var presenter: MainScreenPresenter
override fun init(savedInstanceState: Bundle?) {
setContentView(R.layout.activity_main_screen)
MyMvpApp.get().injector.inject(this)
presenter.attach(this)
}
}
```
А вот как выглядит вся базовая структура нашего приложения:
**2.4. Заключение**
Итак, у нас готова минимальная структура приложения, на которую далее только остается навешивать элементы. Нужна новая активность? Представляем ее компонентом, отделяем ui от backstage, для каждого компонента определяем, какие зависимости нам нужны (минимум, презентер в активности, а может, в самом презентере API для взаимодействия с удаленным сервисом, или, например, API репозитория для работы с БД), прописываем модуль с зависимостями, регистрируем модуль в компоненте, прописываем в билдере, пересобираем проект, инжектим зависимости где необходимо, повторяем итерацию для каждого нового компонента.
Разумеется, может возникнуть вопрос: а зачем нам нужен Dagger? Без него ведь отлично справлялись? Отлично, пока приложение маленькое. Когда оно разрастется до полноценного, с десятками активностей, фрагментов, адаптеров, с запросами на сервер, кэшированием данных и прочими чудесами, возникнет множество зависимостей, отследить которые в большом приложении довольно трудно, если не использовать Dependency Injection. DI-фреймворк Dagger помогает упростить задачу их внедрения и отслеживания. | https://habr.com/ru/post/434618/ | null | ru | null |
# Intel TXT vulnerability
### Короткая заметка проверки уязвимости Intel Trusted Execution Technology
В статье использовались: Ubuntu 16.04, tBoot 1.9.6, TPM 1.2.
Сначала проверим работает-ли intel txt на Ubuntu с ядром 4.10.0-28 командой:
`sudo txt-stat`
как видим, mle успешно запущен, и секретный флаг установлен верноtxt-stat показывает хеши системы. Хэши могут быть использованы злоумышленником для ответа и выполнения обычных PCRs.
Проверим динамику PCRs от TPM:
И как видим первые два символа начинаются с 8AF3, AB69, 4836.
Теперь повторим те же самые действия на 4.10.17+malicious:
А тут первые два символа начинаются с 8AF3, 0E89, 486A.
Сравним оба файла и посмотрим изменения:
`git diff normal_pcrs.txt malicious_pcrs.txt`
Видим, что PCR-18 и PCR-19 отличаются, из-за ядра malicious.
Запускаем "Lost Pointer" для эксплуатации уязвимости tboot:`sudo insmod lostpointer/lostpointer.kodmesg`
insmod - команда для вставки модуля в ядро;
dmesg - команда для вывода буфера сообщений ядра в стандартный поток вывода (stdout) (по умолчанию на экран).
Как видим, модуль отображает информацию о tBoot и тело шеллкода. Теперь перейдем в предыдущую ос, и проверим изменения в PCR.
Как видим, первые два символа изменились (PCR 17-19), и при сравнивании с помощью git diff получаем следующее:
Система malicious стала иметь теже PCR как и обычная система. Через редактор vi сравним оба файла:
`vi -o normal_pcrs.txt sleep_malicious_pcrs.txt`
 | https://habr.com/ru/post/680360/ | null | ru | null |
# Когда наступит WEB 3.0?
Всем привет, сегодня я хотел бы подискутировать на примере "очередной революции" в так называемом WEB 3.0 от команды TON, как развивается веб и в целом куда мы идем, статья не претендует на истину, все ниже изложенное является личным мнением автора.
### Что такое WEB 3.0?
Если коротко, это следующая версия после WEB 2.0 ;) в которой мы якобы находимся сейчас. Первые дискуссии о том, какой WEB 3.0 можно [встретить на Хабре](https://habr.com/ru/post/21838/) еще в 2008 году, а это на секундочку 15 лет назад! Статья не получила положительного отклика, как и комментарии носили скорее саркастический характер. Давайте попробуем провести ретроспективу с видения того времени и проанализировать что изменилось в вебе за хотябы последние 15 лет и как люди видели этот самый WEB 3.0
На примере статьи из 2008, Аарон Маркус приводил свое видение WEB 3.0
> «Я понимаю *веб 3.0 как абсолютное распространение семантического веба в интернете, когда информация в Глобальной сети не просто аккумулируется, но и понимается, осмысливается»*
>
>
Что конкретного подразумевал Аарон Маркус под семантическим вебом он не уточнял, впрочем это же просто мечты о будущем. Но в целом под семантикой подразумевалось использование HTML тегов в соответствии с их семантическим назначением от [WHATWG](https://whatwg.org/), а также поддержкой атрибутов [ARIA](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA) и [OpenGraph](https://ogp.me/). Но поддержка ARIA на сайте в целом не делала из вашей веб страницы accessible rich internet application, как и поддержка opengraph не открывала перед вами все прелести WEB 3.0.
Оглядываясь на этот функционал и идеи семантики в спецификациях, можно увидеть что они не очень сильно изменились, но сама поддержка веб-разработчиками и сообществом сильно продвинулась вперед. Поддержка дополнительных атрибутов и семантики в вебе позволила поисковым ботам лучше понимать, что описано на странице, мессенджерам делать красивые превью ссылок, ленты в социальных сетях тоже имеют превью на основе opengraph, также вы можете получить дополнительные сниппеты и подсказки в поисковой выдаче Яндекса и Гугла на основе этой разметки, что сделает ваше предложение более доступным в плане возможности пользователю сразу вам позвонить минуя сайт или перейти в нужный раздел сайта прямо из результата поиска, но все это в целом не тянет на революцию и признание WEB 3.0 уже наступившим. В конце концов статья из с Хабра из 2008 опубликована в марте, а официальная дата первоначального релиза HTML5 22 января 2008 года. Т.е. говорить о наступлении WEB 3.0 15 лет назад было еще рано. Я например, в тот период только начинал свою карьеру на fl.ru и делал первые дизайны сайтов с последующей натяжкой их на wordpess\joomla и активно изучал тогда еще набирающий популярность jQuery и смерть IE6 тогда еще была в очень далеких мечтах. В будущем мы даже следили за [анонсом даты](https://habr.com/ru/post/85446/) смерти этого браузера и это было важным этапом на пути к отказу от огромного слоя legacy кода. Честно признаться, я желал смерти всех версий IE, но тогда еще было слишком рано, мечты сбылись только в 2022 году, когда Microsoft объявила о закрытии Internet Explorer 15 июня 2022 года. С этой даты браузер официально перестал работать на всех современных версиях Windows 10. С этого момента можно было официально уделять поддержке браузера минимум внимания. А в сентябре 2008 года состоялся первый релиз Google Chrome и в паре с релизом HTML5 этот год смело можно считать отправной точкой на пути к WEB 3.0 также в 2008 тогда еще никому неизвестный Satoshi Nakamoto презентовал технологию blockchain за развитием которой с интересом наблюдает весь мир до сих пор.
Конечно мысли о семантическом вебе были далеко не единственными на этот промежуток времени, были еще идеи всего веба в 3D - что в 2023 году можно было считать примером метавселенных. Которые вроде бы есть, но их практическое применение остается под вопросом, кроме демонстрации собственных NFT и вкладывания миллионов долларов в сомнительный цифровой контент, кажется что делать там больше и нечего. На данный момент можно смело сказать, что идея глобальной MMO c элементами RPG под названием метавселенные не работают, например - [ЕС провел вечеринку в метавселенной за €400 тыс](https://news.rambler.ru/tech/49798261-es-provel-vecherinku-v-metavselennoy-za-400-tys-na-kotoruyu-prishlo-shest-chelovek/)., на которую пришло шесть человек. Переименование запрещенных ныне в РФ фейсбука в мета - не сделало из них метавселенную. Онлайн в каком-нибудь GTA\WoW пока все еще выше, чем в любой метавслененной. Пока даже в Sims сыграло больше человек) но это все только "пока".
Тем не менее веб-разработчики и сообщество, учились работать все с более крупными объемами данных. Это привело к тому, что на первое место стали выходить агрегаторы контента, а не их источники (Маркеты у магазинов, почти монополия на видео у YouTube, даже хабр пример, как сообщество объеденилось в ресурс по интересам, в место множества standalone блогов). Standalone self hosted интернет представительство стало сложнее, на фоне интернет сервисов с собственными отделами разработки, конкурировать в одиночку на какой-нибудь CMS простым магазинам стало очень сложно, также и блогерам ведущим свои блоги на собственных сайтах например на Wordpress стало сложнее наращивать аудиторию и противостоять соц сетям, где уже собралась эта аудитория, а также поддерживать нужный уровень функциональности и "реактивности" контента.
На этапе освоения больших данных мы получили такие классные инструменты как [Click House](https://clickhouse.com/docs/ru/), [tarantool](https://www.tarantool.io/ru/), которые актуальны до сих пор, сообщество училось агрегировать все большие объемы данных . Многие кампании разрабатывающие собственные продукты для веба, начали использовать БД как SaaS и не только БД, но и часть вычислений стало нормальным использовать как сервис в "облаке". Еще отличный пример глобализации функциональности, это аналитика Google Analyltics\Яндекс метрика, вырастить такую функциональность собственными силами разработки, стало невозможным для маленьких кампаний. Следующим шагом освоения биг даты будут тренировки нейросетей на всех собранных данных, где уже не человек, а сеть будет делать выводы и сочинять на основе данных рефераты\картинки\кусочки кода.
Казалось бы мы уже прошли огромный путь с 2008 и в 2021 году уже можно было прочитать [статью про WEB 4.0](https://vc.ru/u/739868-andrey-nikolaev/238951-evolyuciya-do-web-4-0-kratkaya-istoriya-razvitiya-internet-tehnologiy-web-1-0-web-2-0-web-3-0-preimushchestva-web-4-0)! И даже якобы описана краткая история развития. Но к сожалению, статья носит больше популистический, чем технический характер. Итак, что же нам обещали в WEB 4.0, возьмем основные тезисы
> *Web 4.0 - это симбиотическое взаимодействие между человеком и машиной. Граница между человеком и машиной размыта.*
>
>
Для меня это уже звучит как фантастика, простите, за душноту, но кажется авторы не до конца понимают значение симбиотических отношений. Банально обратимся к википедии
**Симбио́з** ([греч.](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B5%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) συμ-βίωσις — «совместная жизнь»[[1]](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%B1%D0%B8%D0%BE%D0%B7#cite_note-1) от συμ- — совместно + βίος — жизнь) — это близкое сообщество живых организмов, принадлежащих к разным [**биологическим видам**](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B2%D0%B8%D0%B4)**.**
На мой взгляд наши отношения со смартфоном или ноутбуком с очень большой натяжкой можно назвать симбиотическими отношениями и телефон явно не тянет на биологический вид. Граница между мной и телефоном все еще находится в рамках потребительских отношений, устройства ввода никак не изменились, как живой организм телефон себя не проявляет, какой-то эмоциональной привязанности к своему Galaxy a04 я не ощущаю, телефон как телефон, последние лет 10 я даже не обращаю внимания на дизайн, после первого айфона все стало почти одинаковым.Рассмотрим коротко еще пару тезисов из статьи про WEB 4.0 2021 года
> *Интернет - это Web-ОС. Информация может передаваться из каждой точки мира.*
>
>
Web-ОС в 2023 году у меня стойко ассоциируется с историей Google про Chrome OS, а сам гугл поиск выдает в первых строчках информацию про ОС для телевизоров LG. Сам интернет это изначально история про обмен данными по всему миру, непонятно как это оказалось в преимуществах WEB 4.0 Только теперь такие тезисы не похожи на мечты из 2008, больше похоже на новые песни о старом. Рассмотрим следующий тезис
> *Интернет коммуницирует с пользователями так же, как люди общаются между собой.*
>
>
Как и в одном из предыдущих тезисов, интернет рассматривается как некое существо, которое способно коммуницировать (да что там, общаться так же как человек с вами) Но в целом сам интернет не имеет сознания и интереса общаться с вами. В конце концов пока даже нельзя позвонить в интернет, технически эта фраза звучит абсурдно, чей номер вы бы добавили в контакты с именем интернет?
В каком-то смысле, нейросети могли бы стать тем самым "существом" с которым мы пытаемся общаться, как например голосовые аcистенты типа Алисы, google assistant, Siri, Alexa. Но голосовые помощники не могут поддержать длительной беседы, сохранить контекст между беседами, скорее это все еще продвинутый голосовой ввод команд в интернет, с примитивными запросами типа: включить музыку, узнать погоду, прослушать новости. Один из самых тормозящих факторов на мой взгляд в современном, это дележка права на контент, все эти патентные тролли и хранители авторского права. Люди получающие деньги за авторские труды уже умерших людей, конечно множество контента мы можем найти бесплатно при наличии платных аналогов или поднять пиратский флаг, но это лишь затрудняет создавать и потреблять качественный контент. С другой стороны мысли про open source и free software во всем мире для всех являются утопией и не рассматриваются сообществом всерьез. Подводя итог, никогда не будет единого сервиса с доступным авторским контентом. Рынок поделен на лейблы, корпорации, издательства, студии и т.п. и с этим нам предстоит жить. Причем сами студии тоже с удовольствием делят свой контент даже внутри самих себя, искусственно делая его недоступным, например релиз игр для ПК и игровых приставок, часто ААА проекты (например Uncharted) издаются эксклюзивно для игровой приставки и уже через пару лет, высосав все соки из приставки, игроки ПК уже получают тот же контент, который в целом-то уже не особо актуален.
К этому моменту может показаться, что никакого WEB 3.0, а уж тем более WEB 4.0 не существует и никогда не наступит, но давайте копать дальше и попытаемся проникнуться следующими популистскими тезисами
> *Интернет прозрачен, все действия прослеживаются.*
>
>
Еще одно якобы преимущество. Технология в которой все прозрачно и действия прослеживаются по праву можно считать blockchain, но это не является преимуществом сети как таковым, скорее это особенность сети. Ее прозрачность не делает ее супер революционной или защищенной, доказательством этому является то, что 80% всех токенов это просто скам, еще часть является просто фантокенами. Все прозрачно, все прослеживается) но для мира крипты это не панацея, криптопузыри надуваются и лопаются каждый год, перебор хешей под видом майнинга становится популярной забавой у криптоэнтузиастов и будоражит умы балконных майнеров о богатствах. С другой стороны открытости и прозрачности, стоит человеческое отношение к частной жизни, далеко не все пользователи хотели бы быть открытыми и прозрачными в сети, и как минимум их право на частную жизнь нужно признавать. Популярность таких инструментов как AdBlock и акцент на таких функциях как "режим инкогнито" в браузерах говорит о востребованности данной функции.
Кажется с популизмом мы закончили и на этом можно было бы остановится и продолжить наблюдать за развитием технологий и формированием видения WEB 3.0\4.0\5.0 у интернет сообщества, но давайте рассмотрим еще одно техническое видение WEB 3.0 тем более, что авторы утверждают, что сами сделали целый отдельный WEB 3.0 интернет, а для Хабра эта революция как-то прошла слишком тихо, давайте попробуем разобраться, какой же WEB 3.0 изобрели разработчики [TON](https://ton.org/en/roadmap). Согласно их дорожной карте и последнему сообщению в телеграм канале
> *Отметим, что в соответствии с дорожной картой (*[*https://ton.org/en/roadmap*](https://ton.org/en/roadmap)*) проекта в ушедшем году были выпущены все ключевые модули Web3-интернета, создаваемого командой TON.*
>
>
Разработчики подготовили нам целый web3 интернет. Начиная с 2021 сделали свой блокчейн, DNS, payments, sites, storage. И если очень коротко говорить, то сеть позволяет захостить в себе файлы с использованием p2p технологии (не похоже на революцию WEB 3.0) p2p сети уже прошли свой рассвет во времена DC++ и живы до сих пор. Cобственный DNS (тоже ничего нового, только в сети TON это больше похоже на сокращатель ссылок и работает не только для веб адресов) тоже ничего нового, может обращение к сайтам выглядит как-то революционно? Нет, вот
`ton://domain/?=&=..`
Это выдержка из доки, лично я вижу этой строке кода ровно 0 инноваций, а передача параметров мне напоминает HTTP GET query params. Итого на серьезных технических щах нам рассказывают про новый WEB 3.0, а в программе по популяризации этого добра среди разработчиков призывают уже сейчас начинать писать что-то абсолютно новое! Например аналог DropBox. Ага в 2023 на сайте TON ищут разрабов, кто попишет аналоги для их WEB 3.0 интернета. Что касается каких-то новшеств уровня HTML5 или общих мировых стандартов семантики - такого в TON вы не найдете. В каком-то смысле разработчики React больше повлияли на развитие и видение веба, чем создатели целого WEB 3.0 со своим storage и payments. Ну как чувствуете запах инноваций и эры WEB 3.0?
### Каким я вижу WEB 3.0?
Для меня, как для веб-разработчика с более чем 15 летним стажем, WEB 3.0 это ожидание семантики от интернета вещей, т.е. взаимодействие с интернетом не только через просмотр браузера, но и через физические кнопки\датчики\выключатели\чайники\реле и другие электроприборы, когда грубо говоря производители придут к поддержке общей swagger спеки на уровне API. Сейчас, умный дом с умными устройствами очень тяжело действительно сделать умным не применяя паяльник. На рынке десяток устройств и своих приложений, которые особо не дружат между собой, есть конечно Open Source решения типа home assistant, но это больше история про то как сквозь скрипты\прошивки\наличие очень специфичных знаний, настроить себе простые показатели температуры, управления лампами и т.п., сейчас это все конечно доступно, но без единого стандарта.
Недавно я разочаровался отсутствием поддержки RTSP в xiaomi IP камерах и мои идеи про просмотр всех камер на участке в одной вкладке браузера, пошли коту под хвост. Так вот интернет камеры, как представители интернета вещей не дружат между собой, либо xmEye, либо mihome, либо сразу выбирай и собирай все например через RTSP. Cвой жесткий диск у xiaomi нельзя подключить, только облако за денежку, как и функционал по записи трансляции самостоятельно, умышленно обрезан. Т.е. вы интегрируете в интернет устройства не на столько, сколько позволяют технологии, а ровно на столько сколько считает необходимым производитель.
Хочу чтобы пользователи могли действительно иметь какие-то стандартные storage пусть даже и self hosted, сейчас тот же гугл не дает возможности расширить их облако за счет собственных дисков, а теперь еще и оплатить их место не дает из-за санкций. Другие "облака" тоже не хотят, чтобы я свои диски к их плану мог добавлять, такое можно только на уровне VDS, но собственный настроенный сервер с локальным NAS уже нельзя назвать готовой услугой скачанной с маркета. Итого, интеграция устройств в интернет сейчас стоит дорого, умышленно обрезана производителями и не имеет общих стандартов, что приводит к неполноценной интеграции у конечного пользователя и не оставляет ему шансов на полноценную экосистему интернета вещей. Но все равно остается надежда, что веб и окружающие нас устройства будут больше стандартизироваться и интегрироваться между собой без помощи паяльника и прошивок.
Отдельно хочу отметить успехи в освоении и классификации больших данных на примере Midjourney и ChatGPT, поразительные инструменты, возможности которых одновременно впечатляют и рождают новые вопросы, на которые пока непонятно, кто и когда даст ответы. Речь идет о отделении истинности суждений ChatGPT от лжи, а также первые попытки заменять художников нейросетью и дискуссии о том, почему woman и beautiful woman для Midjourney одно и тоже и что надо рисовать по запросу hot dog). Все это происходит в наши дни и крайне интересно наблюдать за этой эволюцией, может быть именно нейросети станут настоящими хедлайнерами эпохи WEB 3.0? В конце концов иллюстрация к этой статье нарисована нейросетью и возможно будущее уже здесь?)
В какой эпохе сейчас находимся мы? Приглашаю в комментарии :-) | https://habr.com/ru/post/710344/ | null | ru | null |
# Производительность PHP: планируем, профилируем, оптимизируем
Привет, Хабр! Два года назад мы [писали](https://habr.com/company/badoo/blog/279047/) о том, как перешли на PHP 7.0 и сэкономили миллион долларов. На нашем профиле нагрузки новая версия оказалась в два раза более эффективной по использованию CPU: ту нагрузку, которую раньше у нас обслуживали ~600 серверов, после перехода начали обслуживать ~300. В результате на протяжении двух лет у нас был запас мощностей.
Но Badoo растёт. Количество активных пользователей постоянно увеличивается. Мы совершенствуемся и развиваем нашу функциональность, благодаря чему пользователи проводят в приложении всё больше времени. А это, в свою очередь, отражается на количестве запросов, которое за два года увеличилось в 2—2,5 раза.
Мы оказались в ситуации, когда двукратный выигрыш в производительности нивелировался более чем двукратным ростом запросов, и мы опять стали приближаться к пределам нашего кластера. В ядре PHP снова ожидаются полезные [оптимизации](https://habr.com/company/badoo/blog/415359/) (JIT, предзагрузка), но они запланированы только на PHP 7.4, а эта версия выйдет не раньше, чем через год. Поэтому трюк с переходом сейчас повторить не удастся — нужно оптимизировать сам код приложения.
Под катом я расскажу, как мы подходим к таким задачам, какими пользуемся инструментами, и приведу примеры оптимизаций, идей и подходов, которые мы применяем и которые помогли нам в своё время.
Зачем оптимизировать
====================
Самый простой и очевидный способ решить проблему производительности — добавить железа. Если ваш код выполняется на одном сервере, то добавление ещё одного удвоит производительность вашего кластера. Переводя эти затраты на рабочее время разработчика, мы задаёмся вопросом: сможет ли он за это время получить двукратный рост производительности за счёт оптимизаций? Возможно, да, а, возможно, нет: зависит от того, насколько оптимально уже работает система и насколько хорош разработчик. С другой стороны, купленный сервер останется в собственности компании, а потраченное время уже не вернёшь.
Получается, что на небольших объёмах правильным решением чаще будет добавление железа.
Но возьмём нашу ситуацию. Сейчас, после того как выигрыш от перехода на PHP 7.0 был нивелирован ростом активности и количества пользователей, у нас снова 600 серверов обслуживают запросы к PHP-приложению. Для того чтобы увеличить мощность в полтора раза, нам нужно добавить 300 серверов.
Возьмём для расчёта среднюю стоимость сервера — 4000 долларов. 300 \* 4000 = 1 200 000 долларов — стоимость увеличения мощности в полтора раза.
То есть в наших условиях мы можем вложить значительное количество рабочего времени в оптимизацию системы, и это всё равно будет более выгодно, чем покупка железа.
Capacity planning
=================
Прежде чем что-то предпринимать, важно понять, есть ли проблема. Если её нет, то стоит попытаться предсказать, когда она может появиться. Этот процесс называют capacity planning.
Железобетонным показателем наличия проблем с производительностью является время ответа. Ведь, по сути, не имеет значения, загружен CPU (или другие ресурсы) на 6% или 146%: если клиент получает сервис необходимого качества за удовлетворительное время, значит, всё работает хорошо.
Недостаток ориентации на время ответа заключается в том, что обычно оно начинает увеличиваться, только когда проблема уже появилась. Если же её ещё нет, то предсказать её появление сложно. Кроме того, время ответа отражает результаты влияния всех факторов (тормозящие сервисы, сеть, диски и т. д.) и не даёт понимания причин проблем.
В нашем случае узким местом обычно является CPU, поэтому при планировании размера и производительности кластеров мы в первую очередь обращаем внимание на метрики, связанные с его использованием. Мы собираем CPU usage со всех наших машин и строим графики со средним значением, медианой, 75-м и 95-м перцентилем:
*Загрузка CPU машин кластера в процентах: среднее значение, медиана, перцентили*
В наших кластерах сотни машин, которые туда добавлялись в течение многих лет. Они разные по конфигурации и производительности (кластер не гомогенный). Наш балансировщик учитывает это ([статья](https://habr.com/company/oleg-bunin/blog/310366/) и [видео](https://tech.badoo.com/ru/presentation/135/kak-my-sdelali-rovnuyu-balansirovku/)) и нагружает машины в соответствии с их возможностями. Для того чтобы контролировать этот процесс, у нас также есть график максимально и минимально загруженных машин.
*Наиболее и наименее загруженные машины кластера*
Если посмотреть на эти графики (или просто на вывод команды top) и увидеть загрузку CPU 50%, то можно подумать, что у нас ещё есть запас на двукратный рост нагрузки. Но на самом деле обычно это не так. И вот почему.
Hyper-threading
===============
Представим одно ядро без гипертрединга. Нагрузим его одним CPU-bound-потоком. Увидим в топе загрузку на 100%.
Теперь включим на этом ядре гипертрединг и нагрузим его точно так же. В топе мы увидим уже два логических ядра, а общая загрузка будет 50% (обычно на одном 0%, а на другом — 100%).
*Утилизация CPU: данные top и то, что происходит на самом деле*
Как будто процессор загружен только на 50%. Но физически дополнительного свободного ядра не появилось. Гипертрединг позволяет *в некоторых случаях* выполнять на одном физическом ядре больше одного процесса одновременно. Но это далеко не удвоение производительности в типичных ситуациях, хотя на графике CPU usage это и выглядит как ещё половина ресурсов: от 50% до 100%.
Это значит, что после 50% CPU usage при включённом гипертрединге будет расти не так же, как он рос до этого.
Я написал вот такой код для демонстрации (это некий синтетический случай, в реальности результаты будут отличаться):
**Код скрипта**
```
php
$concurrency = $_SERVER['argv'][1] ?? 1;
$hashes = 100000000;
$chunkSize = intval($hashes / $concurrency);
$t1 = microtime(true);
$children = array();
for ($i = 0; $i < $concurrency; $i++) {
$pid = pcntl_fork();
if (0 === $pid) {
$first = $i * $chunkSize;
$last = ($i + 1) * $chunkSize - 1;
for ($j = $first; $j < $last; $j++) {
$dummy = md5($j);
}
printf("[%d]: %d hashes in %0.4f sec\n", $i, $last - $first, microtime(true) - $t1);
exit;
} else {
$children[$pid] = 1;
}
}
while (count($children) 0) {
$pid = pcntl_waitpid(-1, $status);
if ($pid > 0) {
unset($children[$pid]);
} else {
exit("Got a error pid=$pid");
}
}
```
У меня на ноутбуке два физических ядра. Запустим этот код с разными входными данными, чтобы измерить производительность его работы с разным количеством параллельных процессов C.
**Результаты измерений**
Построим график по результатам запусков:
*Производительность скрипта в зависимости от количество параллельных процессов*
На что можно обратить внимание:
* C = 1 и C = 2 предсказуемо одинаковы для HT=on и HT=off, производительность увеличивается в два раза при добавлении физического ядра;
* на С = 3 становятся заметны преимущества от HT: для HT=on мы смогли получить дополнительную производительность, притом что для HT=off с C=3 и дальше она начинает предсказуемо медленно уменьшаться;
* на С = 4 мы видим все преимущества от HT; мы смогли выжать дополнительно ещё 30% производительности, но в сравнении с С=2 в это время CPU usage у нас увеличился с 50% до 100%.
Итого, видя в топе 50% загрузки CPU, при выполнении этого скрипта мы получаем 8,065 Mhash/sec, а при 100% — 10,511 Mhash/sec. Это значит, что на отметке 50% топа мы получаем 8,065/10,511 ~ 77% максимальной производительности системы и на самом деле в запасе у нас остаётся около 100% — 77% = 23%, а не 50%, как это могло показаться.
Этот факт необходимо учитывать при планировании.
*Утилизация CPU для демоскрипта: данные top и то, что происходит на самом деле*
Неравномерность трафика
=======================
Помимо гипертрединга, планирование усложняет ещё и неравномерность трафика в зависимости от времени суток, дня недели, сезона и другой периодичности. Для нас, например, пиковым является вечер воскресенья.
*Количество запросов в секунду, пик вечером воскресенья*
Не всегда количество запросов меняется очевидным образом. Например, пользователи могут как-то взаимодействовать с другими пользователями: активность одних может генерировать пуши/email’ы другим и таким образом вовлекать их в процесс. К этому добавляются промокампании, которые увеличивают трафик и к которым тоже надо быть готовыми.
Всё это также важно учитывать при планировании: например, строить тренд по пиковым дням и держать в голове возможную нелинейность роста пиков.
Профилирование и инструменты измерения
======================================
Предположим, мы выяснили, что существуют проблемы с производительностью, поняли, что виной тому не базы данных/сервисы/прочее, и всё-таки решили оптимизировать код. Для этого в первую очередь нам нужен профайлер или какие-то инструменты, позволяющие находить узкие места и впоследствии видеть результаты наших оптимизаций.
К сожалению, для PHP на сегодняшний день нет хорошего универсального инструмента.
perf
----
[perf](https://en.wikipedia.org/wiki/Perf_(Linux)) — это инструмент профилирования, встроенный в ядро Linux. Является [семплирующим](https://en.wikipedia.org/wiki/Profiling_(computer_programming)#Statistical_profilers) профайлером, который запускается отдельным процессом, поэтому не добавляет напрямую оверхед к профилируемой программе. Косвенно добавленный оверхед равномерно «размазывается», поэтому не искажает измерения.
При всех своих плюсах perf способен работать только со скомпилированным кодом и с JIT и не умеет работать с кодом, выполняющимся «под виртуальной машиной». Поэтому сам PHP-код профилировать в нём не получится, зато отлично видно, как работает PHP внутри, включая различные PHP-расширения, и сколько на это тратится ресурсов.
Мы, например, при помощи perf нашли несколько узких мест, в том числе место со сжатием, о котором я расскажу ниже.
Пример:
`perf record --call-graph dwarf,65528 -F 99 -p $(pgrep php-cgi | paste -sd "," -) -- sleep 20
perf report`
(если процесс и perf выполняются под разными пользователями, то perf нужно запускать из-под sudo).
*Пример вывода perf report для PHP-FPM*
XHProf и XHProf aggregator
--------------------------
XHProf — расширение для PHP, которое расставляет таймеры вокруг всех вызовов функций/методов, а также содержит инструменты для визуализации полученных таким образом результатов. В отличие от perf, он позволяет оперировать терминами PHP-кода (при этом что происходит в расширениях не увидеть).
К недостаткам можно отнести две вещи:
* все измерения собираются в рамках одного запроса, поэтому не дают информацию о картине в целом;
* оверхед хоть и [не такой большой](https://ruhighload.com/%D0%9F%D1%80%D0%BE%D1%84%D0%B8%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5+php+%D1%81+xhprof), как, например, при использовании Xdebug, но он есть, и в некоторых случаях результаты сильно искажаются (чем чаще вызывается какая-либо функция и чем она проще, тем сильнее искажение).
Вот пример, иллюстрирующий последний пункт:
```
function child1() {
return 1;
}
function child2() {
return 2;
}
function parent1() {
child1();
child2();
return;
}
for ($i = 0; $i < 1000000; $i++) {
parent1();
}
```
*Вывод XHProf для демоскрипта: parent1 на порядки превышает сумму child1 и child2*
Видно, что parent1() выполнялась в ~500 раз дольше, чем child1() + child2(), хотя в действительности эти цифры должны быть примерно равны, как равны main() и parent1().
Если с последним недостатком сложно бороться, то для борьбы с первым мы сделали надстройку над XHProf, которая агрегирует профайлы разных реквестов и визуализирует агрегированные данные.
Помимо XHProf, есть множество других менее известных профайлеров, работающих по похожему принципу. Они обладают схожими преимуществами и недостатками.
Pinba
-----
[Pinba](https://github.com/badoo/pinba2) позволяет [мониторить производительность](https://habr.com/company/badoo/blog/319934/) в разрезе скриптов (экшенов) и по предварительно расставленным таймерам. Все измерения в разрезе скриптов делаются из коробки, для этого никаких дополнительных действий не требуется. По каждому скрипту и таймеру выполняется [getrusage](http://man7.org/linux/man-pages/man2/getrusage.2.html), поэтому нам точно известно, сколько процессорного времени было потрачено на тот или иной участок кода (в отличие от семплирующих профайлеров, где это время может оказаться временем ожидания сети, диска и т. д.). Pinba отлично подходит для сохранения исторических данных и получения картины как в целом, так и в рамках конкретных типов запросов.
*Общий rusage всех скриптов, полученный из Pinba*
К недостаткам можно отнести то, что таймеры, которые профилируют конкретные участки кода, а не скрипты целиком, необходимо расставлять в коде заранее, а также наличие оверхеда, который (как в XHProf) может искажать данные.
phpspy
------
[phpspy](https://github.com/adsr/phpspy) — относительно новый проект (первый коммит на GitHub был полгода назад), который выглядит перспективным, поэтому мы за ним пристально следим.
С точки зрения пользователя phpspy похож на perf: запускается параллельный процесс, который периодически копирует участки памяти PHP-процесса, разбирает их и получает оттуда стек-трейсы и другие данные. Это делается достаточно специфичным способом. Для того чтобы минимизировать оверхед, phpspy не останавливает PHP-процесс и копирует память прямо во время его работы. Это приводит к тому, что профайлер может получить неконсистентное состояние, стек-трейсы могут быть битыми. Но phpspy умеет обнаруживать это и отбрасывает такие данные.
В перспективе при помощи этого инструмента можно будет собирать как данные по картине в целом, так и профайлы конкретных типов запросов.
Сравнительная таблица
---------------------
Чтобы структурировать различия между инструментами, сделаем сводную таблицу:
*Сравнение основных возможностей профайлеров*
*[Flame Graphs](http://www.brendangregg.com/flamegraphs.html)*
Оптимизации и подходы
=====================
С помощью этих инструментов мы постоянно следим за производительностью и использованием наших ресурсов. Когда они используются неоправданно или мы приближаемся к порогу (для CPU мы эмпирически выбрали значение в 55%, чтобы иметь запас времени в случае роста), как я писал выше, одним из вариантов решения проблемы является оптимизация.
Хорошо, если оптимизация уже сделана кем-то другим, как это было в случае с PHP 7.0, когда эта версия оказалась гораздо более производительной, чем предыдущие. Мы вообще стараемся использовать современные технологии и инструменты, в том числе своевременно обновляемся на свежие версии PHP. Согласно [публичным](https://www.phoronix.com/scan.php?page=news_item&px=PHP-7.2-Final-Benchmark) [бенчмаркам](https://kinsta.com/blog/php-7-hhvm-benchmarks/), PHP 7.2 на 5—12% быстрее PHP 7.1. Но нам этот переход, увы, дал значительно меньше.
За всё время мы реализовали огромное количество оптимизаций. К сожалению, большая их часть, сильно связана с нашей бизнес-логикой. Я расскажу о тех, которые могут быть актуальны не только для нас, либо идеи и подходы из которых можно использовать за пределами нашего кода.
Сжатие zlib => zstd
-------------------
Мы используем компрессию для больших мемкеш-ключей. Это позволяет нам тратить в три—четыре раза меньше памяти на хранение за счёт дополнительных расходов CPU на сжатие/распаковку. Мы использовали для этого zlib (наше расширение для работы с мемкешем отличается от тех, которые поставляются с PHP, но в официальных [тоже](http://php.net/manual/en/memcache.requirements.php) [используется](http://php.net/manual/en/memcached.configuration.php#ini.memcached.compression-type) zlib).
В perf на продакшене было примерно так:
`+ 4.03% 0.22% php-cgi libz.so.1.2.11 [.] inflate
+ 3.38% 0.00% php-cgi libz.so.1.2.11 [.] deflate`
7—8% времени уходило на компрессию/декомпрессию.
Мы решили протестировать разные уровни и алгоритмы сжатия. Оказалось, что zstd работает на наших данных почти в десять раз быстрее, проигрывая по месту в ~1,1 раза. Достаточно простое изменение алгоритма сэкономило нам ~7,5% CPU (это, напомню, на наших объёмах равнозначно ~45 серверам).
Важно понимать, что соотношение эффективности работы разных алгоритмов сжатия может сильно отличаться в зависимости от входных данных. Есть различные [сравнения](https://quixdb.github.io/squash-benchmark/), но точнее всего это можно оценить только на реальных примерах.
IS\_ARRAY\_IMMUTABLE как хранилище редко изменяемых данных
----------------------------------------------------------
Работая с реальными задачами, приходится иметь дело с такими данными, которые нужны часто и при этом редко меняются и имеют ограниченный размер. У нас подобных данных много, хороший пример — конфигурация [сплит-тестов](https://habr.com/company/badoo/blog/278089/). Мы проверяем, попадает ли пользователь под условия того или иного теста, и в зависимости от этого показываем ему экспериментальную или обычную функциональность (это происходит практически во время каждого запроса). В других проектах таким примером могут быть конфиги и разнообразные справочники: страны, города, языки, категории, бренды и т. п.
Так как такие данные запрашиваются часто, их получение может создавать ощутимую дополнительную нагрузку как на само приложение, так и на сервис, в котором эти данные хранятся. Последнюю проблему можно решить, например, с помощью APCu, которое в качестве хранилища использует память той же машины, где запущен PHP-FPM. Но даже в этом случае:
* будут затраты на сериализацию/десериализацию;
* нужно как-то инвалидировать данные при изменении;
* есть некоторый оверхед по сравнению с доступом к просто переменной в PHP.
В PHP 7.0 появилась оптимизация [IS\_ARRAY\_IMMUTABLE](https://phpinternals.net/docs/is_array_immutable). Если объявить массив, все элементы которого известны на момент компиляции, то он будет обработан и помещён в память OPCache единожды, PHP-FPM-воркеры будут ссылаться на эту общую память, не расходуя свою до попытки изменения. Из этого также следует, что include такого массива будет занимать константное время вне зависимости от размера (обычно ~1 микросекунду).
Для сравнения: пример времени получения массива из 10 000 элементов через include и apcu\_fetch:
```
$t0 = microtime(true);
$a = include 'test-incl-1.php';
$t1 = microtime(true);
printf("include (%d): %d microsec\n", count($a), ($t1-$t0) * 1e6);
$t0 = microtime(true);
$a = apcu_fetch('a');
$t1 = microtime(true);
printf("apcu_fetch (%d): %d microsec\n", count($a), ($t1-$t0) * 1e6);
//include (10000): 1 microsec
//apcu_fetch (10000): 792 microsec
```
Проверить, была ли применена эта оптимизация, можно очень просто, если посмотреть на сгенерированные опкоды:
```
$ cat immutable.php
php
return [
'key1' = 'val1',
'key2' => 'val2',
'key3' => 'val3',
];
$ cat mutable.php
php
return [
'key1' = \SomeClass::CONST_1,
'key2' => 'val2',
'key3' => 'val3',
];
$ php -d opcache.enable=1 -d opcache.enable_cli=1 -d opcache.opt_debug_level=0x20000 immutable.php
$_main: ; (lines=1, args=0, vars=0, tmps=0)
; (after optimizer)
; /home/ubuntu/immutable.php:1-8
L0 (4): RETURN array(...)
$ php -d opcache.enable_cli=1 -d opcache.opt_debug_level=0x20000 mutable.php
$_main: ; (lines=5, args=0, vars=0, tmps=2)
; (after optimizer)
; /home/ubuntu/mutable.php:1-8
L0 (4): T1 = FETCH_CLASS_CONSTANT string("SomeClass") string("CONST_1")
L1 (4): T0 = INIT_ARRAY 3 T1 string("key1")
L2 (5): T0 = ADD_ARRAY_ELEMENT string("val2") string("key2")
L3 (6): T0 = ADD_ARRAY_ELEMENT string("val3") string("key3")
L4 (6): RETURN T0
```
В первом случае видно, что в файле есть единственный опкод — возврат готового массива. Во втором случае происходит его поэлементное формирование каждый раз при исполнении этого файла.
Таким образом, можно генерировать структуры в виде, не требующем дальнейшего преобразования в рантайме. Например, вместо того чтобы каждый раз для автолоада разбирать названия класса по знакам «\_» и «\», можно предварительно сгенерировать карту соответствий «Класс => Путь». В этом случае функция преобразования будет сводиться к одному обращению к хеш-таблице. Такую оптимизацию делает Composer, если включить опцию [optimize-autoloader](https://getcomposer.org/doc/articles/autoloader-optimization.md#optimization-level-1-class-map-generation).
Для инвалидации таких данных специально ничего делать не нужно — PHP сам перекомпилирует файл при изменении так же, как это делается при обычном деплое кода. Единственный недостаток, о котором нужно не забывать: если файл будет очень большим, то первый запрос после его изменения вызовет перекомпиляцию, которая может занимать ощутимое время.
Производительность include/require
----------------------------------
В отличие от примера со статическим массивом, подключение файлов с объявлениями классов и функций происходит не так быстро. Несмотря на наличие OPCache, движок PHP должен скопировать их в память процесса, рекурсивно подключив зависимости, что в итоге может занимать сотни микросекунд или даже миллисекунды на файл.
Если создать новый пустой проект на [Symfony 4.1](https://symfony.com/download) и поставить [get\_included\_files()](http://php.net/manual/en/function.get-included-files.php) первой строкой в экшене, можно увидеть, что уже подключено 310 файлов. В реальном проекте это число может доходить до тысяч за запрос. Стоит обратить внимание на следующие вещи.
**Отсутствие автолоадинга функций**
Есть [Function Autoloading RFC](https://wiki.php.net/rfc/function_autoloading), но никакого его развития не видно уже несколько лет. Поэтому если зависимость в Composer определяет функции вне класса и эти функции должны быть доступны пользователю, то это делается путём [обязательного подключения](https://getcomposer.org/doc/04-schema.md#files) файла с этими функциями на каждую инициализацию автолоадера.
Например, удалив из composer.json одну из зависимостей, объявляющую множество функций и легко заменяемую сотней строк кода, мы выиграли пару процентов CPU.
**Автолоадер вызывается чаще, чем может показаться**
Для демонстрации идеи создадим такой файл с классом:
```
php
class A extends B implements C
{
use D;
const AC1 = \E::E1;
const AC2 = \F::F1;
private static $as3 = \G::G1;
private static $as4 = \H::H1;
private $a5 = \I::I1;
private $a6 = \J::J1;
public function __construct(\K $k = null) {}
public static function asf1(\L $l = null) :? LR { return null; }
public static function asf2(\M $m = null) :? MR { return null; }
public function af3(\N $n = null) :? NR { return null; }
public function af4(\P $p = null) :? PR { return null; }
}</code
```
**Зарегистрируем автолоадер:**
```
spl_autoload_register(function ($name) {
echo "Including $name...\n";
include "$name.php";
});
```
**И сделаем несколько вариантов использования этого класса:**
```
include ‘A.php’
Including B...
Including D...
Including C...
\A::AC1
Including A...
Including B...
Including D...
Including C...
Including E...
new A()
Including A...
Including B...
Including D...
Including C...
Including E...
Including F...
Including G...
Including H...
Including I...
Including J...
```
Можно заметить, что, когда мы просто каким-то образом подключаем класс, но не создаём его инстанс, будут подключены родитель, интерфейсы и трейты. Это делается рекурсивно для всех подключаемых по мере резолва файлов.
При создании инстанса к этому добавляется резолв всех констант и полей, что приводит к подключению всех необходимых для этого файлов, что, в свою очередь, также вызовет рекурсивное подключение трейтов, родителей и интерфейсов новоподключённых классов.
*Подключение связанных классов для процесса создания инстанса и остальных случаев*
Какого-то универсального решения этой проблемы нет, нужно просто иметь её в виду и следить за связями между классами: одна строчка может потянуть за собой подключение сотен файлов.
**Настройки OPCache**
Если вы используете метод [атомарного деплоя при помощи изменения симлинка](https://codeascraft.com/2013/07/01/atomic-deploys-at-etsy/), предложенный Расмусом Лердорфом, создателем PHP, то для [решения](https://grokbase.com/t/php/php-internals/133qt70p3k/continuous-integration-atomic-deploys-and-php-5-5) проблемы «залипания» симлинка на старой версии вам приходится включать opcache.revalidate\_path, как это рекомендуется, например, в этой [статье](https://habr.com/company/mailru/blog/310054/) про OPCache, переведённой Mail.Ru Group.
Проблема в том, что эта опция ощутимо (в среднем в полтора—два раза) увеличивает время на include каждого файла. Суммарно это может потреблять значительное количество ресурсов (у нас отключение этой опции дало выигрыш в 7—9%).
Чтобы её отключить, нужно сделать две вещи:
* [заставить](https://serverfault.com/questions/848503/nginx-caching-symlinks) веб-сервер резолвить симлинки;
* перестать подключать файлы внутри PHP-скрипта по путям, содержащим симлинки, либо принудительно резолвить их через readlink() или realpath().
Если все файлы подключаются автолоадером Composer, то второй пункт будет выполнен автоматически после выполнения первого: Сomposer использует константу \_\_DIR\_\_, которая будет разрезолвлена верно.
OPCache имеет ещё несколько опций, которые могут дать прирост производительности в обмен на гибкость. Подробнее про это можно прочитать в [статье](https://habr.com/company/mailru/blog/310054/), которую я упоминал выше.
Несмотря на все эти оптимизации, include всё равно не будет бесплатным. Для борьбы с этим в PHP 7.4 планируется добавление [preload](https://wiki.php.net/rfc/preload).
APCu, блокировки
----------------
Хотя мы не говорим здесь о базах данных и сервисах, в коде также могут возникать различного рода блокировки, которые увеличивают время выполнения скрипта.
По мере роста запросов мы заметили резкое замедление ответа в пиковые моменты. После выяснения причин оказалось, что, хотя APCu и является самым быстрым способом получения данных (по сравнению с Memcache, Redis и прочими внешними хранилищами), он тоже может работать медленно при частой перезаписи одинаковых ключей.
*Количество запросов в секунду и время выполнения: всплески в пиках 16 и 17 октября*
При использовании APCu в качестве кеша эта проблема не так актуальна, потому что кеширование обычно подразумевают редкую запись и частое чтение. Но некоторые задачи и алгоритмы (например, [Circuit Breaker](https://martinfowler.com/bliki/CircuitBreaker.html) ([реализация на PHP](https://github.com/upwork/phystrix))) подразумевают также и частую запись, что вызывает блокировки.
Универсального решения этой проблемы нет, но в случае с Circuit Breaker её можно решить, например, путём вынесения его в [отдельный сервис](https://www.envoyproxy.io/docs/envoy/latest/intro/arch_overview/circuit_breaking), поставленный на машины с PHP.
Пакетная обработка
------------------
Даже если не брать в расчёт include, обычно всё равно значительная часть времени выполнения запроса тратится на первичную инициализацию: фреймворк (например, сборка DI-контейнера и инициализация всех его зависимостей, роутинг, выполнение всех listeners), поднятие сессии, User’а и так далее.
Если ваш бекенд является внутренним API для чего-то, то наверняка какие-то запросы на клиентах можно объединить в пачки и отправлять единым запросом. В таком случае инициализация будет выполнена один раз для нескольких запросов.
Если на клиентах это сделать невозможно, попробуйте найти запросы, которые можно обрабатывать асинхронно. Их можно принимать каким-то простейшим скриптом, который не инициализирует ничего и просто откладывает их в очередь. А уже её можно будет обрабатывать пачками.
Разумная утилизация ресурсов
----------------------------
У нас в Badoo есть разные кластеры, которые заточены под разные нужды. Помимо кластера с PHP-FPM, где сотни серверов загружены по CPU, а диски простаивают, у нас есть один специфичный кластер баз данных из пары сотен машин, который прямо противоположен первому: с огромными дисками и сильно загруженный по IO, CPU которого простаивали.
Очевидным решением здесь был запуск PHP-FPM на втором кластере — по сути, мы бесплатно получили пару сотен дополнительных машин в кластер PHP.
Нагрузка может быть разделённой не только по типу (CPU, IO), но и по времени. Например, возможно, в рабочее время сотрудники компании строят отчёты, гоняют тесты, компилируют или делают что-то ещё на большом количестве серверов, а пик использования приложения приходится на нерабочее время. В таком случае можно использовать ресурсы простаивающего кластера, когда другой особенно сильно загружен. А построение отчётов, может быть, вообще можно произвольно переносить по времени.
Заключение
==========
Так мы решаем подобного рода задачи у себя. В результате даже в условиях постоянного роста трафика и активности нам удаётся не добавлять новое железо в кластеры с PHP уже в течение нескольких лет.
Краткое резюме:
* на небольших объёмах железо обычно дешевле оптимизаций;
* не оптимизируйте без явной необходимости;
* если всё-таки нужно оптимизировать, то измеряйте: скорее всего, проблема не в коде;
* правильно интерпретируйте измерения: не всегда всё линейно и очевидно (гипертрединг, пики, нелинейность активности);
* не полагайтесь на догадки: профилируйте и правильно интерпретируйте результаты;
* изменить настройки сжатия, OPCache или обновить версию PHP, как правило, проще, чем оптимизировать код;
* но и тут измеряйте: чужие решения могут не подойти вам (как, например, нам использование PHP 7.2 не дало столько, сколько обещают бенчмарки);
* смотрите на проблему шире: возможно, помогут оптимизации клиентов или более разумное использование ресурсов.
А какие инструменты и утилиты используете вы?
Спасибо за внимание! | https://habr.com/ru/post/430722/ | null | ru | null |
# Генератор масок из интервалов DEF кодов для Asterisk
Что имеем на входе:
1. несколько SIP операторов для исходящей связи, причём у некоторых более «вкусные» тарифы на определенного мобильного оператора;
2. данные по DEF кодам на [rossvyaz.ru](http://www.rossvyaz.ru/docs/articles/DEF-9x.html) выделенным операторам, но разбитыми на интервалы в том числе смежные (особенно заметно для МегаФона);
3. настроенный [Asterisk](http://www.asterisk.org) в виде дистрибутива [Elastix](http://www.elastix.org).
На выходе хотим получить список масок для определения номеров московских сотовых операторов (МСС, Билайн, МТС, МегаФон). Для этого за пару часов был написан небольшой скрипт, который наверняка может пригодиться кому-то еще и при небольших изменениях может быть переделан под других операторов или другие регионы.
Upd.: [генератор масок по DEF-кодам для Asterisk](http://habr.zaebalo.tv/def/) — теперь и онлайн =).
```
php
$linecode = '98'; // код для звонков на мобильные
// берем таблицу
$file = fopen('http://www.rossvyaz.ru/docs/articles/DEF-9x.html', 'r');
// получаем и разбираем таблицу
$defs = array();
while(($line = fgets($file)) && ($line !== FALSE)) {
$line = iconv('WINDOWS-1251', 'UTF-8', $line);
if(preg_match('|<tr\s* \s\*(\d+)\s\* |\s* \s\*(\d+)\s\* |\s* \s\*(\d+)\s\* |\s* \s\*(\d+)\s\* |\s* \s\*(.+?)\s\* |\s* \s\*(.+?)\s\* |\s*|', $line, $matches)) {
if(!isset($defs[$matches[6]])) {
$defs[$matches[6]] = array();
}
if(!isset($defs[$matches[6]][$matches[5]])) {
$defs[$matches[6]][$matches[5]] = array();
}
$defs[$matches[6]][$matches[5]][] = array($matches[1],$matches[2],$matches[3]);
}
}
fclose($file);
// выбираем интересующие нас записи и объединяем смежные интервалы
$selected = array();
foreach($defs as $reg => $ops) {
if($reg == 'Москва и Московская область') {
foreach($ops as $op => $cs) {
usort($cs, "cmp_defs");
switch($op) {
case 'Московская сотовая связь':
case 'Вымпел-Коммуникации':
case 'Мобильные ТелеСистемы':
case 'МегаФон':
if(!isset($selected[$op])) {
$selected[$op] = array();
}
$newset = true; $cnt = 1;
foreach($cs as $cid => $c) {
if($newset) {
$selected[$op][] = array($c[0], $c[1]);
}
if(isset($cs[$cid+1]) && ($c[0] == $cs[$cid+1][0]) && (($c[2] + 1) == $cs[$cid+1][1])) {
$newset = false;
$cnt++;
} else {
$selected[$op][count($selected[$op]) - 1][2] = $c[2];
$newset = true;
$cnt = 1;
}
}
break;
}
}
}
}
// генерируем маски для Asterisk
$regs = array();
foreach($selected as $op => $defs) {
$regs[$op] = array();
foreach($defs as $def) {
// если кто будет разбираться, то здесь мозг отказал мне
// $leq - это про правую часть, а $req про левую =)
$pref = $def[0];
$first = $def[1];
$last = $def[2];
if($first > $last) {
$tmp = $first;
$first = $last;
$last = $tmp;
}
// маски разбиваем на три массива и вгоняем через unshift/push исключительно с целью удобства поиска ошибок =)
$r = array();
$rf = array();
$rl = array();
$req = 0;
for($i = 0; $i < 7; $i++) {
if($first[$i] === $last[$i]) {
$req++;
} else {
break;
}
}
$leq = 0;
for($i = 6; $i >= 0; $i--) {
if(($first[$i]) === "0" && ($last[$i] === "9")) {
$leq++;
} else {
break;
}
}
$zf = true;
$nl = true;
if($leq + $req < 6)
for($i = $leq; $i + $req < 6; $i++) {
$sl = 6 - $i;
$pf = substr($first, 0, 6 - $i);
$pl = substr($last, 0, 6 - $i);
if($pf < $pl) {
$x = $first[6 - $i];
if(!$zf || ($x != '0')) {
switch($x) {
case '9':
array_push($rf, $pref . $pf . '9' . str_repeat('X', $i));
break;
case '8':
array_push($rf, $pref . $pf . '[89]' . str_repeat('X', $i));
break;
default:
array_push($rf, $pref . $pf . '[' . $x . '-9]' . str_repeat('X', $i));
}
$first = sprintf('%0' . $sl . 'd', substr($first, 0, $sl) + 1 ) . str_repeat('0', 7 - $sl);
$zf = false;
}
$x = $last[6 - $i];
if(!$nl || ($x != 9)) {
switch($x) {
case '0':
array_unshift($rl, $pref . $pl . '0' . str_repeat('X', $i));
break;
case '1':
array_unshift($rl, $pref . $pl . '[01]' . str_repeat('X', $i));
break;
default:
array_unshift($rl, $pref . $pl . '[0-' . $x . ']' . str_repeat('X', $i));
}
$last = sprintf('%0' . $sl . 'd', substr($last, 0, $sl) - 1 ) . str_repeat('9', 7 - $sl);
$nl = false;
}
}
$leq++;
}
if($leq + $req <= 7) {
if($leq < 7) {
$sl = 6 - $leq;
$pf = substr($first, 0, 6 - $leq);
$pl = substr($last, 0, 6 - $leq);
$xf = $first[6 - $leq];
$xl = $last[6 - $leq];
if(($pf == $pl) && ($xf <= $xl)) {
if($xf == $xl) {
$r[] = $pref . $pf . $xf . str_repeat('X', $leq);
} elseif($xf + 1 == $xl) {
$r[] = $pref . $pf . '[' . $xf . $xl . ']' . str_repeat('X', $leq);
} else {
$r[] = $pref . $pf . '[' . $xf . '-' . $xl . ']' . str_repeat('X', $leq);
}
}
} else {
$r[] = $pref . str_repeat('X', $leq);
}
}
$regs[$op] = array_merge($regs[$op], $rf, $r, $rl);
}
}
foreach($regs as $op => $reg) {
echo "\n\n=== $op ===\n\n";
foreach($reg as $r) {
echo $linecode . $r . "\n";
}
}
function cmp_defs($a, $b) {
if($a[0] != $b[0])
return $a[0] - $b[0];
return $a[1] - $b[1];
}
?>
```
В настоящий момент получил следующий результат: [из таблицы по состоянию на 01.09.2012](http://pastebin.com/xAwdv118).
P.S.: код жестоко привязан к выдаче Россвязи, так что начало интервала всегда оканчивается нулями, а конец — девятками. Это DEF-коды — так что семь цифр.
P.P.S.: на всякий случай уточню — да, это не самый красивый код, но когда нужен вспомогательный скрипт — то можно и так =) | https://habr.com/ru/post/150793/ | null | ru | null |
# Кондитерская программиста. Bon Appetit
Всем привет, в этой статье пойдёт речь о любопытных экспериментах с С++ и 3D графикой. Будем открывать свою собственную кондитерскую-программиста. Bon Appetit!
Для начала давайте немного пробежимся по структуре программ на С++.
Как только мы с Вами создадим проект на С++ в среде VisualStudio, нас встретит вот такой вот код:
```
#include
using namespace std;
int main()
{
cout << “Hello world!”;
}
```
Давайте немного проясним, что же эти «странные» строчки означают?
Для начала разберёмся с `#include` - это инициализация заголовочного файла iostream с классами, функциями и переменными для организации ввода-вывода в языке программирования C++. Он включён в стандартную библиотеку C++. Название образовано от Input/Output Stream («поток ввода-вывода»). В языке C++ и его предшественнике, языке программирования Си, нет встроенной поддержки ввода-вывода, вместо этого используется библиотека функций. iostream управляет вводом-выводом. Библиотека использует объекты cin, cout, cerr и clog для передачи информации и из стандартных потоков ввода, вывода, ошибок без буферизации и ошибок с буферизацией соответственно. Являясь частью стандартной библиотеки C++, эти объекты также являются частью стандартного пространства имён — std.
Ну всё, теперь мы разобрались с первой строчкой! Получается, что iostream – библиотека, которая помогает нам вводить и выводить данные, этого нам будет достаточно.
Далее идёт объявление пространства имён `using namespace std`, что же это такое? Интернет нам даёт следующее определение: Пространство имен — это декларативная область, в рамках которой определяются различные идентификаторы (имена типов, функций, переменных, и т. д.). Пространства имен используются для организации кода в виде логических групп и с целью избежания конфликтов имен, которые могут возникнуть, особенно в таких случаях, когда база кода включает несколько библиотек. Все идентификаторы в пределах пространства имен доступны друг другу без уточнения. Идентификаторы за пределами пространства имен могут обращаться к членам с помощью полного имени для каждого идентификатора, например `std::cin` или `std::cout` для одного идентификатора `using std::string`, для всех идентификаторов в пространстве имен `using namespace std;`. Код в файлах заголовков всегда должен содержать полное имя в пространстве имен.
Получается, что, если не вдаваться в подробности и сложную терминологию, пространство имён (`using namespace std`) – это наш универсальный помощник, который помогает преобразовать длинные и сложные конструкции вроде `std::cin >> a` в простую конструкцию `cin >> a`, а для этого всего-то надо прописать в начале программы, после объявления библиотек, одну строчку: `using namespace std` – нашу палочку-выручалочку, пространство имён std.
Теперь перейдём к телу программы, а именно к функции int main() – это самая главная функция в нашей программе. Даже её название переводится с английского на русский как «главная», именно с неё и будет начинаться выполняться код, который мы будем прописывать. (Небольшое замечание: в программе может быть великое множество функций, но всегда присутствует главная функция main, где все эти функции объявляются, это своеобразная “стартовая линия” нашей программы, отправная точка маршрута.) Тип у функции может быть разный, например int или float, char или double и т.д., но все эти типы объединяет одно, они возвращают какое-то значение после своего вызова, за исключением void – оно ничего не возвращает.
Вы также могли заметить внутри тела функции (внутри фигурных скобок: { }) строчку`cout << “Hello world!”`, здесь мы как раз можем наблюдать яркий пример применения пространства имён std, поэтому вместо `std::cout << “Hello world!”` мы пишем `cout << “Hello world!"`, это ли не магия? В данном случае команда cout отвечает за вывод в консоль фразы, которая написана в *“ “*, а именно фразу «Hello world!», что означает «Привет мир!». Важно отметить, что в конце таких команд ставится точка с запятой (;), что означает для компилятора конец команды.
Итак, мы разобрались с базовой конструкцией программы, теперь перейдём к чуть более сложным вещам, а именно к типам данных и их размерам. Переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная и сколько байт в памяти она будет занимать:
* **void:** тип без значения
* **int:** представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах).
* **float:** представляет вещественное число с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита)
* **double:** представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита)
* **char:** представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127
* и т.д.
Совсем забыл, для написания кода, нам ещё понадобится понимания термина «массив». Итак, массив – это область памяти, где могут последовательно храниться несколько значений. Массив можно представить в виде здания, где в каждой квартире живут «данные»:
А также нам понадобится циклы, мы будем использовать цикл for, про остальные циклы, вы можете почитать [вот здесь](https://metanit.com/cpp/tutorial/2.13.php).
Итак, цикл **for** — параметрический цикл (цикл с фиксированным числом повторений). Для организации такого цикла необходимо осуществить три операции:
* **Инициализация** - присваивание параметру цикла начального значения;
* **Условие** - проверка условия повторения цикла, чаще всего - сравнение величины параметра с некоторым граничным значением;
* **Модификация** - изменение значения параметра для следующего прохождения тела цикла.
Эти три операции записываются в скобках и разделяются точкой с запятой **;**. Как правило, параметром цикла является целочисленная переменная.
**Инициализация** параметра осуществляется только один раз — когда **цикл for** начинает выполняться.
Проверка **Условия** повторения цикла осуществляется перед каждым возможным выполнением тела цикла. Когда выражение, проверяющее **Условие** становится ложным (равным нулю), цикл завершается. **Модификация** параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.
```
for (Инициализация; Условие; Модификация)
{
Блок Операций;
}
```
Теперь давайте попробуем вывести что-нибудь, в консольную строку, например символ **@** для этого с комментариями, представлен ниже:
```
#include // инициализация библиотеки
using namespace std; // инициализация пространства имён std
int main() // начало главной функции main()
{
// инициализация переменных, которые являются неким разрешением консоли (количество символов, которое помещается в консоли)
int width = 120;
int heigh = 30;
// инициализация массива символов выводимых на экран
char\* screen = new char[width \* heigh + 1]; // +1 - это дополнительный нулевой символ,
screen[width \* heigh] = '\0'; // который существует для остановки вывода
// символов массива
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
screen[i + j \* width] = '@'; // заполняем массив какими-то символами, как пример символ "@"
}
}
cout << screen; // выводим на экран массив screen
}
```
И вот, что мы получаем на выходе:
Немного видоизменив наши циклы for мы сможем создать круг с помощью символа **@**:
```
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
float x = (float)i / width * 2.0f - 1.0f;
float y = (float)j / heigh * 2.0f - 1.0f;
char pixel = ' ';
if ((x * x + y * y) < 0.5)
pixel = '@';
screen[i + j * width] = pixel;
}
}
```
Результат:
Теперь создадим новую переменную, которая хранит соотношение сторон нашей консоли:
```
float aspect = (float) width / heigh;
```
А также во вложенном цикле for по j координату по ширине (по Ох) домножим на переменную, в которой хранится соотношение сторон нашей консоли:
```
x = x * aspect;
```
На выходе мы получим такой «овал»:
Но тут выясняется, что помимо соотношения сторон консоли, у нас есть соотношение сторон каждого символа, для символа **@** соотношение будет равно 11 на 24 px (пикселя), что же нам делать?
Решение есть! Добавим это значение в наш код:
```
float pixelAspect = 11.0f / 24.0f;
```
А теперь снова поменяв наш код (вложенный цикл for по j):
```
x = x * aspect * pixelAspect;
```
И вот, что мы получаем, домножив наше значение на соотношение сторон символа:
Вы когда-нибудь слышали, что движение – жизнь? Так давайте оживим нашу фигуру, для этого необходимо дописать ещё один цикл и заключить в него уже два имеющихся цикла. Перепишем код:
```
int moving = 20000; // переменная отвечающая за продолжительность перемещения нашего шара
for (int t = 0; t < moving; t++)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
float x = (float)i / width * 2.0f - 1.0f;
float y = (float)j / heigh * 2.0f - 1.0f;
x *= aspect * pixelAspect; // домножим так же на соотношение сторон символа
x += sin(t * 0.001);
char pixel = ' ';
if ((x * x + y * y) < 0.5)
pixel = '@';
screen[i + j * width] = pixel;
}
}
cout << screen;
}
```
Ура, мы оживили нашу фигуру:
Вам не кажется, что стало как-то скучно?
Давайте украсим нашу фигуру! Для этого перепишем наш код:
```
#include
using namespace std;
int main()
{
// некое разрешение консол (количество символов, которое помещается в консоли)
int width = 120;
int heigh = 30;
// массив символов выводимых на экран
char\* screen = new char[width \* heigh + 1]; // +1 - это дополнительный нулевой символ,
screen[width \* heigh] = '\0'; // который существует для остановки вывода
// символов массива
float aspect = (float)width / heigh; // переменная, которая хранит соотношение сторон нашей консоли
float pixelAspect = 11.0f / 24.0f; // перменная, которая хранит соотношение сторон символа
char gradient[] = ".:!/r(l1Z4H9W8$@"; // градиент из символов, символы – «цвет» нашей фигуры
int gradientSize = size(gradient) - 2;
int moving = 50000; // переменная отвечающая за продолжительность перемещения нашего шара
for (int t = 0; t < moving; t++)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
float x = (float)i / width \* 2.0f - 1.0f;
float y = (float)j / heigh \* 2.0f - 1.0f;
//x \*= aspect; // координаты по ширине (по Ох) домножаем на переменную, в которой хранится
// // соотношение сторон консоли
x \*= aspect \* pixelAspect; // домножим так же на соотношение сторон символа
x += sin(t \* 0.001);
char pixel = ' ';
float dist = sqrt(x \* x + y \* y);
int color = (int)(1.0f / dist);
// определение яркости символа
if (color < 0)
color = 0;
else if (color > gradientSize)
color = gradientSize;
pixel = gradient[color];
screen[i + j \* width] = pixel;
}
}
cout << screen;
}
}
```
Получим такую вот картину:
Теперь поменяем градиент **".:!/r(l1Z4H9W8$@"** на градиент **" .:!/r00 "**, чтобы убрать задний фон, и посмотрим что из этого выйдет:
Код на данном этапе:
```
#include
using namespace std;
int main()
{
// некое разрешение консол (количество символов, которое помещается в консоли)
int width = 120;
int heigh = 30;
// массив символов выводимых на экран
char\* screen = new char[width \* heigh + 1]; // +1 - это дополнительный нулевой символ,
screen[width \* heigh] = '\0'; // который существует для остановки вывода
// символов массива
float aspect = (float)width / heigh; // переменная, которая хранит соотношение сторон нашей консоли
float pixelAspect = 11.0f / 24.0f; // перменная, которая хранит соотношение сторон символа
//char gradient[] = ".:!/r(l1Z4H9W8$@"; // градиент из символов
char gradient[] = " .:!/r00 "; // градиент: " !/r(l1 "
int gradientSize = size(gradient) - 5;
int moving = 50000; // переменная отвечающая за продолжительность перемещения нашего шара
for (int t = 0; t < moving; t++)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
float x = (float)i / width \* 2.0f - 1.0f;
float y = (float)j / heigh \* 2.0f - 1.0f;
//x \*= aspect; // координаты по ширине (по Ох) домножаем на переменную, в которой хранится
// // соотношение сторон консоли
x = x \* aspect \* pixelAspect; // домножим так же на соотношение сторон символа
x = x + sin(t \* 0.001);
char pixel = ' ';
float dist = sqrt(x \* x + y \* y);
int color = (int)(1.0f / dist);
// определение яркости символа
if (color < 0)
color = 0;
else if (color > gradientSize)
color = gradientSize;
pixel = gradient[color];
screen[i + j \* width] = pixel;
}
}
cout << screen;
}
}
```
А теперь перейдём к самому пончику:
Для начала, упростим нашу программу, перенеся сравнение яркости символа в отдельную функцию, которую расположим выше нашей функции main (это необходимо для того, чтобы функцию было видно из функции main), а также немного перепишем сравнение яркости символа, поменяв:
```
if (color < 0)
color = 0;
else if (color > gradientSize)
color = gradientSize;
```
На
```
float clamp(float value, float min, float max)
{
return fmax(fmin(value, max), min); // т.е. мы берём максимум (fmax) от минимума (fmin) и минимум от максимума (fmax)
}
```
Таким образом мы ограничиваем значение с обоих сторон: минимальным значением и максимальным. Получаем:
```
/*if (color < 0)
color = 0;
else if (color > gradientSize)
color = gradientSize;*/
// меняем систему из if и else на функцию clamp
color = clamp(color, 0, gradientSize);
```
* **//** - однострочный комментарий
* **/\* \*/** - многострочный комментарий
Теперь перепишем наши координаты, заменив
```
float x = (float)i / width * 2.0f - 1.0f;
float y = (float)j / heigh * 2.0f - 1.0f;
```
На
```
vec2 uv = vec2(i, j) / vec2(width, heigh) * 2.0f - 1.0f;
```
На двумерную структуру по двум координатам, заключив vec2 в структуру:
```
struct vec2
{
float x, y;
vec2(float value) : x(value), y(value) {}
vec2(float _x, float _y): x(_x), y(_y) {}
vec2 operator+(vec2 const& other) {
return vec2(x + other.x, y + other.y);
}
vec2 operator-(vec2 const& other) {
return vec2(x - other.x, y - other.y);
}
vec2 operator*(vec2 const& other) {
return vec2(x * other.x, y * other.y);
}
vec2 operator/(vec2 const& other) {
return vec2(x / other.x, y / other.y);
}
};
```
Подробнее о структурах [тут](https://metanit.com/cpp/tutorial/5.8.php).
Также создадим структуру для 3 координат:
```
struct vec3
{
float x, y, z;
vec3(float _value) : x(_value), y(_value), z(_value) {};
vec3(float _x, vec2 const& v) : x(_x), y(v.x), z(v.y) {};
vec3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {};
vec3 operator+(vec3 const& other)
{
return vec3(x + other.x, y + other.y, z + other.z);
}
vec3 operator-(vec3 const& other)
{
return vec3(x - other.x, y - other.y, z - other.z);
}
vec3 operator*(vec3 const& other)
{
return vec3(x * other.x, y * other.y, z * other.z);
}
vec3 operator/(vec3 const& other)
{
return vec3(x / other.x, y / other.y, z / other.z);
}
vec3 operator-()
{
return vec3(-x, -y, -z);
}
};
```
И допишем внутри цикла:
```
vec3 ro = vec3(-5, 0, 0);
vec3 rd = vec3(1, uv);
```
Теперь добавим библиотеку math.h, которая отвечает за неэлементарную математику в С++: `#include` И допишем функции для работы с векторами:
```
double sign(double a) { return (0 < a) - (a < 0); }
double step(double edge, double x) { return x > edge; }
float length(vec2 const& v) { return sqrt(v.x * v.x + v.y * v.y); }
float length(vec3 const& v) { return sqrt(v.x * v.x + v.y * v.y + v.z * v.z); }
vec3 norm(vec3 v) { return v / length(v); }
float dot(vec3 const& a, vec3 const& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
vec3 abs(vec3 const& v) { return vec3(fabs(v.x), fabs(v.y), fabs(v.z)); }
vec3 sign(vec3 const& v) { return vec3(sign(v.x), sign(v.y), sign(v.z)); }
vec3 step(vec3 const& edge, vec3 v) { return vec3(step(edge.x, v.x), step(edge.y, v.y), step(edge.z, v.z)); }
vec3 reflect(vec3 rd, vec3 n) { return rd - n * (2 * dot(n, rd)); }
vec3 rotateX(vec3 a, double angle)
{
vec3 b = a;
b.z = a.z * cos(angle) - a.y * sin(angle);
b.y = a.z * sin(angle) + a.y * cos(angle);
return b;
}
vec3 rotateY(vec3 a, double angle)
{
vec3 b = a;
b.x = a.x * cos(angle) - a.z * sin(angle);
b.z = a.x * sin(angle) + a.z * cos(angle);
return b;
}
vec3 rotateZ(vec3 a, double angle)
{
vec3 b = a;
b.x = a.x * cos(angle) - a.y * sin(angle);
b.y = a.x * sin(angle) + a.y * cos(angle);
return b;
}
vec2 sphere(vec3 ro, vec3 rd, float r) {
float b = dot(ro, rd);
float c = dot(ro, ro) - r * r;
float h = b * b - c;
if (h < 0.0) return vec2(-1.0);
h = sqrt(h);
return vec2(-b - h, -b + h);
}
vec2 box(vec3 ro, vec3 rd, vec3 boxSize, vec3& outNormal) {
vec3 m = vec3(1.0) / rd;
vec3 n = m * ro;
vec3 k = abs(m) * boxSize;
vec3 t1 = -n - k;
vec3 t2 = -n + k;
float tN = fmax(fmax(t1.x, t1.y), t1.z);
float tF = fmin(fmin(t2.x, t2.y), t2.z);
if (tN > tF || tF < 0.0) return vec2(-1.0);
vec3 yzx = vec3(t1.y, t1.z, t1.x);
vec3 zxy = vec3(t1.z, t1.x, t1.y);
outNormal = -sign(rd) * step(yzx, t1) * step(zxy, t1);
return vec2(tN, tF);
}
float plane(vec3 ro, vec3 rd, vec3 p, float w) {
return -(dot(ro, p) + w) / dot(rd, p);
}
```
Теперь нормализуем наш вектор:
```
vec3 rd = vec3(1, uv);
```
С помощью функции `norm()` и получим:
```
vec3 rd = norm(vec3(1, uv));
```
Теперь зададим некоторый цвет, если пересечение произошло, для этого добавим в наши циклы следующие строчки:
```
vec2 uv = vec2(i, j) / vec2(width, heigh) * 2.0f - 1.0f;
vec3 ro = vec3(-5, 0, 0);
vec3 rd = norm(vec3(1, uv));
uv.x = uv.x * aspect * pixelAspect;
uv.x = uv.x + sin(t * 0.001);
char pixel = ' ';
int color = 0;
vec2 intersection = sphere(ro, rd, 1);
if (intersection.x > 0)
color = 10;
color = clamp(color, 0, gradientSize);
pixel = gradient[color];
screen[i + j * width] = pixel;
```
Приблизим сферу поменяв значение в строке
```
vec3 ro = vec3(-5, 0, 0)
```
На
```
vec3 ro = vec3(-2, 0, 0)
```
А теперь перепишем вновь нашу функцию main:
```
int main()
{
int width = 120;
int heigh = 30;
float aspect = (float)width / heigh;
float pixelAspect = 11.0f / 24.0f;
char gradient[] = " .:!/r00 ";
int gradientSize = size(gradient) - 2;
char* screen = new char[width * heigh + 1];
screen[width * heigh] = '\0';
for (int t = 0; t < 10000; t++)
{
vec3 light = norm(vec3(sin(t*0.001), cos(t*0.001), -1.0));
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
vec2 uv = vec2(i, j) / vec2(width, heigh) * 2.0f - 1.0f;
vec3 ro = vec3(-2, 0, 0);
vec3 rd = norm(vec3(1, uv));
uv.x = uv.x * aspect * pixelAspect;
uv.x = uv.x + sin(t * 0.001);
char pixel = ' ';
int color = 0;
vec2 intersection = sphere(ro, rd, 1);
if (intersection.x > 0)
{
vec3 itPoint = ro + rd * intersection.x;
vec3 n = norm(itPoint);
float diff = dot(n, light);
color = (int) (diff * 20);
}
color = clamp(color, 0, gradientSize);
pixel = gradient[color];
screen[i + j * width] = pixel;
}
}
cout << screen;
}
}
```
Снова поменяем градиент, чтобы получить сферу сменим
```
char gradient[] = " .:!/r00 "
```
на
```
char gradient[] = " .:!/r(l1Z4H9W8$@"
```
и получим такой результат:
Если же сменим градиент обратно, то и получим:
Код:
```
#include
#include
using namespace std;
float clamp(float value, float min, float max)
{
return fmax(fmin(value, max), min); // т.е. мы берём максимум (fmax) от минимума (fmin) и минимум от максимума (fmax)
}
struct vec2
{
float x, y;
vec2(float value) : x(value), y(value) {}
vec2(float \_x, float \_y): x(\_x), y(\_y) {}
vec2 operator+(vec2 const& other) { return vec2(x + other.x, y + other.y); }
vec2 operator-(vec2 const& other) { return vec2(x - other.x, y - other.y); }
vec2 operator\*(vec2 const& other) { return vec2(x \* other.x, y \* other.y); }
vec2 operator/(vec2 const& other) { return vec2(x / other.x, y / other.y); }
};
struct vec3
{
float x, y, z;
vec3(float \_value) : x(\_value), y(\_value), z(\_value) {};
vec3(float \_x, vec2 const& v) : x(\_x), y(v.x), z(v.y) {};
vec3(float \_x, float \_y, float \_z) : x(\_x), y(\_y), z(\_z) {};
vec3 operator+(vec3 const& other) { return vec3(x + other.x, y + other.y, z + other.z); }
vec3 operator-(vec3 const& other) { return vec3(x - other.x, y - other.y, z - other.z); }
vec3 operator\*(vec3 const& other) { return vec3(x \* other.x, y \* other.y, z \* other.z); }
vec3 operator/(vec3 const& other) { return vec3(x / other.x, y / other.y, z / other.z); }
vec3 operator-() { return vec3(-x, -y, -z); }
};
double sign(double a) { return (0 < a) - (a < 0); }
double step(double edge, double x) { return x > edge; }
float length(vec2 const& v) { return sqrt(v.x \* v.x + v.y \* v.y); }
float length(vec3 const& v) { return sqrt(v.x \* v.x + v.y \* v.y + v.z \* v.z); }
vec3 norm(vec3 v) { return v / length(v); }
float dot(vec3 const& a, vec3 const& b) { return a.x \* b.x + a.y \* b.y + a.z \* b.z; }
vec3 abs(vec3 const& v) { return vec3(fabs(v.x), fabs(v.y), fabs(v.z)); }
vec3 sign(vec3 const& v) { return vec3(sign(v.x), sign(v.y), sign(v.z)); }
vec3 step(vec3 const& edge, vec3 v) { return vec3(step(edge.x, v.x), step(edge.y, v.y), step(edge.z, v.z)); }
vec3 reflect(vec3 rd, vec3 n) { return rd - n \* (2 \* dot(n, rd)); }
vec3 rotateX(vec3 a, double angle)
{
vec3 b = a;
b.z = a.z \* cos(angle) - a.y \* sin(angle);
b.y = a.z \* sin(angle) + a.y \* cos(angle);
return b;
}
vec3 rotateY(vec3 a, double angle)
{
vec3 b = a;
b.x = a.x \* cos(angle) - a.z \* sin(angle);
b.z = a.x \* sin(angle) + a.z \* cos(angle);
return b;
}
vec3 rotateZ(vec3 a, double angle)
{
vec3 b = a;
b.x = a.x \* cos(angle) - a.y \* sin(angle);
b.y = a.x \* sin(angle) + a.y \* cos(angle);
return b;
}
vec2 sphere(vec3 ro, vec3 rd, float r) {
float b = dot(ro, rd);
float c = dot(ro, ro) - r \* r;
float h = b \* b - c;
if (h < 0.0) return vec2(-1.0);
h = sqrt(h);
return vec2(-b - h, -b + h);
}
vec2 box(vec3 ro, vec3 rd, vec3 boxSize, vec3& outNormal) {
vec3 m = vec3(1.0) / rd;
vec3 n = m \* ro;
vec3 k = abs(m) \* boxSize;
vec3 t1 = -n - k;
vec3 t2 = -n + k;
float tN = fmax(fmax(t1.x, t1.y), t1.z);
float tF = fmin(fmin(t2.x, t2.y), t2.z);
if (tN > tF || tF < 0.0) return vec2(-1.0);
vec3 yzx = vec3(t1.y, t1.z, t1.x);
vec3 zxy = vec3(t1.z, t1.x, t1.y);
outNormal = -sign(rd) \* step(yzx, t1) \* step(zxy, t1);
return vec2(tN, tF);
}
float plane(vec3 ro, vec3 rd, vec3 p, float w) { return -(dot(ro, p) + w) / dot(rd, p); }
int main()
{
int width = 120;
int heigh = 30;
float aspect = (float)width / heigh;
float pixelAspect = 11.0f / 24.0f;
char gradient[] = " .:!/r(l1Z4H "; // " .:!/r(l1Z4H9W8$@"
int gradientSize = size(gradient) - 2;
char\* screen = new char[width \* heigh + 1];
screen[width \* heigh] = '\0';
for (int t = 0; t < 100000; t++)
{
vec3 light = norm(vec3(sin(t\*0.001), cos(t\*0.001), -1.0));
for (int i = 0; i < width; i++)
{
for (int j = 0; j < heigh; j++)
{
vec2 uv = vec2(i, j) / vec2(width, heigh) \* 2.0f - 1.0f;
vec3 ro = vec3(-2, 0, 0);
vec3 rd = norm(vec3(1, uv));
uv.x = uv.x \* aspect \* pixelAspect;
uv.x = uv.x + sin(t \* 0.001);
char pixel = ' ';
int color = 0;
vec2 intersection = sphere(ro, rd, 1);
if (intersection.x > 0)
{
vec3 itPoint = ro + rd \* intersection.x;
vec3 n = norm(itPoint);
float diff = dot(n, light);
color = (int) (diff \* 20);
}
color = clamp(color, 0, gradientSize);
pixel = gradient[color];
screen[i + j \* width] = pixel;
}
}
cout << screen;
}
}
```
И немного поменяв код, дописав к нашему коду функцию:
```
float getDisk(vec3 p, float t)
{
vec2 q = vec2(length(vec2(p.x, p.y)) - 1.0, p.z);
return length(q) - 0.5;
}
```
Мы получили наше любимое блюдо «пончик». Всё готово, и как говорят итальянцы "buon appetito", что по русски "приятного аппетита".
**Post Scriptum:** Данная статья была подготовлена в рамках мастер-класса «Сделай пончик с помощью кода» и является методическим материалом для самостоятельного изучения информации в рамках мастер-класса. Так же хотел бы выразить благодарность источникам, которыми я вдохновлялся и пользовался в процессе написания статьи и подготовки к мастер-классу: [сайт metanit](https://metanit.com/cpp/), а также [youtube-каналом Onigiri](https://www.youtube.com/c/OnigiriScience). | https://habr.com/ru/post/650011/ | null | ru | null |
# Опыт создания загрузчика изображений
#### Предисловие
Всем привет. Я хочу рассказать о создании загрузчика изображений для своего первого web-проекта. Я постараюсь объяснить, какие решения я видел, и какие подводные камни встретились на моем пути. Ну и, собственно, как эти камни можно обойти. Надеюсь, мой опыт кому-нибудь поможет.
Для начала опишу основную задачу: необходимо создать загрузчик изображений(bmp, png, jpg), с последующим их сохранением на сервере, а также с созданием копий изображений различного размера. Также желательно обеспечить соответствие дизайна загрузчика стилю сайта, и удобный интерфейс пользователя. И самое главное – загрузчик должен максимально поддерживаться браузерами.
#### Решение первое. HTML4
Конечно же, это самое простое и очевидное. Создать форму, засунуть туда input-file, и обработать на сервере php-скриптом:
```
if(is_uploaded_file($_FILES["filename"]["tmp_name"])) {
move_uploaded_file($_FILES["filename"]["tmp_name"], $_FILES["filename"]["name"]);
}
else {
echo("Ошибка загрузки файла");
}
```
Теперь необходимо создать копии меньшего разрешения. Тут можно воспользоваться различными библиотеками обработки изображений. Например, Imagick. Именно так я вначале и сделал. На локальном хосте все работало замечательно. Потом я выбрал недорогой хостинг, поместил туда проект. Начал тестировать. И вот тут вышел главный облом. Для изображений с хорошим разрешением (2500х1900) не создавались маленькие копии. Многие, наверное, догадались почему. Покопавшись в логах, а также приложив умственные усилия, до меня дошло. Когда начинаешь обрабатывать изображения, и работать со всей матрицей, требуется немало оперативной памяти. И мой достаточно скромный тариф на хостинге предоставлял её не очень-то много.
И вот это уже была проблема. Можно, конечно, взять тариф получше. Но кардинально это ситуацию не изменит. При дополнительной нагрузке произойдет то же самое. Подход неверен по сути. Производить манипуляции с изображением надо не на сервере, а на клиенте. И кроссбраузерный html+javascript тут не подходил.
#### Решение второе. Flash
Конечно, решение тоже не кроссбраузерное. Но у 99% пользователей flash все-таки стоит, поэтому попробовать стоит. Тем более есть очевидные преимущества:
* асинхронная загрузка
* возможность пакетной загрузки
* возможность выводить превью изображений
* варианты дизайна не ограничены
Нам потребуется FileReferenceList для того, чтобы вызвать диалог и получить список изображений с локальной машины. Далее загружаем каждое и выполняем с ним необходимые действия:
```
var FileList:Array;
var send_element;
var load_element;
var script_name = "../../ajax.php";
var type_filter:FileFilter = new FileFilter("Изображения (*.jpg, *.jpeg, *.gif, *.png)","*.jpg;*.jpeg;*.gif;*.png");
var OpenFileDialog:FileReferenceList = new FileReferenceList();
OpenFileDialog.addEventListener(Event.SELECT, onSelectList);
function onSelectList(e:Event){
Select_check();
}
function Select_check(){
var element: FileReference = OpenFileDialog.fileList.shift();
load_element["original"] = element;
FileList.push(load_element);
element.addEventListener(Event.COMPLETE, onLocal_complete);
element.load();
}
function onLocal_complete(e:Event){
//здесь действия с загруженным изображением e.target.data
load_element["original"].removeEventListener(Event.COMPLETE, onLocal_complete);
if(OpenFileDialog.fileList.length > 0) Select_check();
}
function open(){
OpenFileDialog.browse([type_filter]);
}
function save(){
var send_element = FileList.shift();
send_element["original"].addEventListener(ProgressEvent.PROGRESS, onPOST_progress);
send_element["original"].addEventListener(Event.COMPLETE, onPOST_complete);
send_element["original"].addEventListener(IOErrorEvent.IO_ERROR, onPOST_error);
var cookie = ExternalInterface.call("function(){ var name = 'PHPSESSID'; var prefix = name + '='; var cookieStartIndex = document.cookie.indexOf(prefix); if (cookieStartIndex == -1) return null; var cookieEndIndex = document.cookie.indexOf(';', cookieStartIndex + prefix.length); if (cookieEndIndex == -1) cookieEndIndex = document.cookie.length; return unescape(document.cookie.substring(cookieStartIndex + prefix.length, cookieEndIndex));}");
var DataVartibles:URLVariables = new URLVariables();
DataVartibles.PHPSESSID = cookie;
var FileRequest = new URLRequest(script_name);
FileRequest.data = DataVartibles;
FileRequest.method = URLRequestMethod.POST;
send_element["original"].upload(FileRequest, php_file);
}
function onPOST_progress(e:ProgressEvent){
//здесь некие действия, например вывод e.bytesLoaded
}
function onPOST_error(e:IOErrorEvent){
//здесь некие действия проиходящие при ошибке
if(FileList.length > 0) save();
}
function onPOST_complete(e:Event){
if(FileList.length > 0) save();
}
```
Метод browse вызывает диалог загрузки файлов. Тут есть одна тонкость: метод выполнится только в том случае, если код вызывается в слушателе события EVENT.CLICK какого-нибудь элемента.
Также стоит остановиться на описании класса FileReference. Он нужен для загрузки локального изображения и передачи его на сервер. Метод load нужен для загрузки, upload – для передачи на сервер. Здесь есть ещё одна тонкость: при загрузке на сервер с помощью FileReference куки передаются только из IE(спасибо за информацию [Demetros](http://habrahabr.ru/users/demetros/)). Поэтому, если вы хотите, например, работать в рамках одной сессии, то придется достать куки из браузера с помощью вызова функции javascript. Лучше это делать из самой флешки. Для этого подойдет ExternalInterface. Далее записываем нужные нам куки в URLVariables.
Итак, базовая функцинальность есть. Но остается вопрос с созданием и отправкой уменьшенных копий изображений. И вот тут FileReference нам уже не поможет, так как он способен отправить только загруженные локальные файлы.
Вопрос создания уменьшенных копий я не буду рассматривать, есть много библиотек, способных это сделать. Однако для отправки на сервер эти данные должны быть представлены в виде ByteArray.
Теперь рассмотрим, как нам организовать отправку этих данных на сервер. С помощью обычной переменной URLVariables с последущем добавлением в URLRequest это сделать не получится. Поэтому придется формировать шапку запроса самим. URLRequest позволяет это сделать. В итоге создаем класс, который занимается отправкой данных на сервер:
```
package {
import flash.net.URLRequest;
import flash.net.URLLoader;
import flash.net.URLRequestMethod;
import flash.net.URLLoaderDataFormat;
import flash.utils.ByteArray;
import flash.utils.Endian;
import flash.net.URLRequestHeader;
public class HTTPLoader extends URLLoader
{
var HTTPRequest;
var BOUND:String = "";
var ENTER:String = "\r\n";
var ADDB:String = "--";
var index_file = 0;
var PostData:ByteArray;
public function HTTPLoader(script_name: String){
BOUND = getBoundary();
PostData = new ByteArray();
PostData.endian = Endian.BIG_ENDIAN;
HTTPRequest = new URLRequest(script_name);
HTTPRequest.requestHeaders.push(new URLRequestHeader('Content-type','multipart/form-data; boundary=' + BOUND));
HTTPRequest.method = URLRequestMethod.POST;
}
public function addVariable(param_name:String, param_value:String){
PostData.writeUTFBytes(ADDB + BOUND);
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes('Content-Disposition: form-data; name="'+param_name+'"');
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes(param_value);
PostData.writeUTFBytes(ENTER);
}
public function addFile(filename:String, filedata:ByteArray){
PostData.writeUTFBytes(ADDB + BOUND);
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes('Content-Disposition: form-data; name="Filedata' + index_file + '"; filename="' + filename + '"');
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes('Content-Type: application/octet-stream');
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes(ENTER);
PostData.writeBytes(filedata,0,filedata.length);
PostData.writeUTFBytes(ENTER);
PostData.writeUTFBytes(ENTER);
index_file++;
}
public function send(){
PostData.writeUTFBytes(ADDB+BOUND+ADDB);
HTTPRequest.data = PostData;
this.load(HTTPRequest);
}
public function getBoundary():String {
var _boundary:String = "";
for (var i:int = 0; i < 0x20; i++) {
_boundary += String.fromCharCode( int( 97 + Math.random() * 25 ) );
}
return _boundary;
}
}
}
```
Привожу класс полностью, так как формирование правильной шапки HTTP-запроса заняло у меня довольно много времени. Надеюсь, кому-то поможет. Пользоваться классом очень просто. Вот пример:
```
var POSTLoader:HTTPLoader = new HTTPLoader("../../ajax.php");
POSTLoader.addEventListener(Event.COMPLETE, POSTLoader_complete);
POSTLoader.addVariable("AJAX_module_name", "pic_loader.php");
POSTLoader.addFile("pic_100", send_element["pic_100"]);
POSTLoader.send();
```
Ну а в слушателе Event.COMPLETE делайте, что вам необходимо. Минус такого способа в том, что нельзя отследить процесс загрузки, поэтому доступно только два состояния — загрузился файл или нет.
В php можно легко пройтись по массиву $\_FILES и подцепить каждый файл по имени «Filedata»+index, а потом просто сохранить.
```
if(isset($_FILES["Filedata0"])){
for($i = 0; $i < $n; $i++){
$file_name = $_FILES["Filedata".$i]["name"];
move_uploaded_file($_FILES["Filedata".$i]['tmp_name'],$file_path.$file_name);
}
}
```
Вот такое решение. При желании можно выводить превью картинок сразу же, или передавать в javascript в виде base64. Ну это уже кому как нравится.
#### Решение третье. HTML5
Сразу скажу, что с помощью html5 я загрузчик не реализовывал, однако для относительной полноты картины (java-апплеты я брать не стал) об этом решении стоит упомянуть. Скорее всего, в будущем это станет наилучшим способом решения этой задачи. Однако пока ещё в ходу старые браузеры, да и в новых File API ещё не до конца проработан. Также стоит упомянуть про неизменяемый input-file. В современных браузерах можно вызвать программно метод click, а сам input скрыть.
```
```
```
var btn = document.querySelector("#button");
btn.onclick = function(){
var im = document.querySelector("#im");
im.click();
}
```
Такое решение работает почти во всех современных браузерах. Кроме одного. Угадайте какого…
Не угадали, Opera. В версиях до 11.52 включительно так сделать нельзя. Поэтому наложение грима на input-file до сих пор остается проблемой.
#### Заключение
Конечно, в реальном проекте лучше использовать комбинацию этих способов, чтобы загрузчик работал у всех. Например, если функции html5 в браузере пользователя не поддерживаются, то можно попытаться использовать flash. Если же и flash отсутствует, то даем простое html-решение. Неказисто, зато работает.
Надеюсь, моя статья кому-нибудь поможет. | https://habr.com/ru/post/132489/ | null | ru | null |
# One Day in the Life of PVS-Studio Developer, or How I Debugged Diagnostic That Surpassed Three Programmers
Static analyzers' primary aim is to search for errors missed by developers. Recently, the PVS-Studio team again found an interesting example proving the power of static analysis.
You have to be very attentive while working with static analysis tools. Often the code that triggered the analyzer seems to be correct. So, you are tempted to mark the warning as false positive. The other day, we fell into such a trap. Here's how it turned out.
Recently, we've [enhanced the analyzer core](https://pvs-studio.com/en/blog/posts/cpp/0824/). When viewing new warnings, my colleague found a false one among them. He noted the warning to show the team leader, who glanced through the code and created a task. I took the task. That's what brought together three programmers.
The analyzer warning: [V645](https://pvs-studio.com/en/w/v645/) The 'strncat' function call could lead to the 'a.consoleText' buffer overflow. The bounds should not contain the size of the buffer, but a number of characters it can hold.
The code fragment:
```
struct A
{
char consoleText[512];
};
void foo(A a)
{
char inputBuffer[1024];
....
strncat(a.consoleText, inputBuffer, sizeof(a.consoleText) –
strlen(a.consoleText) - 5);
....
}
```
Before we take a look at the example, let's recall what the *strncat* function does:
```
char *strncat(
char *strDest,
const char *strSource,
size_t count
);
```
where:
* 'destination' — pointer to a string to append to;
* 'source' — pointer to a string to copy from;
* 'count' — maximum number of characters to copy.
At first glance, the code seems great. The code calculates the amount of free buffer space. And it seems that we have 4 extra bytes... We thought the code was written in the right way, so we noted it as an example of a false warning.
Let's see if this is really the case. In the expression:
```
sizeof(a.consoleText) – strlen(a.consoleText) – 5
```
the maximum value can be reached with the minimum value of the second operand:
```
strlen(a.consoleText) = 0
```
Then the result is 507, and no overflow happens. Why does PVS-Studio issue the warning? Let's delve into the analyzer's internal mechanics and try to figure it out.
Static analyzers use data-flow analysis to calculate such expressions. In most cases, if an expression consists of compile-time constants, data flow returns the exact value of the expression. In all other cases, as with the warning, data flow returns only a range of possible values of the expression.
In this case, the *strlen(a.consoleText)* operand value is unknown at compile time. Let's look at the range.
After a few minutes of debugging, we get the whole 2 ranges:
```
[0, 507] U [0xFFFFFFFFFFFFFFFC, 0xFFFFFFFFFFFFFFFF]
```
The second range seems redundant. However, that's not so. We forgot that the expression may receive a negative number. For example, such may happen if *strlen(a.consoleText) = 508*. In this case, an unsigned integer overflow happens. The expression results in the maximum value of the resulting type — *size\_t*.
It turns out that the analyzer is right! In this expression, the *consoleText* field may receive a much larger number of characters than it can store. This leads to [buffer overflow](https://pvs-studio.com/en/blog/terms/0067/) and to [undefined behavior](https://pvs-studio.com/en/blog/terms/0066/). So, we received an unexpected warning because there is no false positive here!
That's how we found new reasons to recall the key advantage of static analysis — the tool is much more attentive than a person. Thus, a thoughtful review of the analyzer's warnings saves developers time and effort while debugging. It also protects from errors and snap judgments. | https://habr.com/ru/post/566230/ | null | en | null |
# D3.js. Визуализация графов
> **D3.js** — это библиотека JavaScript для управления документами, в основе которых лежат данные. **D3** помогает претворить данные в жизнь, используя HTML, SVG и CSS. D3 позволяет привязывать произвольные данные к DOM, и затем применять результаты манипуляций с ними к документу.
>
>
Для понимания статьи пригодится [знание основ D3](https://habrahabr.ru/company/datalaboratory/blog/217905/), и в ней мы рассмотрим реализацию алгоритмов визуализации графа на основе сил ([Force-directed graph drawing algorithms](https://en.wikipedia.org/wiki/Force-directed_graph_drawing)), которая в D3 (version 3) имеет название *[Force Layout](https://github.com/d3/d3-3.x-api-reference/blob/master/Force-Layout.md)*. Это класс алгоритмов визуализации графов, которые вычисляют позицию каждого узла, моделируя силу притяжения между каждой парой связанных узлов, а также отталкивающую силу между узлами.
На картинке выше вы видите, как небезызвестное издание «New Yourk Times» [визуализировало связи](http://www.nytimes.com/interactive/2013/02/20/movies/among-the-oscar-contenders-a-host-of-connections.html) между претендентами на очередной «Оскар». Окончательный лейаут статичен, но позиции узлов графа были вычислены как раз при помощи Force Layout. Для графа был построен внутренний редактор, позволяющий сохранять координаты узлов для использования их в статическом варианте.
**N.B.!** Буквально вчера [вышла](https://twitter.com/mbostock/status/747810877001203712) новая версия (version 4) D3.js, поэтому начатая мною статья уже может считаться устаревшей. Тем не менее, надеюсь, что она будет полезна для понимания возможностей новой версии. Об изменениях, внесенных в новой версии в API визуализации графов можно прочитать [здесь](https://github.com/d3/d3/blob/master/CHANGES.md#forces-d3-force).
Немного о Layouts
=================
D3.js API содержит несколько сотен функций, и для удобства они разделены на логические блоки, одним из которых является блок Layouts. Он заключает в себе функционал визуального отображения связанных с данными элементов друг относительно друга. Layouts получают ряд входных данных, применят к ним алгоритм или эвристику, и выводят результат в виде графического представления данных.
Layouts мало чем отличаются от [d3.svg path generators](https://github.com/d3/d3-3.x-api-reference/blob/master/SVG-Shapes.md#path-data-generators) в том, что они помогают преобразовывать данные для их визуального представления. Однако Layouts, как правило, работают с набором данных в целом, а не по отдельности. Кроме того, результаты работы Layout не ограничены одним SVG. Некоторые Layouts динамичны во времени: например, Force Layout, где после исполнения метода ***.start()*** экземпляра ***d3.layout.force()*** можно отслеживать события ***'tick'*** обновления лейаута.
В D3 встроены более десятка Layouts. Их экземплярами зачастую являются функции (хотя не обязательно), которые могут быть сконфигурированы и затем применены к набору данных. В иных случаях, для ввода данных и представления результата используются отдельные методы или обработчики событий. Для использования нужно смотреть документацию каждого конкретного Layout.
Force Layout
============
Визуализация гибкого force-directed графа осуществляется с использованием [метода численного интегрирования Верле](https://ru.wikipedia.org/wiki/Интегрирование_Верле) для накладывания ограничений на перемещения элементов графа относительно друг друга. Подробнее о физическом моделировании вы можете прочитать [здесь](http://www.gamasutra.com/resource_guide/20030121/jacobson_pfv.htm). Данная реализация использует [модуль quadtree](https://github.com/d3/d3-3.x-api-reference/blob/master/Quadtree-Geom.md) (дерево квадрантов) для ускорения взаимодействия узлов графа между собою, с помощью [аппроксимации Барнса-Хата](https://en.wikipedia.org/wiki/Barnes–Hut_simulation). Кроме отталкивающей силы ***charge*** узла, псевдо-гравитационная сила ***gravity*** удерживает узлы в видимой области и избегает выталкивания несвязанных подграфов за область видимости, в то время как связи графа имеют фиксированную длину ***linkDistance*** и выполняют роль геометрических ограничений. Дополнительные пользовательские воздействия и ограничения могут быть применены в событии ***'tick'***, путем обновления атрибутов x и y узлов.
[](http://bl.ocks.org/mbostock/4062045)
Для всестороннего обзора возможностей с примерами, смотрите [видеодоклад](https://vimeo.com/29458354) одного из ключевых разработчиков D3 Майка Бостока и [презентацию](http://mbostock.github.io/d3/talk/20110921/#0) из этого доклада.
Несколько забавных примеров: [divergent forces](http://bl.ocks.org/mbostock/1021841), [multiple foci](http://bl.ocks.org/mbostock/1021953), [graph constructor](http://bl.ocks.org/mbostock/929623), [force-directed tree](http://bl.ocks.org/mbostock/1062288), [force-directed symbols](http://bl.ocks.org/mbostock/1062383), [force-directed images and labels](http://bl.ocks.org/mbostock/950642), [force-directed states](http://bl.ocks.org/mbostock/1073373), [sticky force layout](http://bl.ocks.org/mbostock/3750558).
Как и другие классы в D3, Layouts следуют [приему method chaining](https://en.wikipedia.org/wiki/Method_chaining), когда методы сеттеров возвращают свой Layout, позволяя выстраивать множество сеттеров в одну цепочку вызовов. В отличие от некоторых других реализаций Layouts, Force Layout сохраняет ссылку на узлы и связи графа внутри себя; таким образом, каждый экземпляр Force Layout может быть использован только с одним набором данных.
### d3.layout.force()
Создает новый force-directed layout со следующими настройками по умолчанию: size 1×1, link strength 1, friction 0.9, distance 20, charge strength -30, gravity strength 0.1, theta parameter 0.8 (перечисленные параметры будут описаны ниже). По умолчанию узлы и связи графа — пустые массивы, и когда Layout запускается, внутренний параметр «охлаждения» alpha устанавливается в 0.1. Общий шаблон для построения force-directed layouts — это установка всех конфигурационных свойств, и затем вызов метода ***.start()***:
```
var force = d3.layout.force()
.nodes(nodes)
.links(links)
.size([w, h])
.linkStrength(0.1)
.friction(0.9)
.linkDistance(20)
.charge(-30)
.gravity(0.1)
.theta(0.8)
.alpha(0.1)
.start();
```
Обратите внимание, что, в отличие от других D3 Layouts, force-directed layout не связан с определенным визуальным представлением. Обычно узлы отображаются как SVG элементы circle, а связи отображаются как SVG элементы line. Но вы также можете отобразить узлы как [символы](http://bl.ocks.org/mbostock/1062383) или [изображения](http://bl.ocks.org/mbostock/950642).
### force.size([width, height])
Если параметр ***size*** передан, устанавливает доступный размер лейаута (ширину и высоту). В противном случае возвращает текущий размер, который по умолчанию равен [1, 1]. В force-directed layout размер влияет на две вещи: гравитационный центр и начальную случайную позицию добавляемых узлов (их координаты x и y). Центр гравитации рассчитывается просто [x/2, y/2]. При добавлении узлов в Force Layout, если они не имеют уже установленных атрибутов x и y, тогда эти атрибуты инициализируются с использованием равномерного случайного распределения в диапазоне [0, x] и [0, y], соответственно.
### force.linkDistance([distance])
Если параметр ***distance*** передан, устанавливает указанное в нем расстояние между связанными узлами (длину связей). В противном случае, возвращает текущую длину связей, которая по умолчанию равна 20. Если ***distance*** константа, то все связи будут иметь одинаковую длину. Иначе, если ***distance*** — функция, тогда эта функция вычисляется для каждой связи (по порядку). Функция принимает два аргумента — связь и ее индекс; контекст `this` функции имеет значение текущего Force Layout. Возвращаемое функцией значение используется для установки длины каждой связи. Функция вычисляется при запуске (метод **.*start()***) лейаута.
Связи реализованы не как «силы упругости», что распространено в иных force-directed лейаутах, но как слабые геометрические ограничения. На каждое событие ***'tick'*** лейаута, расстояние между каждой парой связанных узлов вычисляется и сравнивается с целевым расстоянием; затем связи перемещаются ближе или дальше друг от друга, пока не сойдутся на нужном расстоянии. Такой подход вкупе с методом численного интегрирования Верле значительно более стабилен, нежели подходы, использующие силы упругости, а также допускает гибкую реализацию других ограничений в обработчике события ***'tick'***, таких как иерархическое представление.
### force.linkStrength([strength])
Если параметр ***strength*** передан, устанавливает указанную жесткость связей в диапазоне [0,1]. В противном случае, возвращает текущую жесткость, которая по умолчанию равна 1. Если ***strength*** константа, то все связи будут иметь одинаковую жесткость. Иначе, если ***strength*** — функция, тогда эта функция вычисляется для каждой связи (по порядку). Функция принимает два аргумента — связь и ее индекс; контекст `this` функции имеет значение текущего Force Layout. Возвращаемое функцией значение используется для установки жесткости каждой связи. Функция вычисляется при запуске (метод **.*start()***) лейаута.
### force.friction([friction])
Если параметр ***friction*** передан, устанавливает указанный коэффициент трения. В противном случае, возвращает текущий коэффициент, который по умолчанию равен 0.9. Наименование этого параметра, возможно, вводит в заблуждение; он не соответствует стандартному коэффициенту трения (из физики). Скорее он больше похож на затухание скорости: на каждое событие ***'tick'*** процесса моделирования скорость узлов вычисляется на основе параметра ***friction***. Так, значение 1 соответствует лишенной трения среде, а значение 0 замораживает все узлы на месте. Значения вне диапазона [0,1] не рекомендуются и могут иметь дестабилизирующие эффекты.
### force.charge([charge])
Если параметр ***charge*** передан, устанавливает указанную силу заряда узла. В противном случае, возвращает текущую силу заряда, которая по умолчанию равна -30. Если ***charge*** константа, то все узлы будут иметь одинаковую силу заряда. Иначе, если ***charge*** — функция, тогда эта функция вычисляется для каждого узла (по порядку). Функция принимает два аргумента — узел и его индекс; контекст `this` функции имеет значение текущего Force Layout. Возвращаемое функцией значение используется для установки силы заряда каждого узла. Функция вычисляется при запуске (метод **.*start()***) лейаута.
Отрицательное значение силы заряда приводит к отталкиванию узлов, а положительное значение приводит к притяжению узлов. Для представления графа должны использоваться отрицательные величины; для [симуляции](http://mbostock.github.com/protovis/ex/nbody.html) [задачи N тел](https://ru.wikipedia.org/wiki/Гравитационная_задача_N_тел) могут быть использованы положительные величины. Как предполагается, все узлы являются бесконечно малыми точками с равным зарядом и массой. Силы зарядов эффективно реализованы с помощью [алгоритма Барнса-Хата](http://arborjs.org/docs/barnes-hut) путем вычисления [дерева квадрантов](https://github.com/d3/d3-3.x-api-reference/blob/master/Quadtree-Geom.md) при каждом событии ***'tick'***. Установка силы заряда равной 0 отключает вычисление дерева квадрантов, что **может заметно улучшить производительность**, если вам такая функциональность не требуется.
### force.chargeDistance([distance])
Если параметр ***distance*** передан, устанавливает максимальное расстояние, на котором действуют силы заряда узла. В противном случае, возвращает текущее максимальное расстояние, которое по умолчанию равно бесконечности. Определение конечного расстояния улучшает производительность Force Layout и дает на выходе более локализованный лейаут; это особенно полезно в сочетании с пользовательской гравитацией ***gravity***.
### force.theta([theta])
Если параметр ***theta*** передан, устанавливает критерий аппроксимации Барнса-Хата. В противном случае, возвращает текущее значение, которое по умолчанию равно 0.8. В отличие от связей, которые влияют только на два связанных узла, сила заряда имеет всеобщее значение: каждый узел оказывает влияние на все остальные узлы, даже если они находятся на несвязанных подграфах.
Чтобы избежать задержки, связанной с квадратичной временной сложностью, Force Layout использует [алгоритм Барнса-Хата](http://en.wikipedia.org/wiki/Barnes-Hut_simulation), который имеет [временную сложность](https://ru.wikipedia.org/wiki/Временная_сложность_алгоритма) O(n log n) за один ***'tick'***. На каждое событие ***'tick'*** создается дерево квадрантов для сохранения текущей позиции узла; затем для каждого узла вычисляется сумма сил зарядов всех остальных узлов. Для групп узлов, которые находятся далеко, сила заряда аппроксимируется обработкой отдаленной группы узлов как одного большого узла. ***Theta*** определяет точность вычисления: если отношение площади квадранта в дереве квадрантов к расстоянию между узлом и центром масс квадранта меньше чем ***theta***, все узлы в данном квадранте обрабатываются как один большой узел, а не вычисляются по отдельности.
### force.gravity([gravity])
Если параметр ***gravity*** передан, устанавливает силу гравитационного притяжения. В противном случае, возвращает текущую гравитационную силу, которая по умолчанию равна 0.1. Наименование этого параметра, возможно, вводит в заблуждение; он не соответствует [физической гравитации](https://ru.wikipedia.org/wiki/Гравитация) (которая может быть имитирована присваиванием параметру ***charge*** положительного значения). Вместо этого параметр ***gravity*** реализован как небольшое геометрическое ограничение, подобное виртуальной пружине, соединяющей каждый узел с центром лейаута. Такой подход обладает замечательными свойствами: возле центра лейаута сила гравитационного притяжения практически равна нулю, что предотвращает любое локальное искажение лейаута; поскольку узлы выдвинуты дальше от центра, сила гравитационного притяжения усиливается в линейной пропорции к расстоянию. Таким образом, сила гравитационного притяжения всегда будет преодолевать отталкивающие силы заряда на определенном пороге, препятствуя выходу несвязных узлов за границы лейаута.
Гравитация может быть отключена путем установки силы гравитационного притяжения равной нулю. При отключении гравитации рекомендуется реализовать какое-нибудь другое геометрическое ограничение для предотвращения выхода узлов за границы лейаута.
### force.nodes([nodes])
Если параметр ***nodes*** передан, устанавливает указанные в массиве узлы графа. В противном случае возвращает текущий массив узлов, который по умолчанию пуст. Каждый узел имеет следующие атрибуты:
* index — индекс (отсчет индекса с 0) узла в массиве nodes.
* x — координата x текущей позиции узла.
* y — координата y текущей позиции узла.
* px — координата x предыдущей позиции узла.
* py — координата y предыдущей позиции узла.
* fixed — булевское значение, отражающее, зафиксирована ли позиция узла.
* weight — число связанных с узлом ребер.
Эти атрибуты не обязательно устанавливать перед передачей узла Force Layout; если они не установлены, соответствующие значения по умолчанию будут инициализированы Force Layout при вызове метода ***.start()***. Однако, имейте в виду, что если вы храните какие-то другие данные в ваших узлах, ваши атрибуты данных не должны конфликтовать с вышеприведенными свойствами, используемыми Force Layout.
### force.links([links])
Если параметр ***links*** передан, устанавливает указанные в массиве связи графа. В противном случае возвращает текущий массив связей, который по умолчанию пуст. Каждая связь имеет следующие атрибуты:
* source — начальный узел (элемент массива nodes)
* target — конечный узел (элемент массива nodes)
Примечание: значения атрибутов source и target могут быть первоначально заданы как индексы в массиве nodes; они будут заменены ссылками после вызова метода ***.start()***. Объекты link могут иметь дополнительные поля, задаваемые пользователем; эти данные могут быть использованы для вычисления жесткости ***linkStrength*** связи и расстояния ***linkDistance*** между узлами связи, иcпользуя функцию доступа.
### force.start()
Запуск процесса моделирования; этот метод должен быть вызван при создании Force Layout, после установки узлов и связей. Кроме того, его нужно вызывать вновь, когда узлы или связи изменяются. Force Layout использует «охлаждающий» параметр ***alpha***, который регулирует температуру Force Layout: поскольку физическое моделирование сводится к статичному лейауту, температура снижается, вследствие чего узлы замедляют движение. В конечном счете, ***alpha*** опускается ниже определенного порога, и моделирование останавливается окончательно, освобождая ресурсы. Force Layout может быть вновь «подогрет» с помощью метода ***.resume()*** или путем перезапуска; также это происходит автоматически при использовании режима ***drag***.
При запуске Force Layout инициализирует различные атрибуты связанных с ним узлов. Индекс каждого узла вычисляется путем перебора массива, начиная с 0. Начальные координаты узла x и y, если их значение не указано, вычисляются на основе соседних узлов: если связанный узел уже имеет начальное значение x и y, соответствующие координаты применяются к новому узлу. Это увеличивает устойчивость лейаута графа при добавлении новых узлов, в отличие от использования значений по умолчанию, которые инициализируют координаты случайным образом в пределах размера лейаута. Координаты px и py предыдущей позиции узла (если не указаны) принимают значение начальных координат, что дает новым узлам начальную скорость равную нулю. Наконец, значение fixed по умолчанию равно false.
Force Layout также инициализирует атрибуты source и target связей links: эти атрибуты могут быть заданы не только прямыми ссылками на узлы nodes, но и числовыми индексами узлов (это удобно при считывании данных из файла JSON или иного статического описания). Атрибуты source и target связей заменяются соответствующими записями в ***nodes***, только если эти атрибуты — числа; таким образом, эти атрибуты не затрагиваются на уже существующих связях при перезапуске Force Layout. Параметры ***linkDistance*** и ***linkStrength*** связей также вычисляются при запуске.
### force.alpha([value])
Получает или задает «охлаждающий» параметр ***alpha*** процесса моделирования Force Layout. Если значение передано, устанавливает параметр ***alpha*** и возвращает Force Layout. Если переданное значение больше нуля, этот метод также перезапускает Force Layout, если он еще не запущен, вызывая событие ***'start'*** и включая ***'tick'***-таймер. Если переданное значение не положительно, и Force Layout запущен, этот метод останавливает Force Layout на следующем событии ***'tick'*** и вызывает событие ***'end'***. Если значение не задано, этот метод возвращает текущее значение «охлаждающего» параметра.
### force.resume()
Эквивалентен вызову:
```
force.alpha(.1);
```
Устанавливает «охлаждающий» параметр ***alpha*** в 0.1 и затем перезапускает [таймер](https://github.com/d3/d3-3.x-api-reference/blob/master/Transitions.md#d3_timer). Как правило, вам не нужно вызывать этот метод прямо; он вызывается автоматически методом ***.start()***. Он также вызывается автоматически методом ***.drag()*** при перетаскивании.
### force.stop()
Эквивалентен вызову:
```
force.alpha(0);
```
Завершает процесс моделирования, устанавливая охлаждающий параметр ***alpha*** в 0. Этот метод может использоваться для явной остановки процесса моделирования. Если вы не остановите Force Layout явно, это произойдет автоматически после того, как параметр «охлаждения» ***alpha*** опустится ниже определенного порога.
### force.tick([value])
Выполняет один шаг моделирования Force Layout. Этот метод может быть использован вместе с методами ***.start()*** и ***.stop()*** для вычисления статического лейаута. Например:
```
force.start();
for (var i = 0; i < n; ++i) force.tick();
force.stop();
```
Количество итераций зависит от размера графа и его сложности. Выбор начальных позиций также имеет важное значение. Например, здесь узлы расположены по диагонали:
```
var n = nodes.length;
nodes.forEach(function(d, i) {
d.x = d.y = width / n * i;
});
```
Если вы не инициализируете позиции узлов вручную, Force Layout инициализирует их случайным образом, приводя к несколько непредсказуемому подведению.
### force.on([type, listener])
Регистрирует определенный обработчик ***listener*** для обработки событий определенного типа ***type*** от Force Layout. В настоящее время поддерживаются только события ***'start'***, ***'tick'***, и ***'end'***.
Объекты-события, которые передаются функции-обработчику, являются пользовательскими объектами, созданными с использованием [d3.dispatch()](https://github.com/d3/d3-3.x-api-reference/blob/master/Internals.md#events). Каждый объект-событие имеет два свойства: type (строка, 'start', 'tick', или 'end'), и alpha, являющееся текущим значением «охлаждающего» параметра ***alpha***. Свойство ***event.alpha*** может быть использовано для мониторинга прогресса моделирования Force Layout или для внесения в этот процесс ваших собственных корректив.
Событие ***'start'*** посылается как при начальном запуске процесса моделирования, так и каждый раз, когда моделирование перезапускается.
Событие ***'tick'*** отправляется на каждом шаге моделирования. Отслеживайте события 'tick' для обновления отображаемых позиций узлов и связей. Например, если вы изначально отображаете узлы и связи следующим образом:
```
var link = vis.selectAll("line")
.data(links)
.enter().append("line");
var node = vis.selectAll("circle")
.data(nodes)
.enter().append("circle")
.attr("r", 5);
```
Вы можете установить их позиции для каждого шага процесса моделирования:
```
force.on("tick", function() {
link.attr("x1", function(d) { return d.source.x; })
.attr("y1", function(d) { return d.source.y; })
.attr("x2", function(d) { return d.target.x; })
.attr("y2", function(d) { return d.target.y; });
node.attr("cx", function(d) { return d.x; })
.attr("cy", function(d) { return d.y; });
});
```
В данном случае, мы сохранили набор узлов (node) и связей (link) на этапе инициализации, чтобы нам не было нужно повторно выбирать узлы на каждом шаге моделирования. При желании вы можете отобразить узлы и связи иным образом; например, вы можете использовать [символы](https://github.com/d3/d3-3.x-api-reference/blob/master/SVG-Shapes.md#symbol) вместо кругов.
Событие ***'end'*** отправляется, когда внутренний «охлаждающий» параметр ***alpha*** опускается ниже пороговой величины (0.005) и обнуляется.
### force.drag()
Связывает поведение с узлами для интерактивного перетаскивания, как мышью, так и касанием. Используйте его в сочетании с методом [call](https://github.com/d3/d3-3.x-api-reference/blob/master/Selections.md#call) для узлов; например, вызовите ***node.call(force.drag)*** для инициализации. В режиме drag при наведении курсора мыши на узел его атрибут ***fixed*** устанавливается в true, тем самым останавливая его движение. Фиксация узла при наведении мыши (mouseover), в отличии от фиксации при клике по узлу (mousedown), упрощает задачу вылавливания нужного узла. Когда происходит событие 'mousedown', и на каждое последующее событие 'mousemove' вплоть до события 'mouseup', центр узла устанавливается в текущую позицию мыши. Кроме того, каждое событие 'mousemove' инициирует метод ***.resume()*** Force Layout, «подогревая» процесс моделирования. Если вы хотите, чтобы перемещенные узлы зафиксировались после перетаскивания, установите атрибут ***fixed*** в true при событии 'dragstart', как сделано в [этом примере](http://bl.ocks.org/mbostock/3750558).
*Примечание реализации*: обработчики событий 'mousemove' и 'mouseup' зарегистрированы для текущего окна window, так что когда пользователь начинает перетаскивать узел, процесс перетаскивания не будет прекращен, даже если курсор мыши вышел за пределы лейаута. Каждый обработчик событий использует пространство имен «force», чтобы избежать конфликта с другими обработчиками событий, которые может привязать к узлам или к окну пользователь. Если узел перемещается путем перетаскивания, последующее событие 'click', которое вызовется при отпускании кнопки мыши ('mouseup'), будет отменено. Если вы регистрируете обработчик события 'click', вы можете проигнорировать события 'click', возникающие при перетаскивании, следующим образом:
```
selection.on("click", function(d) {
if (d3.event.defaultPrevented) return; // ignore drag
otherwiseDoAwesomeThing();
});
```
Напоследок ознакомьтесь с этими двумя примерами: [collapsible force layout](http://bl.ocks.org/mbostock/1093130) и [divergent forces](http://bl.ocks.org/mbostock/1021841). | https://habr.com/ru/post/302968/ | null | ru | null |
# Городские легенды о медленных вызовах виртуальных функций
Традиционно компиляторы реализуют вызовы виртуальных функций через двойную косвенную адресацию — если класс содержит хотя бы одну виртуальную функцию, то в начале каждого объекта этого класса хранится адрес таблицы виртуальных функций. Если компилятор не знает конкретный тип объекта, на который указывает указатель, то для вызова виртуальной функции нужно сначала взять указатель на объект, прочитать адрес начала таблицы, затем по номеру метода прочитать адрес, где хранится реализация функции, затем вызвать функцию.
Процесс поиска конкретной функции по указателю на объект называется поздним связыванием и выполняется во время работы программы. Позднее связывание не только увеличивает накладные расходы на вызов, но и препятствует оптимизации кода компилятором. Из-за этого сами виртуальные функции принято считать замедляющими работу.
В тексте выше ключевое слово «если». Что, если компилятор знает, какую функцию на самом деле надо вызывать?
В Стандарте (далее ссылки на Стандарт C++03) ничего не сказано про таблицы виртуальных методов. Вместо этого в 5.2.2/1 ([expr.call], «вызов функции») сказано, что если в программе содержится вызов виртуальной функции, то должна быть вызвана соответствующая функция, выбранная по правилам из 10.3/2 ([class.virtual], «виртуальные функции»), а там сказано, что TL;DR; должна быть выбрана функция из самого производного класса, в котором функция определена или переопределена.
Соответственно, если компилятор может, разобрав код, выяснить точный тип объекта, он не обязан использовать позднее связывание – и не важно, вызывается метод у конкретного объекта, по ссылке или по указателю на объект.
От бессмысленных рассуждений перейдем к коду, который будем пробовать на [gcc.godbolt.org](http://gcc.godbolt.org)
Нам понадобятся вот эти два класса:
```
class Base {
public:
virtual ~Base() {}
virtual int Magic() {
return 9000;
}
};
class Derived : public Base {
public:
virtual int Magic() {
return 100500;
}
};
```
Для начала такой код:
```
int main()
{
Derived derived;
return derived.Magic();
}
```
clang 3.4.1 с -O2 отвечает на это так:
```
main: # @main
movl $100500, %eax # imm = 0x18894
ret
```
Нетрудно видеть, что машинный код соответствует программе, содержащей только *return 100500;* Это не особенно интересно — ведь здесь нет указателей и ссылок.
Ладно, медленно помешивая, добавляем указатели и ссылки:
```
int magic( Base& object )
{
return object.Magic();
}
int main()
{
Base* base = new Derived();
int result = magic( *base );
delete base;
return result;
}
```
clang 3.4.1 с -O2 отвечает на это так:
```
magic(Base&): # @magic(Base&)
movq (%rdi), %rax
jmpq *(%rax) # TAILCALL
main: # @main
movl $100500, %eax # imm = 0x18894
ret
```
~~ОХ ЩИ ОШИБКА В КОМПИЛЯТОРЕ~~ Нет, с компилятором все в порядке, но агрессивность оптимизации отрицать бессмысленно. Снова *return 100500;*
Для сравнения, gcc 4.9.0 с -O2:
```
main:
subq $8, %rsp
movl $8, %edi
call operator new(unsigned long)
movq vtable for Derived+16, (%rax)
movq %rax, %rdi
call Derived::~Derived()
movl $100500, %eax
addq $8, %rsp
ret
```
*call Derived::~Derived()* – из-за виртуального деструктора, gcc в таких случаях ставит вызов *::operator delete()* внутрь деструктора:
```
Derived::~Derived():
jmp operator delete(void*)
```
хотя мог бы и по месту подставить. Вот так:
```
movq %rax, %rdi
call operator delete(void*)
```
Мог бы, но не стал. В то же время тело метода *Derived::Magic()* подставлено в место вызова и оптимизировано вместе с окружающим кодом.
Небольшое отступление… Если вы любите пространно рассуждать о том, насколько хорошо компилятор в принципе может оптимизировать код, пример выше для вас. И вызов *Derived::Magic()*, и удаление объекта компилятор мог оптимизировать одинаково успешно, но один из них он оптимизировал, а второй – нет. Отступление закончено.
Для сравнения, gcc 4.9.0 с -O1
```
magic(Base&):
subq $8, %rsp
movq (%rdi), %rax
call *(%rax)
addq $8, %rsp
ret
main:
pushq %rbp
pushq %rbx
subq $8, %rsp
movl $8, %edi
call operator new(unsigned long)
movq %rax, %rbx
movq vtable for Derived+16, (%rax)
movq %rax, %rdi
call magic(Base&)
movl %eax, %ebp
testq %rbx, %rbx
je .L12
movq (%rbx), %rax
movq %rbx, %rdi
call *16(%rax)
.L12:
movl %ebp, %eax
addq $8, %rsp
popq %rbx
popq %rbp
ret
```
Вот, может ведь, если хорошо попросить. В этом коде «все в порядке» — куча доступов к памяти и вызов метода инструкцией call с косвенной адресацией (*call \*16(%rax)*).
Впрочем, примеры успеха с -O2 выглядят надуманными – весь код находится в одной единице трансляции, а это существенно упрощает оптимизацию.
На помощь спешит [LTO](https://gcc.gnu.org/wiki/LinkTimeOptimization) (или как там называется оптимизация нескольких единиц трансляции в вашем компиляторе).
Делим код на несколько единиц трансляции…
```
//Classes.h
class Base {
public:
virtual int Magic();
virtual ~Base();
};
class Derived : public Base {
public:
virtual int Magic();
};
//Classes.cpp
#include
#include
Base::~Base()
{
}
int Base::Magic()
{
return 9000;
}
int Derived::Magic()
{
return 100500;
}
//main.cpp
#include
int magic( Base& object )
{
return object.Magic();
}
int main()
{
Base\* base = new Derived();
int result = magic( \*base );
delete base;
return result;
}
```
Здесь и далее будем использовать MinGW с gcc 4.9.0
```
g++ -flto -g -O3 main.cpp Classes.cpp
objdump -d -M intel -S --no-show-raw-insn a.exe >a.txt
```
```
int main()
{
402830: push ebp
402831: mov ebp,esp
402833: and esp,0xfffffff0
402836: sub esp,0x10
402839: call 402050 <___main>
Base* base = new Derived();
40283e: mov DWORD PTR [esp],0x4
вызов ::operator new()
402845: call 4015d8 <__Znwj>
запись указателя на vtable
40284a: mov DWORD PTR [eax],0x404058
int result = magic( *base );
delete base;
402850: mov ecx,eax
402852: call 4015c0 <__ZN7DerivedD0Ev>
return result;
}
на место возвращаемого значения записывается константа
402857: mov eax,0x18894
40285c: leave
40285d: ret
```
Здесь нас интересует инструкция *mov eax, 0x18894* (100500 в шестнадцатеричной записи) — снова компилятор выбрал нужную функцию, подставил ее тело в место вызова и оптимизировал окружающий код.
Слишком просто, поэтому добавляем фабрику (Derived и Base те же)…
```
//Factory.h
#include
class Factory {
public:
static Base\* CreateInstance();
};
//Factory.cpp
#include
Base\* Factory::CreateInstance()
{
return new Derived();
}
//main.cpp
#include
int magic( Base& object )
{
return object.Magic();
}
int main()
{
Base\* base = Factory::CreateInstance();
int result = magic( \*base );
delete base;
return result;
}
```
Компилируем, дизассемблируем… Исходно результат выглядит не очень понятно – из-за агрессивной оптимизации машинный код и исходный код оказались сопоставлены не самым удобным для чтения образом, ниже машинный код оставлен как есть, а часть строк исходного кода размещена максимально близко к соответствующему машинному коду.
```
int main()
{
402830: push ebp
402831: mov ebp,esp
402833: push esi
402834: push ebx
402835: and esp,0xfffffff0
402838: sub esp,0x10
40283b: call 402050 <___main>
return new Derived();
402840: mov DWORD PTR [esp],0x4
вызов ::operator new()
402847: call 4015d8 <__Znwj>
40284c: mov ebx,eax
int magic( Base& object )
{
return object.Magic();
40284e: mov ecx,eax
запись указателя на vtable
402850: mov DWORD PTR [eax],0x404058
прямой вызов Derived::Magic()
402856: call 401580 <__ZN7Derived5MagicEv>
int main()
{
delete base;
40285b: mov ecx,ebx
40285d: mov esi,eax
40285f: call 4015b0 <__ZN7DerivedD0Ev>
return result;
402864: lea esp,[ebp-0x8]
402867: mov eax,esi
402869: pop ebx
40286a: pop esi
40286b: pop ebp
40286c: ret
(дальше пропущено)
```
Здесь нас интересует строка
```
402856: call 401580 <__ZN7Derived5MagicEv>
```
Это прямой вызов *Derived::Magic()*:
```
00401580 <__ZN7Derived5MagicEv>:
int Derived::Magic()
{
return 100500;
}
401580: mov eax,0x18894
401585: ret
```
Компилятор правильно определил, какую функцию нужно вызвать, но не стал подставлять тело функции в место вызова.
Параметризуем фабрику (Base и Derived те же)…
```
//Factory.h
#include
enum ClassType {
BaseType,
DerivedType
};
class Factory {
public:
static Base\* CreateInstance(ClassType classType);
};
//Factory.cpp
#include
Base\* Factory::CreateInstance(ClassType classType)
{
switch( classType ) {
case BaseType:
return new Base();
case DerivedType:
return new Derived();
}
}
//main.cpp
#include
int magic( Base& object )
{
return object.Magic();
}
int main()
{
Base\* base = Factory::CreateInstance(DerivedType);
int result = magic( \*base );
delete base;
return result;
}
```
Получаем… тот же код, что и в предыдущей попытке.
Теперь ~~party hard~~ будем вычислять параметр фабрики при работе программы…
```
#include
#include
int magic( Base& object )
{
return object.Magic();
}
int main()
{
Base\* base = Factory::CreateInstance(rand() ? BaseType : DerivedType);
int result = magic( \*base );
delete base;
return result;
}
```
Получаем… (результат опять выглядит не очень понятно)
```
int main()
{
402830: push ebp
402831: mov ebp,esp
402833: push esi
402834: push ebx
402835: and esp,0xfffffff0
402838: sub esp,0x10
40283b: call 402050 <___main>
Base* base = Factory::CreateInstance(rand() ? BaseType : DerivedType);
вызов rand()
402840: call 4027c8 <_rand>
Base* Factory::CreateInstance(ClassType classType)
{
switch( classType ) {
проверка из объединенных вместе тернарного оператора и switch
402845: test eax,eax
402847: mov DWORD PTR [esp],0x4
ветвление
40284e: jne 402875 <_main+0x45>
если rand() вернула не ноль, происходит переход вперед на адрес 402875
если rand() вернула ноль, перехода нет и ...
case DerivedType:
return new Derived();
вызов ::operator new()
402850: call 4015d8 <__Znwj>
запись указателя на vtable класса Derived
402855: mov DWORD PTR [eax],0x404070
40285b: mov ebx,eax
int magic( Base& object )
{
return object.Magic();
здесь происходит слияние двух ветвей -
управление либо "проваливается" сюда, либо безусловно
приходит из ветви, начинающейся с адреса 402875 (rand() != 0)
40285d: mov eax,DWORD PTR [ebx]
40285f: mov ecx,ebx
косвенный вызов Magic()
402861: call DWORD PTR [eax]
402863: mov esi,eax
int main()
{
delete base;
402865: mov eax,DWORD PTR [ebx]
402867: mov ecx,ebx
косвенный вызов удаления объекта
402869: call DWORD PTR [eax+0x8]
return result;
}
40286c: lea esp,[ebp-0x8]
40286f: mov eax,esi
402871: pop ebx
402872: pop esi
402873: pop ebp
402874: ret
Base* Factory::CreateInstance(ClassType classType)
{
switch( classType ) {
case BaseType:
return new Base();
сюда управление приходит при ветвлении по адресу 40284e
если rand() != 0
вызов ::operator new()
402875: call 4015d8 <__Znwj>
запись указателя на vtable класса Base
40287a: mov DWORD PTR [eax],0x404058
402880: mov ebx,eax
окончание ветви и безусловный переход в точку слияния
402882: jmp 40285d <_main+0x2d>
```
Довольно любопытный результат. Код метода фабрики полностью подставлен по месту. В зависимости от результата вызова функции *rand()* прямо внутри *main()* выполняется ветвление и создание экземпляров соответствующих классов. Компилятор мог бы дальше поставить и прямые вызовы в каждой из ветвей, но не справился с оптимизацией и скатился в два косвенных вызова – один для вызова метода *Magic()* с поздним связыванием, второй – для удаления объекта, тоже с поздним связыванием.
Как видим, вызовы виртуальных функций не обязывают использовать позднее связывание, а что произойдет в реальном мире – зависит от компилятора, его настроек и конкретного кода.
*Дмитрий Мещеряков,
департамент продуктов для разработчиков* | https://habr.com/ru/post/248429/ | null | ru | null |
# Небольшие трюки с Elasticsearch
Небольшая заметка, скорее для себя, о мелких трюках по восстановлению данных в Elasticsearch. Как починить красный индекс если нет бэкапа, что делать если удалил документы, а копии не осталось — к сожалению в официальной документации об этих возможностях умалчивают.
Бэкапы
------
Первое, что необходимо сделать, это настроить бэкапы важных данных. Как это делается описано в [**официальной документации**](https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html).
В целом, ничего сложного. В простейшем варианте создаем шару на другом сервере, монтируем ее ко всем узлам эластика любым удобным способом (nfs, smbfs, whatever). Далее используем cron, ваше приложение или что угодно для отправки запросов на периодическое создание снэпшотов.
Первый снэпшот будет долгим, последующие будут содержать только дельту между состояниями индекса. Учтите, что если вы периодически делаете **forcemerge**, дельта будет огромной и соответственно время создания снэпшота будет примерно как в первый раз.
Что следует учесть:
* Проверяйте статус бэкапов, например с помощью \_cat: `curl localhost:9200/_cat/snapshots/**yourbackuprepo**/`. Снэпшоты в статусе **Partial** или **Failed** — не ваши бро.
* Начиная с ES 6.x эластик очень требователен к заголовкам запросов. Если вы делаете их вручную (не через API), проверьте что у вас выставлен `Content-Type: application/json`, иначе все ваши запросы просто обламываются и бэкапа не происходит
* Снэпшот невозможно восстановить в открытый индекс. Его надо обязательно закрыть или удалить сначала. Однако вы можете восстановить снэпшот рядом, используя rename\_pattern, rename\_replacement ([см. пример в доке](https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html#_restore)). Кроме того, при восстановлении снэпшота также восстанавливаются его настройки, в том числе алиасы, количество реплик и т.п. Если вам этого не надо, добавьте в запрос на восстановление index\_settings ([см. доку для примера](https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html#_changing_index_settings_during_restore)) с нужными изменениями.
* Репоз (шару) со снэпшотами можно подключить к более чем одному кластеру и восстанавливать снэпшоты из любого кластера в любой другой. Главное чтобы версии эластиков были совместимы.
В общем смотрите в документацию, там эта тема более-менее раскрыта.
Elasticdump
-----------
[Небольшая утилита](https://github.com/taskrabbit/elasticsearch-dump) на nodejs, позволяющая копировать данные из одного индекса в другой индекс, кластер, файл, stdout.
Вывод в файл или stdout кстати можно использовать как альтернативный метод бэкапа — на выходе получается обычный валидный json (что-то вроде sql dump), который можно переиспользовать как хотите. Например, можно засунуть вывод в pipe, где ваш скрипт будет как-то преобразовывать данные и отправлять в другое хранилище, например clickhouse. Простейшие js преобразования можно делать прямо самим elasticdump, есть соответствующий ключ **--transform**. В общем, полёт фантазии.
Из подводных камней:
* Как метод бэкапа — значительно медленнее чем снэпшоты. Плюс бэкап растянут по времени, поэтому результат на часто изменяющемся индексе может быть неконсистентным. Имейте ввиду.
* Не используйте nodejs из репозитория debian, там слишком старая версия, отрицательно влияющая на стабильность тулзы.
* Стабильность работы может варьироваться, особенно если одна из сторон перегружена. Не пытайтесь бэкапить с одного сервера на другой запуская тулзу на офисной машине — весь трафик польется через нее.
* Фигово копирует маппинги. Если у вас там что-то сложное, то создайте индекс вручную, а уже потом заливайте в него данные.
* Иногда имеет смысл поменять размер чанка (параметр --limit). Этот параметр напрямую влияет на скорость копирования.
Для сливания большого количества индексов одновременно в комплекте есть multielasticdump с упрощенным набором опций, но зато все индексы сливаются параллельно.
**Замечание!** Автор утилиты сообщил, что у него больше нет времени на поддержку, поэтому [**программа ищет нового мэйнтейнера**](https://github.com/taskrabbit/elasticsearch-dump/issues/333).
Из личного опыта: утилита полезная, выручала не раз. Скорость и стабильность так себе, хотелось бы адекватную замену, но пока ничего на горизонте.
CheckIndex
----------
Итак, мы начинаем подбираться к тёмной стороне. Ситуация: индекс перешёл в состояние красный. В логах — что-то пошло не так, не совпадает чек сумма, наверное у вас навернулась память или диск:
`org.apache.lucene.index.CorruptIndexException: checksum failed (hardware problem?)`
Конечно у мамкиных админов никогда такое не происходит, потому что у них топовое железо с тройной репликацией, память суперECC с коррекцией абсолютно всех уровней ошибок на лету и вообще снэпшоты каждую секунду настроены.
Но реальность к сожалению иногда подкидывает и такие варианты, когда бэкап был относительно давно (если у вас индексируются гигабайты в час, слишком ли стар бэкап сделанный 2 часа назад?), данные восстановить неоткуда, репликация не успела и все в таком духе.
Конечно, если есть снэпшот, бэкап или т.п. — отлично, раскатывайте и не парьтесь. А если нет? К счастью, хотя бы часть данных все-таки можно спасти.
Первым делом, закройте индекс и/или выключите эластик, сделайте резервную копию провалившегося шарда.
У Lucene (а именно она работает бэкендом в elasticsearch) есть замечательный метод CheckIndex. Нам нужно всего лишь вызвать его над поломанным шардом. Lucene проверит все его сегменты и удалит поврежденные. Да, данные потеряются, но хотя бы не абсолютно все. Хотя тут как повезет.
Тут есть как минимум 2 способа.
### Способ 1: Прямо на узле
Нам поможет вот такой простенький скрипт
```
#!/bin/bash
pushd /usr/share/elasticsearch/lib
java -cp lucene-core*.jar -ea:org.apache.lucene... org.apache.lucene.index.CheckIndex "$@"
popd
```
Вызвав его без параметров получим что-то такое:
```
ERROR: index path not specified
Usage: java org.apache.lucene.index.CheckIndex pathToIndex [-exorcise] [-crossCheckTermVectors] [-segment X] [-segment Y] [-dir-impl X]
-exorcise: actually write a new segments_N file, removing any problematic segments
-fast: just verify file checksums, omitting logical integrity checks
-crossCheckTermVectors: verifies that term vectors match postings; THIS IS VERY SLOW!
-codec X: when exorcising, codec to write the new segments_N file with
-verbose: print additional details
-segment X: only check the specified segments. This can be specified multiple
times, to check more than one segment, eg '-segment _2 -segment _a'.
You can't use this with the -exorcise option
-dir-impl X: use a specific FSDirectory implementation. If no package is specified the org.apache.lucene.store package will be used.
**WARNING**: -exorcise *LOSES DATA*. This should only be used on an emergency basis as it will cause
documents (perhaps many) to be permanently removed from the index. Always make
a backup copy of your index before running this! Do not run this tool on an index
that is actively being written to. You have been warned!
Run without -exorcise, this tool will open the index, report version information
and report any exceptions it hits and what action it would take if -exorcise were
specified. With -exorcise, this tool will remove any segments that have issues and
write a new segments_N file. This means all documents contained in the affected
segments will be removed.
This tool exits with exit code 1 if the index cannot be opened or has any
corruption, else 0.
```
Собственно, можем либо просто прогнать тест индекса, либо заставить CheckIndex его «починить», вырезав все поврежденное.
Люценовский индекс живет примерно по такому пути: /var/lib/elasticsearch/nodes/0/indices/str4ngEHashVa1uE/0/index/, где 0 и 0 — номер узла на сервере и номер шарда на узле. Страшное значение между ними — внутреннее название индекса — можно получить из вывода curl localhost:9200/\_cat/indices.
Я обычно делаю копию в другой каталог, а чиню in-place. После чего перезапускаю elasticsearch. Как правило все подхватывается, пусть и с потерей данных. Иногда индекс все равно не хочет зачитываться из-за файлов \*corrupted\* в папке шарды. Переместите их в безопасное место на время.
### Способ 2: Luke
(картинка из интернета)
Для работы с Lucene есть замечательная утилита [под названием **Luke**](https://github.com/DmitryKey/luke).
Тут все еще проще. Узнаем версию Lucene у вашего elasticsearch:
```
$ curl localhost:9200
{
"name" : "node00",
"cluster_name" : "main",
"cluster_uuid" : "UCbEivvLTcyWSQElOipgTQ",
"version" : {
"number" : "6.2.4",
"build_hash" : "ccec39f",
"build_date" : "2018-04-12T20:37:28.497551Z",
"build_snapshot" : false,
"lucene_version" : "7.2.1",
"minimum_wire_compatibility_version" : "5.6.0",
"minimum_index_compatibility_version" : "5.0.0"
},
"tagline" : "You Know, for Search"
}
```
Берем ту же версию Luke. Открываем в нем индекс (копию конечно) с галкой **Do not open IndexReader (when openning corrupted index)**. Далее жмем Tools / Check Index. Сначала рекомендую прогнать всухую, а уже потом в режиме починки. Дальше действия аналогичные — копируем назад эластику, перезапускаем/открываем индекс.
Восстановление удаленных документов
-----------------------------------
Ситуация: вы выполнили разрушительный запрос, который поудалял много/все нужные данные. А восстановить неоткуда, либо очень затратно. Ну конечно ССЗБ, что бэкапов нет, но и такое бывает.
К сожалению или счастью, Lucene никогда ничего не удаляет напрямую. Её философия ближе к CoW, поэтому удаленные данные на самом деле не удаляются, а лишь помечаются удаленными. Собственно удаление происходит при оптимизации индекса — живые данные из сегментов копируются во вновь созданные сегменты, старые сегменты просто удаляются. В общем, пока в статусе индекса deleted не 0, шансы вытащить есть.
```
$ curl localhost:9200/_cat/indices?v
health status index uuid pri rep docs.count docs.deleted store.size pri.store.size
green open data.0 R0fgvfPnTUaoI2KKyQsgdg 5 1 7238685 1291566 45.1gb 22.6gb
```
После forcemerge шансов нет.
Итак, первым делом закрываем индекс, стопаем эластик, копируем индекс (файлики) в безопасное место.
Вытащить индивидуальный удаленный документ невозможно. Можно только восстановить вообще все удаленные документы в указанном сегменте.
Для версий Lucene ниже 4 все очень просто. В Lucene API есть функция под названием undeleteAll. Можно вызвать ее прямо из **Luke** из предыдущего пункта.
Для более новых версий увы функционал выпилили. Но все-таки способ все еще есть. Информация о «живых» документах хранится в файликах \*.liv. Однако простое их удаление сделает индекс нечитаемым. Необходимо поправить файл segments\_N, чтобы он вообще забыл о их существовании.
Открываем файл segments\_N (N — целое число) в вашем любимом Hex-редакторе. Ориентироваться в нем нам поможет [**официальная документация**](https://lucene.apache.org/core/7_1_0/core/org/apache/lucene/index/SegmentInfos.html):
```
segments_N: Header, LuceneVersion, Version, NameCounter, SegCount, MinSegmentLuceneVersion, SegCount, CommitUserData, Footer
```
Из всего этого нам нужны значения DelGen (Int64) и DeletionCount (Int32). Первое надо сделать равным -1, а второе 0.
Найти их не сложно, они сразу за SegCodec, который весьма бросающаяся в глаза строка типа Lucene62. На данном скрине видно, что DelGen имеет значение 3, а DeletionCount — 184614. Заменяем первое на 0xFFFFFFFFFFFFFFFF, а второе на 0х00000000. Повторяем для всех необходимых сегментов, сохраняем.
Однако, пофикшенный индекс не захочет грузится, ссылаясь на ошибку контрольной суммы. Тут все еще проще. Берем Luke, загружаем индекс с отключенным IndexReader, Tools / Check Index. Делаем тестовый прогон и сразу же ловим, что segments\_N поврежден. Ожидается чексумма такая-то, а получена такая-то.
```
Caused by: org.apache.lucene.index.CorruptIndexException: checksum failed (hardware problem?) : expected=51fbdb5c actual=6e964d17
```
Ерунда! Берем ожидаемую контрольную сумму и вписываем в последние 4 байта файла.
Сохраняем. Прогоняем еще раз CheckIndex, чтобы убедиться что все ок и индекс загружается.
Et voilà! | https://habr.com/ru/post/416955/ | null | ru | null |
# Dagaz: Сумма технологий
***Итак, технологии интересуют меня, так сказать, по необходимости: потому что всякая цивилизация включает и то, к чему общество стремилось, и то, чего никто не замышлял.
Порой, и довольно часто, путь технологии открывал случай: искали же когда-то философский камень, а нашли фарфор.*
Станислав Лем.**
С самого начала работы над [проектом](https://glukkazan.github.io/), было понятно, что качественный AI мне жизненно необходим! Самому с собой играть скучно, а модуль для игры по сети — он неизвестно когда ещё будет. Я пытался писать ботов сам, но все они работали либо плохо, либо плохо и медленно. В конце концов, я устал заниматься этой самодеятельностью и нашёл шахматного [бота](http://omerkel.github.io/Garbochess-JS/oliver/), качество игры которого меня вполне устраивало. Но тут возникла проблема. Мне-то были нужны не только Шахматы. Тому, как я с этим боролся, и посвящена эта статья.
Если вы посмотрите на исходный код [Garbochess-JS](https://github.com/glinscott/Garbochess-JS/blob/master/js/garbochess.js) (кстати, на КДПВ фотография [Греты Гарбо](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D1%80%D0%B1%D0%BE,_%D0%93%D1%80%D0%B5%D1%82%D0%B0), знаменитой актрисы, в честь которой проект получил своё название), то сможете заметить, что красота исходного кода — это последнее из того, что интересовало его автора. В тексте присутствуют глобальные переменные и прочие милые мелочи, добросовестно портированные из первоначального [проекта](https://github.com/glinscott/Garbochess-3/tree/master/GarboChess3).
Для меня, самой большой проблемой стало то, что сам алгоритм никак не отделён от исключительно шахматной специфики, такой как оценка позиции, эвристики и прочее. Уже только по этой причине, код пришлось полностью переписывать. Это была большая работа (и она всё ещё продолжается до сих пор), но сегодня уже есть некоторые успехи, которыми я могу поделиться.
[](https://glukkazan.github.io/checkmate/platform-chess.htm)
**Немного о производительности**Этот бот всё ещё слишком требователен к ресурсам. Я работаю над этим, но пока что, он и на компьютерах довольно задумчив, а на телефонах тормозит просто безобразно. Для меня это всё равно большой прогресс, поскольку он играет так, как мог бы играть человек. Все предыдущие мои попытки были весьма далеки от этого.
Качество игры сильно зависит от того, какое количество позиций бот успеет рассмотреть за отведённое время (поэтому, на более быстрых компьютерах он будет играть заметно лучше). Количеством миллисекунд, отведённых на «размышление», можно управлять [через url](https://glukkazan.github.io/checkmate/platform-chess.htm?ai=1000), но здесь есть некоторая гранулярность, особенно заметная на медленных устройствах. Фактическое время поиска хода всегда будет больше заданного.
Не стоит устанавливать маленькие значения. Бот будет играть глупо. Я предупредил.
Можно заметить, что хотя эта игра (которую придумал Robert Price в 2001 году) похожа на [Шахматы](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B), оригинальный Garbochess с ней вряд ли бы справился. Это хорошая иллюстрация той задачи, что передо мной стояла. Мне следовало отделить [алгоритм](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/ab-ai-v5.js) поиска наилучшего хода, от всего [того](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/chess/chess-ai.js), что специфично для конкретных игр. Для того, чтобы можно было использовать его в разных играх, разумеется. Для чего же ещё?
Конечно, начинал я с чего-то куда менее сложного (но уже на этом этапе возникли первые трудности). Пешки здесь двигаются по обычным правилам (но без прыжка первым ходом и [взятия на проходе](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D1%8F%D1%82%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BF%D1%80%D0%BE%D1%85%D0%BE%D0%B4%D0%B5)). Превращение любой фигуры завершает игру. Отсутствие возможности хода означает поражение.
[](https://glukkazan.github.io/breakthrough/pawn-wars-5x5.htm)
Трудности, разумеется, возникли в связи с тем, что Garbochess нацелен исключительно на шахматы. Когда король находится под [матом](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)) или [патом](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%82), процесс поиска хода завершается естественным образом. Остаётся только проверить, под [шахом](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)) ли король, для определения результата завершения игры. В «Войне пешек» есть и другое завершение, связанное с превращением одной из фигур.
Бот, в этих случаях, бодро продолжал перебор вариантов, несмотря на то, что игра уже закончилась. Я довольно легко победил это, запретив дальнейшую генерацию ходов, после достижения цели игры. Другим отличием явилось то, что отсутствие возможности хода, в этой игре — это всегда поражение. В игре просто нет королей, незачем проверять, под шахом ли они. С этим удалось справиться ещё легче. Следующими на очереди были крупные формы.
[](https://glukkazan.github.io/checkmate/dunsanys-chess.htm)
**Здесь стоит сделать небольшое теоретическое отступление**Я хочу рассказать о том, как работает [Garbochess](https://www.chessprogramming.org/Garbochess). Всё основано на минимаксном алгоритме с "[альфа-бета-отсечением](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%84%D0%B0-%D0%B1%D0%B5%D1%82%D0%B0-%D0%BE%D1%82%D1%81%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)". В связи с этим, есть одна проблема — чтобы всё это работало, мы должны заранее знать, до какого уровня глубины будем опускаться. Предсказать это число, при условии ограничения на продолжительность поиска хода, довольно проблематично.
Либо мы выберем слишком маленькую глубину, неэффективно израсходовав выделенное время, либо опустимся слишком глубоко, потратим много времени и найдём, в результате, скорее всего, далеко не самый лучший ход. Чтобы победить эту проблему, было придумано [итеративное углубление](https://www.chessprogramming.org/Iterative_Deepening). Глубина поиска последовательно инкрементируется, начиная с единички и до тех пор, пока хватает времени.
Это работает, но для того чтобы не повторять одни и те же вычисления (очень дорогостоящие, кстати) снова и снова, необходимо использовать [таблицу транспозиций](https://www.chessprogramming.org/Transposition_Table). А поскольку это подразумевает поиск конкретной позиции в памяти по какому-то компактному ключу, без [Зобрист-хэша](https://www.chessprogramming.org/Zobrist_Hashing) тоже не обойтись! Я к тому, что в Garbochess всё взаимосвязано. Убери что-то одно и остальное просто не будет работать!
В этом месте, начались проблемы с производительностью. Дело в том, что нельзя просто опуститься до какого-то уровня и оценить там позицию! Может получиться так, например, что мы завершим поиск, на взятии ферзём пешки, не обратив внимания на то, что следующим ходом ферзь может быть взят, с далеко не лучшим для нас итогом размена. Перед тем как что-то оценивать, необходимо «проигрывать» до конца все форсированные ходы, к которым относятся любые взятия, а также любые ходы в тех ситуациях, когда король находится под шахом.
В этом и заключалась проблема. Дело в том, что все проверки на выделенное время выполнялись в той части кода, которая про «альфа-бета отсечение», а не в той, что про доигрывание. Есть такие игры, в которых такое доигрывание способно принимать чудовищно разветвлённые формы. Там выполнение программы и умирало. При этом нельзя было просто добавить проверку на время в «доигрывание», потому что в результате, там бы всё и закончилось, возможно не дойдя до действительно хороших ходов. Пришлось это дело как-то ограничивать (с потерей качества игры, само собой).
**Другая причина зависаний крылась в том, что моя модель оказалась очень медленной**Раз в десять, примерно, медленнее модели шахматной игры, используемой Garbochess. Само собой, за универсальность надо платить, но не такой же ценой! Когда я начинал работу над проектом, я довольно плохо знал JavaScript и принял не очень удачное решение, использовать стековую машину, для генерации разрешённых правилами ходов.
**То есть, описание Шахмат выглядит как-то так**
```
Dagaz.Model.BuildDesign = function(design) {
design.addDirection("w"); // 0
design.addDirection("e"); // 1
design.addDirection("s"); // 2
design.addDirection("ne"); // 3
design.addDirection("n"); // 4
design.addDirection("se"); // 5
design.addDirection("sw"); // 6
design.addDirection("nw"); // 7
design.addPlayer("White", [1, 0, 4, 6, 2, 7, 3, 5]);
design.addPlayer("Black", [0, 1, 4, 5, 2, 3, 7, 6]);
design.addPosition("a8", [0, 1, 8, 0, 0, 9, 0, 0]);
...
design.addPosition("h1", [-1, 0, 0, 0, -8, 0, 0, -9]);
...
design.addCommand(0, ZRF.FUNCTION, 24); // from
design.addCommand(0, ZRF.PARAM, 0); // $1
design.addCommand(0, ZRF.FUNCTION, 22); // navigate
design.addCommand(0, ZRF.FUNCTION, 1); // empty?
design.addCommand(0, ZRF.FUNCTION, 20); // verify
design.addCommand(0, ZRF.IN_ZONE, 0); // last-rank
design.addCommand(0, ZRF.FUNCTION, 0); // not
design.addCommand(0, ZRF.IF, 4);
design.addCommand(0, ZRF.PROMOTE, 4); // Queen
design.addCommand(0, ZRF.FUNCTION, 25); // to
design.addCommand(0, ZRF.JUMP, 2);
design.addCommand(0, ZRF.FUNCTION, 25); // to
design.addCommand(0, ZRF.FUNCTION, 28); // end
design.addCommand(1, ZRF.FUNCTION, 24); // from
design.addCommand(1, ZRF.PARAM, 0); // $1
design.addCommand(1, ZRF.FUNCTION, 22); // navigate
design.addCommand(1, ZRF.FUNCTION, 1); // empty?
design.addCommand(1, ZRF.FUNCTION, 20); // verify
design.addCommand(1, ZRF.IN_ZONE, 1); // third-rank
design.addCommand(1, ZRF.FUNCTION, 20); // verify
design.addCommand(1, ZRF.PARAM, 1); // $2
design.addCommand(1, ZRF.FUNCTION, 22); // navigate
design.addCommand(1, ZRF.FUNCTION, 1); // empty?
design.addCommand(1, ZRF.FUNCTION, 20); // verify
design.addCommand(1, ZRF.FUNCTION, 25); // to
design.addCommand(1, ZRF.FUNCTION, 28); // end
...
design.addPiece("Pawn", 0, 800);
design.addMove(0, 0, [4], 1);
design.addMove(0, 1, [4, 4], 1);
design.addMove(0, 2, [7], 1);
design.addMove(0, 2, [3], 1);
design.addMove(0, 3, [1, 4, 4], 1);
design.addMove(0, 3, [0, 4, 4], 1);
...
design.setup("White", "Pawn", 48);
...
design.setup("Black", "King", 4);
}
```
**А должно бы выглядеть следующим образом**
```
var step = function(ctx, params) {
if (ctx.go(params, 0) && !ctx.isFriend()) {
ctx.end();
}
}
var pawnShift = function(ctx, params) {
if (ctx.go(params, 0) && ctx.isEmpty()) {
if (ctx.inZone(0)) {
ctx.promote(4);
}
ctx.end();
}
}
var pawnLeap = function(ctx, params) {
if (ctx.go(params, 0) && ctx.isEnemy()) {
if (ctx.inZone(0)) {
ctx.promote(4);
}
ctx.end();
}
}
var pawnJump = function(ctx, params) {
if (ctx.go(params, 0) &&
ctx.isEmpty() &&
ctx.inZone(1) &&
ctx.go(params, 0) &&
ctx.isEmpty()) {
ctx.end();
}
}
var enPassant = function(ctx, params) {
if (ctx.go(params, 0) &&
ctx.isEnemy() &&
ctx.isPiece(0)) {
ctx.capture();
if (ctx.go(params, 1)) {
ctx.put();
if (ctx.go(params, 1) &&
ctx.isLastFrom()) {
ctx.end();
}
}
}
}
var jump = function(ctx, params) {
if (ctx.go(params, 0) &&
ctx.go(params, 1) &&
!ctx.isFriend()) {
ctx.end();
}
}
var slide = function(ctx, params) {
while (ctx.go(params, 0)) {
if (ctx.isFriend()) break;
ctx.end();
if (!ctx.isEmpty()) break;
}
}
var O_O = function(ctx, params) {
if (ctx.go(params, 0) &&
ctx.isEmpty() &&
ctx.go(params, 0) &&
ctx.isEmpty()) {
ctx.put();
if (ctx.go(params, 0) &&
ctx.isFriend() &&
ctx.isPiece(1)) {
ctx.take();
if (ctx.go(params, 1) &&
ctx.go(params, 1)) {
ctx.end();
}
}
}
}
var O_O_O = function(ctx, params) {
if (ctx.go(params, 0) &&
ctx.isEmpty() &&
ctx.go(params, 0) &&
ctx.isEmpty()) {
ctx.put();
if (ctx.go(params, 0) &&
ctx.isEmpty() &&
ctx.go(params, 0) &&
ctx.isFriend() &&
ctx.isPiece(1)) {
ctx.take();
if (ctx.go(params, 1) &&
ctx.go(params, 1) &&
ctx.go(params, 1)) {
ctx.end();
}
}
}
}
games.model.BuildDesign = function(design) {
design.addDirection("w"); // 0
design.addDirection("e"); // 1
design.addDirection("s"); // 2
design.addDirection("ne"); // 3
design.addDirection("n"); // 4
design.addDirection("se"); // 5
design.addDirection("sw"); // 6
design.addDirection("nw"); // 7
design.addPlayer("White", [1, 0, 4, 6, 2, 7, 3, 5]);
design.addPlayer("Black", [0, 1, 4, 5, 2, 3, 7, 6]);
design.addPosition("a8", [0, 1, 8, 0, 0, 9, 0, 0]);
...
design.addPosition("h1", [-1, 0, 0, 0, -8, 0, 0, -9]);
...
design.addPiece("Pawn", 0, 2);
design.addMove(0, pawnShift, [4], 0);
design.addMove(0, pawnJump, [4], 0);
design.addMove(0, pawnLeap, [7], 0);
design.addMove(0, pawnLeap, [3], 0);
design.addMove(0, enPassant, [1, 4], 0);
design.addMove(0, enPassant, [0, 4], 0);
...
design.setup("White", "Pawn", ["a2", "b2", "c2", "d2", "e2", "f2", "g2", "h2"]);
design.setup("White", "Rook", ["a1", "h1"]);
design.setup("White", "Knight", ["b1", "g1"]);
design.setup("White", "Bishop", ["c1", "f1"]);
design.setup("White", "Queen", ["d1"]);
design.setup("White", "King", ["e1"]);
design.setup("Black", "Pawn", ["a7", "b7", "c7", "d7", "e7", "f7", "g7", "h7"]);
design.setup("Black", "Rook", ["a8", "h8"]);
design.setup("Black", "Knight", ["b8", "g8"]);
design.setup("Black", "Bishop", ["c8", "f8"]);
design.setup("Black", "Queen", ["d8"]);
design.setup("Black", "King", ["e8"]);
}
```
Кстати, и для человека это удобнее! К сожалению, чтобы реализовать такую красоту, мне придётся всё переписывать. Так что, это дело следующей версии, но должно стать заметно быстрее. Генерация списка ходов, сейчас, это самое узкое место. Очень дорогая операция!
Одним из следствий такой разницы в производительностях оказалось то, что проверка на завершение отведённого времени выполнялась слишком редко. Один раз за 128 итераций. За это время, на телефоне, алгоритм успевал задумываться примерно на минуту. На десктопе дело обстояло лучше, но тоже не слишком радужно. В общем, пришлось сделать эти проверки более частыми (конечно, это не спасает от того, что на телефонах бот будет играть очень тупо).
Стоит отметить, что далеко не всегда вопрос производительности стоит остро. Есть игры, играть в которые людям объективно сложно. Использование в таких играх алгоритмов не упускающих ни единой возможности приводит к совершенно убойным результатам:
[](https://glukkazan.github.io/mancala/mini-mancala.htm)
Берём все шарики в одной из двух лунок на своей стороне и сеем по одному в следующие лунки, против часовой стрелки. У кого первого кончились все шарики — тот и проиграл. Ирония заключается в том, что если первый игрок всё делает правильно — он (в большинстве случаев) выигрывает. В вычислительном плане, это очень простая игра, но человеку играть в неё сложно. Можно привести и менее экстремальные примеры:
[](https://glukkazan.github.io/xiangqi/mini-xiangqi.htm)
А вот [так](https://glukkazan.github.io/xiangqi/dark-mini-xiangqi.htm) ещё интереснее! Впрочем, в этой игре, человек уже довольно легко побеждает. Если знает [правила](https://ru.wikipedia.org/wiki/%D0%A1%D1%8F%D0%BD%D1%86%D0%B8) и не зевает, конечно. Вообще, в шахматном мире, довольно много различных мини-игр. И с ними текущая реализация бота уже вполне справляется.
**У нового бота есть и недостатки, конечно**Например, я пока не придумал, как его рандомизировать. В одной и той же позиции (при одинаковых настройках) бот будет всегда делать один и тот же ход. Это плохо, конечно. Я немного экспериментировал с этим, но пока любые попытки рандомизации ухудшают качество игры. Наиболее перспективной выглядит предварительная случайная сортировка списка ходов на первом уровне. Но пока здесь рано говорить о каких-то успехах.
Кстати, порядок просмотра узлов очень важен! Альфа-бета-отсечение работает гораздо лучше, если просматривать ходы в порядке от лучших к худшим. Сложность заключается в том, что по самому ходу бывает трудно судить о том, насколько он хорош. Разумеется, на эту тему была придумана куча эвристик.
Прежде всего, начинать следует с лучшего хода предыдущей итерации. Далее, имеет смысл рассматривать ходы, берущие только что походившую фигуру (желательно, наименее ценными фигурами). Затем следуют взятия, но не все, а только с выгодным разменом (как его определить — это тоже та ещё задача). В отношении «тихих» ходов очень помогает "[эвристика убийцы](https://www.chessprogramming.org/Killer_Heuristic)" (здесь пришлось научиться использовать Зобрист для хэширования ходов, а не только позиций). Потом всё остальное, завершая невыгодными разменами.
Но, в целом, я вполне доволен полученными (промежуточными) результатами. Здесь есть ещё над чем поработать. Пока, я подключил далеко не все оптимизации Garbochess. Да и вопрос [оценки позиции](https://www.chessprogramming.org/Evaluation) — это тема для отдельного большого разговора. Всё это — плоды продолжительного коллективного труда многих и многих умных людей. Я очень благодарен всем им за эту работу. Сам бы я до многого из всего этого не додумался. | https://habr.com/ru/post/486082/ | null | ru | null |
# Туториал: Создание простейшей 2D игры на андроид
Этот туториал предназначен в первую очередь для новичков в разработке под андроид, но может быть будет полезен и более опытным разработчикам. Тут рассказано как создать простейшую 2D игру на анроиде без использования каких-либо игровых движков. Для этого я использовал Android Studio, но можно использовать любую другую соответствующее настроенную среду разработки.
**Шаг 1. Придумываем идею игры**
Для примера возьмём довольно простую идею:
Внизу экрана — космический корабль. Он может двигаться влево и вправо по нажатию соответствующих кнопок. Сверху вертикально вниз движутся астероиды. Они появляются по всей ширине экрана и двигаются с разной скоростью. Корабль должен уворачиваться от метеоритов как можно дольше. Если метеорит попадает в него — игра окончена.
**Шаг 2. Создаём проект**
В Android Studio в верхнем меню выбираем File → New → New Project.
Тут вводим название приложения, домен и путь. Нажимаем Next.
Тут можно ввести версию андроид. Также можно выбрать андроид часы и телевизор. Но я не уверен что наше приложение на всём этом будет работать. Так что лучше введите всё как на скриншоте. Нажимаем Next.
Тут обязательно выбираем Empty Activity. И жмём Next.
Тут оставляем всё как есть и жмём Finish. Итак проект создан. Переходим ко третьему шагу.
**Шаг 3. Добавляем картинки**
Скачиваем [архив](https://drive.google.com/file/d/0B053Cq6-zmFQbUhEQWY3NEp2REE/view?usp=sharing) с картинками и распаковываем его.
Находим папку drawable и копируем туда картинки.
Позже они нам понадобятся.
**Шаг 4. Создаём layout**
Находим activity\_main.xml, открываем вкладку Text и вставляем туда это:
```
xml version="1.0" encoding="utf-8"?
```
На вкладке Design видно как наш layout будет выглядеть.
Сверху поле в котором будет сама игра, а снизу кнопки управления Left и Right. Про layout можно написать отдельную статью, и не одну. Я не буду на этом подробно останавливаться. Про это можно почитать [тут](http://developer.alexanderklimov.ru/android/theory/layout.php).
**Шаг 5. Редактируем MainActivity класс**
В первую очередь в определение класса добавляем implements View.OnTouchListener. Определение класса теперь будет таким:
```
public class MainActivity extends AppCompatActivity implements View.OnTouchListener {
```
Добавим в класс нужные нам статические переменные (переменные класса):
```
public static boolean isLeftPressed = false; // нажата левая кнопка
public static boolean isRightPressed = false; // нажата правая кнопка
```
В процедуру protected void onCreate(Bundle savedInstanceState) {
добавляем строки:
```
GameView gameView = new GameView(this); // создаём gameView
LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // находим gameLayout
gameLayout.addView(gameView); // и добавляем в него gameView
Button leftButton = (Button) findViewById(R.id.leftButton); // находим кнопки
Button rightButton = (Button) findViewById(R.id.rightButton);
leftButton.setOnTouchListener(this); // и добавляем этот класс как слушателя (при нажатии сработает onTouch)
rightButton.setOnTouchListener(this);
```
Классы LinearLayout, Button и т.д. подсвечены красным потому что ещё не добавлены в Import.
Чтобы добавить в Import и убрать красную подсветку нужно для каждого нажать Alt+Enter.
GameView будет подсвечено красным потому-что этого класса ещё нет. Мы создадим его позже.
Теперь добавляем процедуру:
```
public boolean onTouch(View button, MotionEvent motion) {
switch(button.getId()) { // определяем какая кнопка
case R.id.leftButton:
switch (motion.getAction()) { // определяем нажата или отпущена
case MotionEvent.ACTION_DOWN:
isLeftPressed = true;
break;
case MotionEvent.ACTION_UP:
isLeftPressed = false;
break;
}
break;
case R.id.rightButton:
switch (motion.getAction()) { // определяем нажата или отпущена
case MotionEvent.ACTION_DOWN:
isRightPressed = true;
break;
case MotionEvent.ACTION_UP:
isRightPressed = false;
break;
}
break;
}
return true;
}
```
Если кто-то запутался ― вот так в результате должен выглядеть MainActivity класс:
```
package com.spaceavoider.spaceavoider;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
public class MainActivity extends AppCompatActivity implements View.OnTouchListener {
public static boolean isLeftPressed = false; // нажата левая кнопка
public static boolean isRightPressed = false; // нажата правая кнопка
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
GameView gameView = new GameView(this); // создаём gameView
LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // находим gameLayout
gameLayout.addView(gameView); // и добавляем в него gameView
Button leftButton = (Button) findViewById(R.id.leftButton); // находим кнопки
Button rightButton = (Button) findViewById(R.id.rightButton);
leftButton.setOnTouchListener(this); // и добавляем этот класс как слушателя (при нажатии сработает onTouch)
rightButton.setOnTouchListener(this);
}
public boolean onTouch(View button, MotionEvent motion) {
switch(button.getId()) { // определяем какая кнопка
case R.id.leftButton:
switch (motion.getAction()) { // определяем нажата или отпущена
case MotionEvent.ACTION_DOWN:
isLeftPressed = true;
break;
case MotionEvent.ACTION_UP:
isLeftPressed = false;
break;
}
break;
case R.id.rightButton:
switch (motion.getAction()) { // определяем нажата или отпущена
case MotionEvent.ACTION_DOWN:
isRightPressed = true;
break;
case MotionEvent.ACTION_UP:
isRightPressed = false;
break;
}
break;
}
return true;
}
}
```
Итак, класс MainActivity готов! В нём инициирован ещё не созданный класс GameView. И когда нажата левая кнопка — статическая переменная isLeftPressed = true, а когда правая — isRightPressed = true. Это в общем то и всё что он делает.
Для начала сделаем чтобы на экране отображался космический корабль, и чтобы он двигался по нажатию управляющих кнопок. Астероиды оставим на потом.
**Шаг 6. Создаём класс GameView**
Теперь наконец-то создадим тот самый недостающий класс GameView. Итак приступим. В определение класса добавим extends SurfaceView implements Runnable. Мобильные устройства имею разные разрешения экрана. Это может быть старенький маленький телефон с разрешением 480x800, или большой планшет 1800x2560. Для того чтобы игра выглядела на всех устройствах одинаково я поделил экран на 20 частей по горизонтали и 28 по вертикали. Полученную единицу измерения я назвал юнит. Можно выбрать и другие числа. Главное чтобы отношение между ними примерно сохранялось, иначе изображение будет вытянутым или сжатым.
```
public static int maxX = 20; // размер по горизонтали
public static int maxY = 28; // размер по вертикали
public static float unitW = 0; // пикселей в юните по горизонтали
public static float unitH = 0; // пикселей в юните по вертикали
```
unitW и unitW мы вычислим позже. Также нам понадобятся и другие переменные:
```
private boolean firstTime = true;
private boolean gameRunning = true;
private Ship ship;
private Thread gameThread = null;
private Paint paint;
private Canvas canvas;
private SurfaceHolder surfaceHolder;
```
Конструктор будет таким:
```
public GameView(Context context) {
super(context);
//инициализируем обьекты для рисования
surfaceHolder = getHolder();
paint = new Paint();
// инициализируем поток
gameThread = new Thread(this);
gameThread.start();
}
```
Метод run() будет содержать бесконечный цикл. В начале цикла выполняется метод update()
который будет вычислять новые координаты корабля. Потом метод draw() рисует корабль на экране. И в конце метод control() сделает паузу на 17 миллисекунд. Через 17 миллисекунд run() запустится снова. И так до пока переменная gameRunning == true. Вот эти методы:
```
@Override
public void run() {
while (gameRunning) {
update();
draw();
control();
}
}
private void update() {
if(!firstTime) {
ship.update();
}
}
private void draw() {
if (surfaceHolder.getSurface().isValid()) { //проверяем валидный ли surface
if(firstTime){ // инициализация при первом запуске
firstTime = false;
unitW = surfaceHolder.getSurfaceFrame().width()/maxX; // вычисляем число пикселей в юните
unitH = surfaceHolder.getSurfaceFrame().height()/maxY;
ship = new Ship(getContext()); // добавляем корабль
}
canvas = surfaceHolder.lockCanvas(); // закрываем canvas
canvas.drawColor(Color.BLACK); // заполняем фон чёрным
ship.drow(paint, canvas); // рисуем корабль
surfaceHolder.unlockCanvasAndPost(canvas); // открываем canvas
}
}
private void control() { // пауза на 17 миллисекунд
try {
gameThread.sleep(17);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
```
Обратите внимание на инициализацию при первом запуске. Там мы вычисляем количество пикселей в юните и добавляем корабль. Корабль мы ещё не создали. Но прежде мы создадим его родительский класс.
**Шаг 7. Создаём класс SpaceBody**
Он будет родительским для класса Ship (космический корабль) и Asteroid (астероид). В нём будут содержаться все переменные и методы общие для этих двух классов. Добавляем переменные:
```
protected float x; // координаты
protected float y;
protected float size; // размер
protected float speed; // скорость
protected int bitmapId; // id картинки
protected Bitmap bitmap; // картинка
```
и методы
```
void init(Context context) { // сжимаем картинку до нужных размеров
Bitmap cBitmap = BitmapFactory.decodeResource(context.getResources(), bitmapId);
bitmap = Bitmap.createScaledBitmap(
cBitmap, (int)(size * GameView.unitW), (int)(size * GameView.unitH), false);
cBitmap.recycle();
}
void update(){ // тут будут вычисляться новые координаты
}
void drow(Paint paint, Canvas canvas){ // рисуем картинку
canvas.drawBitmap(bitmap, x*GameView.unitW, y*GameView.unitH, paint);
}
```
**Шаг 8. Создаём класс Ship**
Теперь создадим класс Ship (космический корабль). Он наследует класс SpaceBody поэтому в определение класа добавим extends SpaceBody.
Напишем конструктор:
```
public Ship(Context context) {
bitmapId = R.drawable.ship; // определяем начальные параметры
size = 5;
x=7;
y=GameView.maxY - size - 1;
speed = (float) 0.2;
init(context); // инициализируем корабль
}
```
и переопределим метод update()
```
@Override
public void update() { // перемещаем корабль в зависимости от нажатой кнопки
if(MainActivity.isLeftPressed && x >= 0){
x -= speed;
}
if(MainActivity.isRightPressed && x <= GameView.maxX - 5){
x += speed;
}
}
```
На этом космический корабль готов! Всё компилируем и запускаем. На экране должен появиться космический корабль. При нажатии на кнопки он должен двигаться вправо и влево. Теперь добавляем сыплющиеся сверху астероиды. При столкновении с кораблём игра заканчивается.
**Шаг 9. Создаём класс Asteroid**
Добавим класс Asteroid (астероид). Он тоже наследует класс SpaceBody поэтому в определение класса добавим extends SpaceBody.
Добавим нужные нам переменные:
```
private int radius = 2; // радиус
private float minSpeed = (float) 0.1; // минимальная скорость
private float maxSpeed = (float) 0.5; // максимальная скорость
```
Астероид должен появляться в случайной точке вверху экрана и лететь вниз с случайной скоростью. Для этого x и speed задаются при помощи генератора случайных чисел в его конструкторе.
```
public Asteroid(Context context) {
Random random = new Random();
bitmapId = R.drawable.asteroid;
y=0;
x = random.nextInt(GameView.maxX) - radius;
size = radius*2;
speed = minSpeed + (maxSpeed - minSpeed) * random.nextFloat();
init(context);
}
```
Астероид должен двигаться с определённой скорость вертикально вниз. Поэтому в методе update() прибавляем к координате x скорость.
```
@Override
public void update() {
y += speed;
}
```
Так же нам нужен будет метод определяющий столкнулся ли астероид с кораблём.
```
public boolean isCollision(float shipX, float shipY, float shipSize) {
return !(((x+size) < shipX)||(x > (shipX+shipSize))||((y+size) < shipY)||(y > (shipY+shipSize)));
}
```
Рассмотрим его поподробнее. Для простоты считаем корабль и астероид квадратами. Тут я пошёл от противного. То есть определяю когда квадраты НЕ пересекаются.
((x+size) < shipX) — корабль слева от астероида.
(x > (shipX+shipSize)) — корабль справа от астероида.
((y+size) < shipY) — корабль сверху астероида.
(y > (shipY+shipSize)) — корабль снизу астероида.
Между этими четырьмя выражениями стоит || (или). То есть если хоть одно выражение правдиво (а это значит что квадраты НЕ пересекаются) — результирующие тоже правдиво.
Всё это выражение я инвертирую знаком!. В результате метод возвращает true когда квадраты пересекаются. Что нам и надо.
Про определение пересечения более сложных фигур можно почитать [тут](https://habrahabr.ru/sandbox/108362/).
**Шаг 10. Добавляем астероиды в GameView**
В GameView добавляем переменные:
```
private ArrayList asteroids = new ArrayList<>(); // тут будут харанится астероиды
private final int ASTEROID\_INTERVAL = 50; // время через которое появляются астероиды (в итерациях)
private int currentTime = 0;
```
также добавляем 2 метода:
```
private void checkCollision(){ // перебираем все астероиды и проверяем не касается ли один из них корабля
for (Asteroid asteroid : asteroids) {
if(asteroid.isCollision(ship.x, ship.y, ship.size)){
// игрок проиграл
gameRunning = false; // останавливаем игру
// TODO добавить анимацию взрыва
}
}
}
private void checkIfNewAsteroid(){ // каждые 50 итераций добавляем новый астероид
if(currentTime >= ASTEROID_INTERVAL){
Asteroid asteroid = new Asteroid(getContext());
asteroids.add(asteroid);
currentTime = 0;
}else{
currentTime ++;
}
}
```
И в методе run() добавляем вызовы этих методов перед вызовоом control().
```
@Override
public void run() {
while (gameRunning) {
update();
draw();
checkCollision();
checkIfNewAsteroid();
control();
}
}
```
Далее в методе update() добавляем цикл который перебирает все астероиды и вызывает у них метод update().
```
private void update() {
if(!firstTime) {
ship.update();
for (Asteroid asteroid : asteroids) {
asteroid.update();
}
}
}
```
Такой же цикл добавляем и в метод draw().
```
private void draw() {
if (surfaceHolder.getSurface().isValid()) { //проверяем валидный ли surface
if(firstTime){ // инициализация при первом запуске
firstTime = false;
unitW = surfaceHolder.getSurfaceFrame().width()/maxX; // вычисляем число пикселей в юните
unitH = surfaceHolder.getSurfaceFrame().height()/maxY;
ship = new Ship(getContext()); // добавляем корабль
}
canvas = surfaceHolder.lockCanvas(); // закрываем canvas
canvas.drawColor(Color.BLACK); // заполняем фон чёрным
ship.drow(paint, canvas); // рисуем корабль
for(Asteroid asteroid: asteroids){ // рисуем астероиды
asteroid.drow(paint, canvas);
}
surfaceHolder.unlockCanvasAndPost(canvas); // открываем canvas
}
}
```
Вот и всё! Простейшая 2D игра готова. Компилируем, запускаем и смотрим что получилось!
Если кто-то запутался или что-то не работает можно скачать [исходник](https://drive.google.com/file/d/0B053Cq6-zmFQdllOcVgyd1NfRms/view?usp=sharing).
Игра, конечно, примитивна. Но её можно усовершенствовать, добавив новые функции. В первую очередь следует реализовать удаление вылетевших за пределы экрана астероидов. Можно сделать чтобы корабль мог стрелять в астероиды, чтобы игра постепенно ускорялась, добавить таймер, таблицу рекордов и прочее. Если это будет вам интересно — напишу продолжение, где всё это опишу.
На этом всё. Пишите отзывы, вопросы, интересующие вас темы для продолжения. | https://habr.com/ru/post/330686/ | null | ru | null |
# Реализация Minecraft Query протокола в .Net Core
**Minecraft Server Query** – это простой протокол, позволяющий получить актуальную информацию о состоянии сервера путём отправки пары-тройки незамысловатых UDP-пакетов.
На [вики](https://wiki.vg/Query) есть подробное описание этого протокола с примерами реализации на разных языках. Однако меня поразило, насколько куцые реализации для .Net существуют на данный момент. Поискав некоторое время, я наткнулся на несколько репозиториев. Предлагаемые решения либо содержали банальные ошибки, либо имели урезанный функционал, хотя, казалось бы, куда ещё больше урезать-то.
Так было принято решение написать свою реализацию.
Скажи мне, кто ты...
--------------------
Для начала, посмотрим, что из себя представляет сам протокол Minecraft Query. Согласно [вики](https://wiki.vg/Query), мы имеем в распоряжении 3 вида пакетов запросов и, соотвественно, 3 вида пакетов ответа:
* Handshake
* BasicStatus
* FullStatus
Первый тип пакета используется для получения **ChallengeToken**, необходимого для формирования других двух пакетов. Привязывается он к IP-адресу отправителя на **30 секунд**. Смысловая нагрузка оставшихся двух ясна из названий.
Стоит отметить, что хотя последние два запроса отличаются друг от друга лишь выравниванием на концах пакетов, присылаемые ответы отличаются способом представления данных. Для примера, вот так выглядит ответ BasicStatus
Ответ на запрос BasicStatusА вот так – FullStatus
Ответ на запрос FullStatusВсе данные, помимо тех, что хранятся в short, представлены в *big-endian*. А для поля **SessionId**, которое постоянно в рамках одного клиент-сервер соединения, должно выполняться условие *SessionId & 0x0F0F0F0F == SessionId*.
В общем виде запрос выглядит так
Запрос в общем видеБолее подробно об этом об этом можно почитать на вики.
И я скажу тебе, как тебя распарсить
-----------------------------------
Для начала, определимся, что мы хотим получить на выходе. Готовая библиотека должна предоставлять API для отправки любого из 3 видов пакетов и получения результата в распаршеном виде.
При этом, я хочу больше свободы в плане поддержания жизнеспособности сокетов и обновления **ChallengeToken**. Если я буду запрашивать состояние сервера каждые 3 секунды, то я не хочу, чтобы вместо одного пакета запроса отправлялось два: хэндшейк и состояние. И наоборот, если я опрашиваю сервер раз в час, зачем мне слать запросы каждые 30 секунд? Поэтому работа с библиотекой будет происходить в "ручном" режиме.
Итак, определившись, можем уже представить, как будет выглядеть архитектура классов. Я вижу работу примерно таким образом
```
public static async Task DoSomething(IPAddress host, int port) {
var mcQuery = new McQuery(host, port);
mcQuery.InitSocket();
await mcQuery.GetHandshake();
return await mcQuery.GetFullStatus();
}
```
Здесь создаётся разовое соединение. Для долгоживущего потребуется проверять состояние сокета и инициализировать заново (об этом в конце статьи).
Для того, чтобы пакет отправить, его надо для начала сформировать. Этим будет заниматься класс **Request**.
```
public class Request
{
// Набор констант для формирования пакета
private static readonly byte[] Magic = { 0xfe, 0xfd };
private static readonly byte[] Challenge = { 0x09 };
private static readonly byte[] Status = { 0x00 };
public byte[] Data { get; private set; }
private Request(){}
public byte RequestType => Data[2];
public static Request GetHandshakeRequest(SessionId sessionId)
{
var request = new Request();
// Собираем пакет
var data = new List();
data.AddRange(Magic);
data.AddRange(Challenge);
data.AddRange(sessionId.GetBytes());
request.Data = data.ToArray();
return request;
}
public static Request GetBasicStatusRequest(SessionId sessionId, byte[] challengeToken)
{
if (challengeToken == null)
{
throw new ChallengeTokenIsNullException();
}
var request = new Request();
var data = new List();
data.AddRange(Magic);
data.AddRange(Status);
data.AddRange(sessionId.GetBytes());
data.AddRange(challengeToken);
request.Data = data.ToArray();
return request;
}
public static Request GetFullStatusRequest(SessionId sessionId, byte[] challengeToken)
{
if (challengeToken == null)
{
throw new ChallengeTokenIsNullException();
}
var request = new Request();
var data = new List();
data.AddRange(Magic);
data.AddRange(Status);
data.AddRange(sessionId.GetBytes());
data.AddRange(challengeToken);
data.AddRange(new byte[] {0x00, 0x00, 0x00, 0x00}); // Padding
request.Data = data.ToArray();
return request;
}
}
```
Здесь всё просто. Храним все константы внутри класса и формируем пакет в трёх статических методах. Можно ещё заметить класс **SessionId**, который может давать как байтовое, так и строковое представление по необходимости.
```
public class SessionId
{
private readonly byte[] _sessionId;
public SessionId (byte[] sessionId)
{
_sessionId = sessionId;
}
// Случайный SessionId
public static SessionId GenerateRandomId()
{
var sessionId = new byte[4];
new Random().NextBytes(sessionId);
sessionId = sessionId.Select(@byte => (byte)(@byte & 0x0F)).ToArray();
return new SessionId(sessionId);
}
public string GetString()
{
return BitConverter.ToString(_sessionId);
}
public byte[] GetBytes()
{
var sessionId = new byte[4];
Buffer.BlockCopy(_sessionId, 0, sessionId, 0, 4);
return sessionId;
}
}
```
Дождавшись ответа сервера, мы получаем последовательность байт, которые хотим привести к человекочитаемому виду. Для этого служит класс **Response**, который представляет набор "парсеров" в виде статических полей.
```
public static class Response
{
public static byte ParseType(byte[] data)
{
return data[0];
}
//
public static SessionId ParseSessionId(byte[] data)
{
if (data.Length < 1) throw new IncorrectPackageDataException(data);
var sessionIdBytes = new byte[4];
Buffer.BlockCopy(data, 1, sessionIdBytes, 0, 4);
return new SessionId(sessionIdBytes);
}
public static byte[] ParseHandshake(byte[] data)
{
if (data.Length < 5) throw new IncorrectPackageDataException(data);
var response = BitConverter.GetBytes(int.Parse(Encoding.ASCII.GetString(data, 5, data.Length - 6)));
if (BitConverter.IsLittleEndian)
{
response = response.Reverse().ToArray();
}
return response;
}
public static ServerBasicState ParseBasicState(byte[] data)
{
if (data.Length <= 5)
throw new IncorrectPackageDataException(data);
var statusValues = new Queue();
short port = -1;
data = data.Skip(5).ToArray(); // Skip Type + SessionId
var stream = new MemoryStream(data);
var sb = new StringBuilder();
int currentByte;
int counter = 0;
while ((currentByte = stream.ReadByte()) != -1)
{
if (counter > 6) break;
// Парсим нормер порта
if (counter == 5)
{
byte[] portBuffer = {(byte) currentByte, (byte) stream.ReadByte()};
if (!BitConverter.IsLittleEndian)
portBuffer = portBuffer.Reverse().ToArray();
port = BitConverter.ToInt16(portBuffer); // Little-endian short
counter++;
continue;
}
// Парсим параметры-строки
if (currentByte == 0x00)
{
string fieldValue = sb.ToString();
statusValues.Enqueue(fieldValue);
sb.Clear();
counter++;
}
else sb.Append((char) currentByte);
}
var serverInfo = new ServerBasicState
{
Motd = statusValues.Dequeue(),
GameType = statusValues.Dequeue(),
Map = statusValues.Dequeue(),
NumPlayers = int.Parse(statusValues.Dequeue()),
MaxPlayers = int.Parse(statusValues.Dequeue()),
HostPort = port,
HostIp = statusValues.Dequeue(),
};
return serverInfo;
}
// "Секции" пакета резделены константными последовательностями байт,
// это можно испльзовать для проверки, что мы всё сделали правильно
public static ServerFullState ParseFullState(byte[] data)
{
var statusKeyValues = new Dictionary();
var players = new List();
var buffer = new byte[256];
Stream stream = new MemoryStream(data);
stream.Read(buffer, 0, 5); // Read Type + SessionID
stream.Read(buffer, 0, 11); // Padding: 11 bytes constant
var constant1 = new byte[] {0x73, 0x70, 0x6C, 0x69, 0x74, 0x6E, 0x75, 0x6D, 0x00, 0x80, 0x00};
for (int i = 0; i < constant1.Length; i++)
Debug.Assert(constant1[i] == buffer[i], "Byte mismatch at " + i + " Val :" + buffer[i]);
var sb = new StringBuilder();
string lastKey = string.Empty;
int currentByte;
while ((currentByte = stream.ReadByte()) != -1)
{
if (currentByte == 0x00)
{
if (!string.IsNullOrEmpty(lastKey))
{
statusKeyValues.Add(lastKey, sb.ToString());
lastKey = string.Empty;
}
else
{
lastKey = sb.ToString();
if (string.IsNullOrEmpty(lastKey)) break;
}
sb.Clear();
}
else sb.Append((char) currentByte);
}
stream.Read(buffer, 0, 10); // Padding: 10 bytes constant
var constant2 = new byte[] {0x01, 0x70, 0x6C, 0x61, 0x79, 0x65, 0x72, 0x5F, 0x00, 0x00};
for (int i = 0; i < constant2.Length; i++)
Debug.Assert(constant2[i] == buffer[i], "Byte mismatch at " + i + " Val :" + buffer[i]);
while ((currentByte = stream.ReadByte()) != -1)
{
if (currentByte == 0x00)
{
var player = sb.ToString();
if (string.IsNullOrEmpty(player)) break;
players.Add(player);
sb.Clear();
}
else sb.Append((char) currentByte);
}
ServerFullState fullState = new()
{
Motd = statusKeyValues["hostname"],
GameType = statusKeyValues["gametype"],
GameId = statusKeyValues["game\_id"],
Version = statusKeyValues["version"],
Plugins = statusKeyValues["plugins"],
Map = statusKeyValues["map"],
NumPlayers = int.Parse(statusKeyValues["numplayers"]),
MaxPlayers = int.Parse(statusKeyValues["maxplayers"]),
PlayerList = players.ToArray(),
HostIp = statusKeyValues["hostip"],
HostPort = int.Parse(statusKeyValues["hostport"]),
};
return fullState;
}
}
```
Таким образом мы получаем полный инструментарий для формирования пакетов, их отправки, получения ответов и извлечения из них необходимой информации.
Долгоживущие приложения на основе библиотеки
--------------------------------------------
Вернёмся к том, о чем я говорил выше. Это можно реализовать таким образом. Код взят из моего [нотификатора пользовательской активности](https://github.com/MaxLevs/MCServerNotifier). Здесь каждые 5 секунд запрашивается FullStatus, поэтому имеет смысл обновлять ChallengeToken периодически сразу после истечения предыдущего. Всего приложение имеет 2 режима работы: штатный и режим восстановления соединения.
В штатном режиме приложение по таймерам обновляет токен и запрашивает FullStatus. При обнаружении упавшего сервера/оборванного соединения/etc (5 попыток передачи) приложение переходит в режим восстановления соединения и при удачной попытке получения сообщения снова возвращается в штатный режим.
Для начала напишем конструктор и два метода для запуска прослушивания сервера и окончания.
```
public StatusWatcher(string serverName, string host, int queryPort)
{
ServerName = serverName;
_mcQuery = new McQuery(Dns.GetHostAddresses(host)[0], queryPort);
_mcQuery.InitSocket();
}
public async Task Unwatch()
{
await UpdateChallengeTokenTimer.DisposeAsync();
await UpdateServerStatusTimer.DisposeAsync();
}
public async void Watch()
{
// Обновляем challengetoken по таймеру каждые 30 секунд
UpdateChallengeTokenTimer = new Timer(async obj =>
{
if (!IsOnline) return;
if(Debug)
Console.WriteLine($"[INFO] [{ServerName}] Send handshake request");
try
{
var challengeToken = await _mcQuery.GetHandshake();
// Если всё ок, говорим, что мы в онлайне и сбрасываем счетчик попыток
IsOnline = true;
lock (_retryCounterLock)
{
RetryCounter = 0;
}
if(Debug)
Console.WriteLine($"[INFO] [{ServerName}] ChallengeToken is set up: " + BitConverter.ToString(challengeToken));
}
// Если что-то не так, увеличиваем счетчик неудачных попыток
catch (Exception ex)
{
if (ex is SocketException || ex is McQueryException || ex is ChallengeTokenIsNullException)
{
if(Debug)
Console.WriteLine($"[WARNING] [{ServerName}] [UpdateChallengeTokenTimer] Server doesn't response. Try to reconnect: {RetryCounter}");
if(ex is McQueryException)
Console.Error.WriteLine(ex);
lock (_retryCounterLock)
{
RetryCounter++;
if (RetryCounter >= RetryMaxCount)
{
RetryCounter = 0;
WaitForServerAlive(); // Переходим в режим восстановления соединения
}
}
}
else
{
throw;
}
}
}, null, 0, GettingChallengeTokenInterval);
// По таймеру запрашиваем текущее состояние
UpdateServerStatusTimer = new Timer(async obj =>
{
if (!IsOnline) return;
if(Debug)
Console.WriteLine($"[INFO] [{ServerName}] Send full status request");
try
{
var response = await _mcQuery.GetFullStatus();
IsOnline = true;
lock (_retryCounterLock)
{
RetryCounter = 0;
}
if(Debug)
Console.WriteLine($"[INFO] [{ServerName}] Full status is received");
OnFullStatusUpdated?.Invoke(this, new ServerStateEventArgs(ServerName, response));
}
// По аналогии с предыдущим
catch (Exception ex)
{
if (ex is SocketException || ex is McQueryException || ex is ChallengeTokenIsNullException)
{
if(Debug)
Console.WriteLine($"[WARNING] [{ServerName}] [UpdateServerStatusTimer] Server doesn't response. Try to reconnect: {RetryCounter}");
if(ex is McQueryException)
Console.Error.WriteLine(ex);
lock (_retryCounterLock)
{
RetryCounter++;
if (RetryCounter >= RetryMaxCount)
{
RetryCounter = 0;
WaitForServerAlive();
}
}
}
else
{
throw;
}
}
}, null, 500, GettingStatusInterval);
}
```
Осталось только реализовать ожидание восстановления соединения. Для этого нам достаточно убедиться, что мы получили хоть какой-то ответ от сервера. Для этого мы можем воспользоваться тем же запросом хэндшейка, который не требует наличия действующего ChallengeToken.
```
public async void WaitForServerAlive()
{
if(Debug)
Console.WriteLine($"[WARNING] [{ServerName}] Server is unavailable. Waiting for reconnection...");
// Отключаем отслеживание
IsOnline = false;
await Unwatch();
_mcQuery.InitSocket(); // Пересоздаём сокет
Timer waitTimer = null;
waitTimer = new Timer(async obj => {
try
{
await _mcQuery.GetHandshake();
// Говорим, что можно возвращаться в штатный режим и отключаем таймер
IsOnline = true;
Watch();
lock (_retryCounterLock)
{
RetryCounter = 0;
}
waitTimer.Dispose();
}
// Пересоздаем сокет каждые 5 (настраивается) неудачных соединений
catch (SocketException)
{
if(Debug)
Console.WriteLine($"[WARNING] [{ServerName}] [WaitForServerAlive] Server doesn't response. Try to reconnect: {RetryCounter}");
lock (_retryCounterLock)
{
RetryCounter++;
if (RetryCounter >= RetryMaxCount)
{
if(Debug)
Console.WriteLine($"[WARNING] [{ServerName}] [WaitForServerAlive] Recreate socket");
RetryCounter = 0;
_mcQuery.InitSocket();
}
}
}
}, null, 500, 5000);
}
```
**UDP1**: Вынес библиотеку в отдельный [репозиторий](https://github.com/MaxLevs/McQueryLib.Net). | https://habr.com/ru/post/543798/ | null | ru | null |
# Адаптируем BDD для разработки на 1С совместно с cucumber и 1Script
Кто платит за тестирование решений? Особенно в случаях если заказчик (внутренний или внешний) просит запустить систему учета, и не указывает насколько плохая система ему нужна? Этот вопрос вызывает достаточно большую волну “священных войн” при любой разработке, любых решений. Написаны они на 1С или не на 1С — это извечная “драка”: никто не любит тестировать, все любят “кодить” новые и интересные задачи.
Но чтобы, хотя бы попробовать сдвинутся с мертвой точки, необходимо разобраться в том, что тестирование как понятие относится к процессу разработки. Значит все же придется тестировать разработчикам. Но вот как это сделать максимально удобно?
BDD, DDD, TDD, PDD, SDD и остальные <всякие>DD
----------------------------------------------
Размышляя над проблемой тестирования, а точнее над проблемой качества решений, умные и не очень люди, в основном ломают копья.над следующим противоречием
**“надо тестировать, но надо разрабатывать, а не тестировать”.**
Также к этому добавляется другое противоречие
**“надо предусмотреть все возможные действия будущего пользователя, но нельзя предусмотреть ВСЕ действия будущего пользователя”**
Всё становится еще хуже, когда к этому мы добавим еще огромное количество подходов к проектированию и разработке. Например, как это классифицирую я, когда мне необходимо объяснить сущность проблемы.
**Domain DD** — способ разработки, когда цель заказчика сформулирована в виде базовых сущностей будущей системы: *“Хочу Товары, Инвентаризацию, Акты списаний и оприходований”*
**Report DD** — способ разработки, когда цель заказчика формулируется в виде конечных отчетов с анализом данных: *“Хочу отчет о прибылях и убытках”*
**User Interface DD** — способ разработки, когда цель заказчика сформулирована в виде конечного пользовательского интерфейса: *“Хочу вот такую формочку для сотрудника на проходной по выдаче пропусков”*
**Behavior DD** — способ разработки, когда цель заказчика сформулирована в виде конечного процесса ожидаемого в системе, или даже группы взаимосвязанных процессов: *“Когда мы фиксируем отправку машины из Москвы, тогда нужно чтобы изменился статус заказа и зафиксировалось время отправки, а также надо учесть косвенные затраты на перевозку в себестоимости заказа”*
Отдельно стоит выделить еще 3 подхода, которые обычно нигде не описываются
**Sabotage DD** — способ разработки, когда цель заказчика формулируется в виде ускоренных сроков требущих разработки напрямую в Production системах: *“Срочно добавьте на форму реквизит Булево =Ромашка=”*. Применяется при попытках заказчика построить управляемый хаос в команде разработки — используется в политических целях.
**Moratorium DD** — способ разработки, когда цель заказчика не в запуске функциональности, а в соблюдении регламентов и нормативов утвержденных на предприятии: *“Любое изменение в системе должны быть согласовано с <ЛистСогласования>, любые работы по проектированию, разработке и прототипированию не могут быть проведены без указания проекта и его технико-экономического обоснования”*.
**Pain DD** — переходный способ разработки, когда цель заказчика повысить качество решений, не снижая сроков выхода функциональности: *“Хочу чтобы вы производили всестороннее тестирование, но кстати не забудьте первого числа запуск системы WMS, не дай бог вам сорвать сроки. Да и кстати ФОТ нам в этом году урезали — выделенных тестировщиков не получите”*.
**И это не “троллинг”**Если кому-то показалось, что эти 3 последних подхода выделены и описаны в порядке “стёба”, то сразу скажу — это не так: в определённых случаях такие подходы дают определённую долю эффективности, правда не ИТ департаменту. ИТ специалисты, здесь “чаще всего в проигрыше”.
Классификация конечно топорная и очень уж приземленная, но для подготовки специалиста к чтению умных книг по этому поводу, достаточная.
Есть еще и **FeatureDD** (разработка, когда цель заказчика сформулирована в виде небольшой легковесной функциональности), и **ModelDD** (разработка, когда цель заказчика сформулирована в виде конечной таблицы с полями), но я их обычно не использую по следующим причинам:
* в 1С мире чаще заказчик сразу формулирует ожидаемое поведение **“behavior”**, а так как “поведение” всегда сложное, то feature’s возникают сами собой при декомпозиции/категоризации сценариев.
* в 1С мире все домены/модели всегда сложные (а точнее сложно-функциональные) и имеют более двух зависимых сущностей и более двух функциональных связей. А корректные model’s возникают сами собой уже в рамках декомпозиции сложных доменов — иначе не построить корректный граф зависимостей доменов. Советую всем приглядеться к [v8.1c.ru/model](http://v8.1c.ru/model/) — в системе как раз отражен DDD совмещенный с MDD, при небольшой адаптации ChangeManagementSystem.
Вдруг кто не в курсе что это за аббревиатуры:
***DD — Driven Development** (разработка “через” или разработка “от цели”) — один из способов организации процесса разработки в инженерии программного обеспечения. Входит в [en.wikipedia.org/wiki/Software\_development\_process](http://en.wikipedia.org/wiki/Software_development_process) в виде отдельных методологий.*
Окружение разработчика BDD для eDSL
-----------------------------------
Те кто с eDSL миром знаком, а я так понял по предыдущей статье, их достаточно много на Хабре, скорее всего догадались куда я веду. Для тех кто не понял скажу: в 1С мире за счет того, что заказчик — не конечный бизнесмен, а любой пользователь предприятия: де-факто применим любой из подходов. Кто-то хочет отчет, кто-то поведение, кто-то вообще странного. Поэтому то в сообществе обычных 1С специалистов и используют формулировку **xDrivenDevelopment** — где **x**: любой подход, в зависимости от цели заказчика. Авторство принадлежит одному из участников сообщества и изначально звучало как **yDrivenDeveloment**, где **y** — некая целевая функция выполняемая разработчиком.
Но вернемся к тестированию. Итак, на входе у нас следующие данные:
* Необходимо тестировать (а куда деваться)
* Необходимо разрабатывать (eDSL платформа для этого собственно и предназначена)
* Подход к процессу разработки может быть разный.(и ничего с этим не поделать)
* Все тесты не написать (ну или написать, но через лет 10 жизни системы)
* Требования к системе достаточно хаотичны, подходы к постановке требований также
**Мы хотим попробовать создать возможность разрабатывать через поведение на платформе 1С**
**Для работы нам понадобится:**
* 1C [users.v8.1c.ru/distribution](https://users.v8.1c.ru/distribution/) => 8.3.\*
* git-msgit [msysgit.github.io](https://msysgit.github.io/) => 1.7
* ruby [www.ruby-lang.org/ru/downloads](https://www.ruby-lang.org/ru/downloads/) => 2.0
* python [wiki.python.org/moin/Python2orPython3](https://wiki.python.org/moin/Python2orPython3) => 2.5
а также концепт отражающий подход к тестированию 1С решение через поведение:
* [github.com/silverbulleters/vanessa-behavoir](https://github.com/silverbulleters/vanessa-behavoir)
в качестве дополнительно подмодуля мы будем использовать
* [github.com/xDrivenDevelopment/precommit1c](https://github.com/xDrivenDevelopment/precommit1c)
Дойдя до этого места, некоторые 1С специалисты сделают “широко открытые глаза” и возможно закроют статью. Для остальных продолжим, замечу следующий моменты:
> я ожидаю, что при установке msgit вы сделали так, что он установился в $PATH не только сам, но и со всеми утилитами (настоящему 1С-нику необходимо привыкать к консольным утилитам из \*nix мира — touch, mv, rm, grep и т.д.)
**ruby** нам понадобится чтобы установить [«огурец»](https://cukes.info/)
**python** — используется для работы с hook’ами git (дело в том, что для получения исходных файлов мы используем перехват помещения бинарных 1С файлов в репозиторий: ведь в репозитории исходных кодов все же должен быть исходный код).
Для тех, кто в данный момент испытывает боль от резкого перехода с теории к практическим работам, предлагаю смириться и продолжить чтение:
Первое что вы должны понять, тесты — это тоже код. А для кода мы просто обязаны сделать хранилище кода. Поэтому:
```
$ mkdir EnterpriseAccounting
$ cd EnterpriseAccounting
$ git init./
$ mkdir features
$ mkdir tests
$ mkdir src
$ touch README.md
```
теперь осталось только разобраться где хранить тесты на сервере git
```
$ git set origin https://dev.example.com/foobar/EnterpriseAccounting
$ git push
```
**кто такой touch и что это за команды**если вы правильно установили msgit, то тогда у вас эта команда уже присутствует, справку по ней можно посмотреть через *touch --help*
всё остальное типовые команды при работе с исходными кодами:
* создать локальную директорию
* инициализировать репозиторий внутри неё
* создать структуру каталогов
* сделать задел по будущей документации для команды
* указать центральный сервер
* отправить в центр (поделится с командой)
### Тестирование конечной задачи, это не тестирование алгоритма функции
Перейдем непосредственно к задаче. Тут опять придется несколько отвлечься и сказать, что при запуске разработки автоматизированного тестирования 1С, основная проблема это как раз непонимание “как тестировать” конечный бизнес-функционал. Возможно здесь также играет “злую штуку” название известного проекта xUnit — которое отсылает нас к [en.wikipedia.org/wiki/XUnit](http://en.wikipedia.org/wiki/XUnit), где мы читаем много умных слов, но они слишком далеки от конечного тестирования бизнес-задачи.
И вот тут у начинающего разработчика, которому поставлена задача на автоматизированное тестирование, начинается “ломка стереотипов”, дело в том что Конфигуратор 1С позволяет сразу реализовывать полученное ожидаемое поведение, без необходимости его обдумывать и задавать вопрос “зачем” и “кому” необходим функционал. Изначально считается что все заказчики-бизнесмены и специалисты по eDSL языку максимально находятся “в контексте”. Для одного поведения это скорее всего так, а вот для комплекта ожидаемых поведений и сложных сценариев ни один мозг не сможет удержать в контексте весь сценарий задачи. Как раз за этим мы и начинаем относится к ожидаемому поведению как к коду.
### Обычный типовой процесс для разработчика
Задача от заказчика (в системе учета задач) звучит исходно так
> “Необходимо что деньги учитывались как аванс, если клиент оплатил больше чем мы ему отгрузили”
Теперь посмотрим как это выглядит в реальности и прикинем что нам нужно для BDD в 1С:
* Парсер для языка Gherkin, который будет выполнять две функции: помогать нам генерировать процедуры для тестов и, собственно, запускать потом готовые тесты и формировать отчет об их прохождении. Для этих целей мы будем использовать **Cucumber** (тот самый «огурец»)
* Было бы хорошо, если бы был инструмент, который получая от **Cucumber** готовые имена тестов (вместе с параметрами) создавал нам готовые файлы обработок в формате внешней обработки 1С (мы же помним: всё что может быть автоматизированно — должно быть автоматизированно). Технически — это скрипт написанный на [языке 1Script](https://bitbucket.org/EvilBeaver/1script/wiki/Home). **Он позволяет связать Cucumber и 1C между собой посредством wire протокола cucumber, 1Script Socket, и OLE соединения с 1С**. Т.е. на вход мы получаем feature файл — на выходе готовую обработку 1С, которую можно отдавать разработчику. И всё это за один клик.
* Те обработки, которые мы получим — это и есть наши тесты. Это код, а код надо хранить и версионировать. Для этого мы ставим Git.
* После того как разработчик наполнит эти тесты кодом, их надо будет разложить на исходники (а как же, мы же не будем хранить в репозитарии только бинарные файлы). Для этой цели мы возьмём **Precommit1c** от сообщества **xDrivenDevelopment**. Теперь, когда мы помещаем готовый файл в Git, он будет распарсен, разложен, декомпилирован, деклассирован (выбрать нужное). И само собой автоматически, за один клик, ну вы поняли.
Дальше идет достаточно важный и очень обязательный шаг при «разработке через поведение» — мы пишем ожидаемый сценарий поведения (или аналитики за нас, или грамотный заказчик). Фактически Gherkin, а мы будем использовать именно его, спасёт нас здесь, тем, что мы имеем DSL язык для описания группы будущих тестовых сценариев. Наверное вы удивились что я сказал про будущие тесты? Но вы должны смирится — после использования BusinessReadableDSL для описания сценария происходит понимание что же действительно нужно протестировать, и что же действительно нужно реализовывать (ищете статью Мартина Фаулера на эту тему).
Итак, у нас есть feature файл, который мы напишем на основе исходной постановке задачи, следующего содержания:
```
$ touch ./feature/account_loan.feature
$ notepad++ ./feature/account_loan.feature
```
```
Функционал: Поступление оплаты по существующим договорам и зачёт аванса контрагента
Как Бухгалтер
Я Хочу чтобы чтобы при фиксации оплаты от Контрагента происходило распределение поступившей суммы по договорам, на котором существует долг
И происходила фиксация оплаты в виде аванса, если долг отсутствует
Контекст:
Когда есть Конфигурация 'Бухгалтерия 3.0 (Такси)'
И существует Контрагент 'тестовый Контрагент'
И существует договор 'тестовый договор Контрагента 1' с датой договора 02.01.2014
И существует договор 'тестовый договор Контрагента 2' с датой договора 03.01.2014
И Введена учетная политика
Сценарий: Поступление суммы достаточной только для погашения существующего долга
Допустим 'тестовый Контрагент' имеет 2 покупки по 2 'тестовым договорам' на сумму 1000 и 300 рублей
Когда фиксируется оплата по 'тестовому Контрагенту' на сумму 1100 рублей
Тогда формируется проводка по счету '62.01' по 'тестовый договор Контрагента 1' на сумму 1000
И формируется проводка по счету '62.01' по 'тестовый договор Контрагента 2' на сумму 100
И на счете '62.01' по 'тестовый договор Контрагента 2' остается долг в размере 200 рублей
```
**Как я создал такой feature файл**Я просто ответил на типовой комплект вопросов из Gherkin, немного подробней опросив заказчика по следующему списку:
* Что за функционал
* Что за роль
* В чем цель
* Какие сценарии поведения мы ожидаем
* В каком контексте необходим данный функционал
Запускаем vanessa-behavior.os с параметром “GenerateEpf” и получаем на выходе готовый файл обработки для тестирования:
```
$ oscript.exe vanessa-behavior.os --GenerateEpf --ProjectPath="<Адрес репозитория с Feature файлами>" --1cConnectString="File=<СтрокаСоединенияС1С>"
```
и получаем то ради чего всё это затевалось — обработку тестирования на основе поведения, [которую мы затем и наполняем при помощи кода на встроенном языке 1С](http://v8.1c.ru/overview/Term_000000816.htm)
Как видно — произошло следующее:
Для каждой строки feature файла была создана процедура.
> Например строка
>
>
>
>
> ```
> Когда есть Конфигурация 'Бухгалтерия 3.0 (Такси)'
>
> ```
>
>
>
>
> превратилась в
>
>
>
>
> ```
> Процедура ЕстьКонфигурация(Парам01Строка) Экспорт
>
> ```
>
>
>
>
>
Были определены параметры для вызова этих процедур (число, строка, дата), а также были определены, так называемые сниппеты, например:
```
//“@СуществуетДоговорСДатойДоговора(Парам01Строка,Парам02Дата)”
```
Давайте посмотрим, что с этим добром можно делать.
Первое, что бросается в глаза, что имя параметра **Парам01Строка** не очень наглядный. Что же, берём и меняем ему имя, скажем, на **НазваниеКонфигурации**. Да и имя процедуры заменим на **СуществуетКонфигурация**.
Получится:
```
Процедура СуществуетКонфигурация(НазваниеКонфигурации) Экспорт
```
Но тут может получиться ситуация, что если попытаться ещё раз сгенерировать обработку 1С по тому же *feature* файлу, то программа не сможет найти процедуру со старым именем и всё перестанет работать. Но тут нам на помощь приходит сниппет
```
//@СуществуетКонтрагент(Парам01Строка)
```
по которому мы всегда сможем определить какой именно метод вызывать (правда для этого нам придётся распарсить исходники обработки, и построить таблицу сниппетов и реальных имен процедур, но нас такие мелочи не пугают).
Второе, что можно заметить, это то что в feature файле были две похожие строки:
```
И существует договор 'тестовый договор Контрагента 1' с датой договора 02.01.2014
И существует договор 'тестовый договор Контрагента 2' с датой договора 03.01.2014
```
Но для них был создан только один метод:
```
Процедура СуществуетДоговорСДатойДоговора(Парам01Строка,Парам02Дата) Экспорт
```
Что не удивительно, ведь для обеих строк сниппет будет одинаковый. Таким образом может показаться, что тут назревает повторное использование кода. Иииииииии… Да! Это оно и есть! Если где-нибудь в этом feature файле (или в любом другом этого же проекта) мы напишем что-то вроде:
```
И существует договор 'Какой-то там договор' с датой договора ‘какая-то дата’
```
то окажется, что этот код тестирования уже реализован в методе **СуществуетДоговорСДатойДоговора**.
Мало того, может оказаться, что этот метод реализовал вообще кто-то другой до нас. И мы просто его переиспользуем. И это произойдёт само собой. Это ли не мечта любого программиста! Заказчик пишет что он хочет (а это и есть наш feature файл) — а половина кода уже реализована, протестирована (т.е. покрыта тестом) и будет подхвачена на лету!
**Welcome to the BDD, my friend!**
Подведём мини итог.
* У нас есть то, что хочет заказчик: это описано на декларативном языке Gherkin.
* Запускаем генератор — получаем готовые файлы тестов, которые надо будет наполнять кодом.
* Пишем тесты (или генерируем через новый функционал записи действий пользователя), одновременно пишем/конфигурируем тот функционал, который хочет получить заказчик.
* Запускаем vanessa-behavior.os — и идет выполнение наших тестов, используя всё ту же feature от заказчика.
* Получаем отчет о прохождении тестов в json или, например, в html ([не забудем про проект Allure](https://github.com/allure-framework/allure-cucumber))
В рамках одной статьи трудно охватить такую большую тему как BDD и как это адаптировать в мир 1С. Надеюсь, будет отдельная статья целиком посвященная этой тематике, но с уже более подробными примерами.
Инвентаризация функционала и технический долг
---------------------------------------------
Обычно, те кто изучают данный материал, как я и говорил в первой статье, отказываются начинать писать через тесты.
Происходит это по двум причинам:
* после введения правила “Любую задачу мы берем в работу только после понимания того как её будем тестировать”, основные затраты по времени начинают тратится на наращивание тестов на первичные и мастер данные — таки как контрагенты, номенклатура, учетная политика и т.д. Одновременно с этим приходится генерировать тестовые данные, так как всем становится понятно, что база для автоматизированного тестирования должна быть чистая. Не все готовы это делать — так как приходится ретроспективно взглянуть на всё что “мы накодили” до момента X (переход на BDD). Решается такая проблема так называемым методом “технического спринта” — как его согласовать с заказчиком (или не согласовывать) — это отдельная песня родом из Agile.
* трудно… всё-таки BDD|xDD родом из инженерных практик, поэтому требует высокий уровень ответственности разработчиков в команде. Всегда трудно становится ответственным, когда до этого 6 лет был безответственным. Решается такая проблема двумя способами — так называемой методикой social presure и введение практики release managment’а. То есть когда “без тестов писать фу-фу-фу” и когда релиз без тестов к production не допускается инженерами ответственными за рабочую систему. Если вы один и “многорукий Шива” — то только внутренний ИТ перфекционизм вас и спасёт.
* В общем случае переход на “разработку через ожидаемое поведение” временно увеличивает затраты команды. На текущий момент у нас следующие цифры — увеличение скорости разработки и уменьшение количества ошибок (улучшение качества) начинается где-то через 1 месяц, для команды из 5 человек уровня обычных программистов 1С. Поэтому в течении 1 месяца вся команда должна жить в перманентном стрессе и смириться ;-). Хотя опять же для менеджеров мы вынуждены заметить, что можно и не прерывать разработку по старому, запустив отдельно фазу сбора требований в виде feature файлов, а уже потом запускать фазу тестирования (хотя это и противоречить самой концепции, для переходного периода это допустимо).
**Немного истории, для совсем не сведующих**Отдельно стоит сказать, как это все начиналось и как развивалось, По моей версии это было так (хотя старшие товарищи могут меня поправить).
Начиналась проверка концепции xDD (а точнее с TDD), еще в далеком 2004 году и на платформе 1С 7.7. Принято считать, что лидерами здесь являются [Московская школа по тестированию](http://1c.alterplast.ru/functest/install.html) — в том числе в рамках проекта [www.1cpp.ru](http://www.1cpp.ru/index.php/Main) и [Ижевская школа по тестированию www.kint.ru](http://www.kint.ru/)
С выходом версии 1C 8.\* никто и не собирался отказываться от уже наработанных процессов, однако закрытость платформы привела к невозможности прямым способом портировать наработки. Процесс немного остановился.
[Но тут всех спас Яндекс и руководитель отдела тестирования;-)](http://www.1cpp.ru/forum/YaBB.pl?num=1267016427/0) (Да-да — в Яндексе тоже была или еще есть 1С).
В итоге появились первые draft’ы [infostart.ru/public/15492](http://infostart.ru/public/15492/) очень даже работоспособные, и уже при объединение нескольких наработок и родился проект [github.com/xDrivenDevelopment/xUnitFor1C](https://github.com/xDrivenDevelopment/xUnitFor1C), для развивающих качество своих решений разработчиков на платформе 1С. Лидером в данном продукте является [Артур Аюханов с командой единомышленников](https://github.com/xDrivenDevelopment/xUnitFor1C/graphs/contributors).
Но нельзя не вспоминать об Ижевской школе тестирования 1С решений. На данный момент основным фронтменом здесь является [Ижевское тестирование систем](http://1с-ижтиси.рф) — команда здесь построила схему монетизации тестирования и развивает уже свою линейку коммерческих продуктов.
Проект [vanessa-behavior](https://github.com/silverbulleters/vanessa-behavoir) является продолжением развития концепции xDD, но уже с другим подходом — теперь не от тестов, а от требования к поведению.
---
**FAQ**
**Q: Я пробовал, у меня не получилось. Как вообще это использовать ?.**
**A:** Проект работает на последней (develop) версии **1Script** и ждет выпуска релиза [1.0.9](https://bitbucket.org/EvilBeaver/1script/wiki/%D0%98%D0%B7%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F%201.0.9), а также будет планомерно дорабатываться под текущие задачи. Поэтому не волнуйтесь — всё будет.
**Q: Что почитать на эту тему ?**
**A:** Материалов достаточно много, но:
* Обращаю внимание что [ключевым докладчиком на ближайшем AgileDays2015 будет автор cucumber](http://msk15.agiledays.ru/members/profile/977/).
* год назад вышла книга *BDD In Action от John Ferguson Smart*
* также крайне рекомендуется к прочтению статьи Дэна Норта
**Q: Зачем здесь Gherkin**
**A:** DSL язык Gherkin для описания требований — это прямая отсылка вас к проблеме управления требованиями и как она решается автоматизировано.
**Q: Зачем тестировать типовой функционал типового решения 1С ?**
**A:** Как я неоднократно заявлял, автоматизированное тестирование это “игра в длинную”. Наличие ожидаемого поведение от внедряемой системы поможет упростить обновление на новую версию типовой конфигурации 1С а также вести свою разработку на основе типовой конфигурации. Правда эта проблема уже из [другой “оперы” (для знающих английский)](http://www.accurev.com/whitepaper/vendor_code.htm). Вместе с этим [я категорически рекомендую подсматривать в “кулуары”](http://v8.1c.ru/o7/201410ext/index.htm), где уже наличествует возможность расширения, которое придется разрабатывать с учетом уже ваших тестов.
**Q: А когда будет публикация про xUnitFor1C ?**
**A:** после долгого обсуждения мы посчитали, что публикацию про xUnit делать стоит группе авторов из организации xDrivenDevelopment, от себя же мы можем поделиться только [начальным восьмичасовым видеокурсом](http://www.youtube.com/watch?v=D8qZVTWWUGQ) и [публикацией на Инфостарт](http://infostart.ru/public/328695/), публикацию по xUnitFor1C все же должен делать [лидер это продукта](https://github.com/artbear)
**Q: Какая следующая публикация ?**
**A:** Это все же будет Docker для 1С, после официального релиза **docker-compose** и **docker-machine**, а также развития **docker до 1.5** теперь это действительно будет полезно уважаемому ХабраСообществу. | https://habr.com/ru/post/252473/ | null | ru | null |
# Знакомство с Koa или coroutine в nodejs
#### **Предисловие**
Меня уже очень давно привлекает javascript в качестве единого языка для веб-разработки, но до недавнего времени все мои изыскания оканчивались чтением документации nodejs и статей о том, что это callback`овый ад, что разработка на нем приносит лишь боль и страдания. Пока не обнаружил, что в harmony появился оператор yield, после чего я наткнулся на koa, и пошло поехало.
#### **В чем соль**
Собственно, koa во многом похож на предшественника — express, за исключением вездесущих callback`ов. Вместо них он использует сопрограммы, в которых управление может быть передано подпрограммам(thunk), обещаниям(promise), массиву с подпрограммами\соообещаниями, либо объекту. В некоторых местах даже сохранена некоторая обратная совместимость через группу функций co, написанных создателями koa и многими последователями. Любая функция, которая раньше использовала callback, может быть thunkify`цирована для использования с co или koa.
Выглядит это так:
```
var func = function(opt){
return function(done){
/* … */
(…) && done(null, data) || done(err)
}
}
var func2 = function(opt){
return function(done){
oldFuncWithCallback(opt, function(err, data){
(...) && done(null, data) || done(err)
}
}
}
co(function*{
/* … */
var result = yield func(opt);
var result2 = yield func2(opt);
var thunkify = require('thunkify');
var result3 = yield thunkify(oldFuncWithCallback(opt))
})()
```
При этом в result вернется data, а done(err) вызовет исключение, и функцию вы не покидаете, как это было бы с callback`ом, и интерпретатор не блокируете, выполнение переходит к следующему yield`у, и выглядит это изящно, другими словами — просто сказка.
##### **Время писать код**
Koa основан на middleware`ях, также, как express, но теперь они выполняются как сопрограмма, подобно tornado в python. Дальше пойдет код простого сайта и мои мысли.
Структура проекта:
* node\_modules
* src — Здесь весь исходный код
+ server — Сервер
+ app — Папка с приложениями
+ public — Статика
+ template — Шаблоны
+ config — Файлы конфигурации
Так как предыдущим моим увлечением был Django, кому-то может показаться, что это сказалось на организацию кода в проекте, возможно это правда, мне нравится организовывать код в модули.
**src/server/index.js**
```
'use strict';
var koa = require('koa');
var path = require('path');
var compose = require('koa-compose');
// эта утилита позволяет композировать набор middleware`й в одну
var app = module.exports = koa();
// выглядит знакомо
var projectRoot = __dirname;
var staticRoot = path.join(projectRoot, '../public');
var templateRoot = path.join(projectRoot, '../template');
// нечто подобное мы делали в settings.py в django
var middlewareStack = [
require('koa-session')(), // расширяет контекст свойством session
require('koa-less')('/less', {dest: '/css', pathRoot: staticRoot}),
// компилирует less в css, если был запрошен файл со стилями, имеет много интересных опций
require('koa-logger')(), // логирует все http запросы
require('koa-favicon')(staticRoot + '/favicon.png'),
require('koa-static')(staticRoot), // отдает статику, удобно для разработки, лучше конечно делать это nginx`ом
require('koa-views')(templateRoot, {'default': 'jade'}) // Jade еще одна причина любви к nodejs
];
require('koa-locals')(app);
// добавляет объект locals к контексту запроса, в который вы можете записывать все, что угодно
app.use(compose(middlewareStack));
/*
все перечисленные middleware должны возвращать функцию генератор, так же мы можем проинициировать здесь что-то сложное
и долгое, никаких лишних callback`ов тут не будет и интерпретатор не заткнется, а продолжит выполнение,
вернувшись, когда будет время
*/
var routes = require('./handlers');
app.use(function *(next) {
// в качестве this, middleware получает app, который в последствии расширяет и передает дальше
this.locals.url = function (url, params) {
return routes.url(url, params);
};
yield next
});
/*
так выглядит типовой middleware, в данном случае эта конструкция добавляет функцию url, которую можно использовать в шаблонах,
либо где то еще, для получения абсолютных урлов по имени и параметрам
*/
app.use(routes.middleware());
```
Нужно помнить, что эта цепочка вызывается каждый раз, когда сервер получает запрос. Чтобы лучше понять порядок их выполнения, можно воспользоваться таким примером:
```
app.use(function*(next){
console.log(1)
yield heavyFunc()
console.log(2)
yield next
})
app.use(function*(next){
console.log(3)
yield next
})
```
Каждый запрос в консоль будет выведено
```
1
3
2
```
Далее в папку с сервером я кладу handlers.js, модуль, который регистрирует приложения из папки src/app.
**src/server/handlers.js**
```
var Router = require('koa-router');
var router = new Router();
function loadRoutes(obj, routes){
routes.forEach(function(val){
var func = val.method.toLowerCase() == 'get' ? obj.get :
val.method.toLowerCase() == 'post' ? obj.post :
val.method.toLowerCase() == 'all' ? obj.all : obj.get;
return func.call(obj, val.name, val.url, val.middleware)
})
}
loadRoutes(router, require('src/app/home').routes); // Так подключается приложение из папки app
module.exports = router;
```
Модуль инкапсулирует метод loadRoutes, который принимает только что созданный экземпляр маршрутизатора и список объектов, содержащих информацию о маршрутах. На примере home я покажу, как выглядят приложения для работы с этим модулем:
**src/app/home.js**
```
function* index(next){
yield this.render('home/index', {
Hello: 'World!'
})
}
var routes = [
{method: 'get', name: 'index', url: '/', middleware: index}
];
exports.routes = routes;
```
Выглядит очень просто и органично, тут я пошел немного дальше модульности, предложенной в django, мне понравилась полная обособленность модуля от остального приложения, включая собственные маршруты. Конечно, при таком подходе может возникнуть конфликт урлов и вы получите не то, что ожидали. Можно добавлять название приложения, либо использовать koa-mount, либо улучшить регистратор для предотвращения дубликатов.
Надо сказать, что для рендера страницы нужно заполнить this.body, чем и занимается this.render, либо передать выполнение дальше, с помощью yield next, иначе в теле страницы вы получите «Not Found». Если ни один из middleware не заполнил body и продолжил выполнение, правильную страницу 404 можно отрисовать, поместив в конец src/server/index.js такую middleware:
```
app.use(function*(){
this.status = 404;
yield this.render('service/404')
// либо редирект, либо что угодно
})
```
#### **Заключение**
На сладкое решил оставить обработку ошибок. От адептов nodejs и express слышал, что это требует не дюжей внимательности к каждому callback`у и даже она не всегда помогает. Если вспомнить порядок выполнения middleware, глобальную обработку можно осуществить, просто добавив следующий код в начало обработки запроса:
```
app.use(function* (next){
try {
yield next
} catch (err) {
this.app.emit('error', err, this); // транслировать тело ошибки в консоль
yield this.render('service/error', {
message: err.message,
error: err
})
}
)
```
Этим мы заключаем весь код проекта в try..catch, ну и не забывайте, что app — это прежде всего eventEmitter. По-моему, это просто гениально. Модулей для koa уже написано великое множество, почти каждый модуль для express уже адаптирован для koa, такие как mongoose, passport, request и многие другие. Так мы получили асинхронное программирование, которое приносит радость и фан. К тому же небезызвестный TJ остается поддерживать koa.
> Философски, Koa стремится исправить и заменить nodejs, в то время как Express расширяет nodejs.
Отрывок из начала статьи, [koa-vs-express](https://github.com/koajs/koa/blob/master/docs/koa-vs-express.md).
Спасибо, что читали. Всего хорошего, всем nodejs. | https://habr.com/ru/post/238095/ | null | ru | null |
# Руководство по установке и тонкой настройке авиа-симулятора Microsoft Flight Simulator X (FSX)
На данный момент в мире существует всего два авиа-симулятора, которые способны приблизить виртуальный полёт к реальности — это [Microsoft Flight Simulator](http://habrahabr.ru/blogs/games/52713/) и [X-Plane](http://www.google.com/search?client=opera&rls=en&q=x-plane+screenshots&sourceid=opera&ie=utf-8&oe=utf-8). В данной статье речь пойдёт о FSX, десятой, и, к сожалению, [последней версии линейки авиа-симуляторов от Microsoft](http://habrahabr.ru/blogs/games/52713/), т.к. в январе этого года вся команда, занимавшаяся линейкой FS, [была распущена](http://www.guardian.co.uk/technology/blog/2009/jan/23/microsoft-flight-sim-cuts). Так что 11ую версию мы вряд ли дождёмся, хотя и ходят слухи, что команда разработчиков [основала свою собственную студию.](http://www.joystiq.com/2009/10/14/former-microsoft-flight-simulator-devs-form-new-studio/) А также не дремлет Aerosoft, и в октябре анонсировала Aerosoft Flight Simulator 2012! Проект развивается в [зародыше](http://www.forum.aerosoft.com/index.php?showforum=278).А пока остаётся только ждать, я решил задокументировать весь набранный опыт установки и использования FSX, выбор необходимых аддонов для увеличения реализма, твикинг FSX для увеличения FPS, и вообще, постараться выжать максимум из того, что осталось от этого замечательного авиа-симулятора. Всем, кому интересна эта тема — прошу под кат (осторожно, 10Мб картинок!).
Перед тем, как начать статью, хочу сразу отметить, что FSX и почти все аддоны, о которых пойдёт речь ниже — **платные**. Поэтому всё, что понравится, нужно купить, ведь симуляторной индустрии и так приходится не легко. Однако, если вы по какой-либо уважительной причине не можете себе позволить приобрести тот или иной продукт, или просто хотите для начала оценить его возможности — всё здесь описанное (и еще вагон и тележку) можно найти [вот здесь](http://anonym.to/?http://torrents.ru/forum/viewforum.php?f=2142). И еще. Практически все советы по оптимизации FSX уже были описаны там и сям по кусочкам в сети. Я лишь разложил всё по полочкам. Если вы с чем-либо не согласны или хотите что-то добавить — пожалуйста, комментарии только приветствуются! Итак:
Оглавление
----------
1. [Системные требования для комфортной игры в FSX](#sysreq)
2. [Установка FSX](#install)
3. [Настройка опций внутри FSX](#setup)
4. [Установка nHancer для тонкой настройки видеокарт nVidia](#nhancer)
5. [Настройка версии шейдеров](#shader)
6. [Установка аддонов, которые ЗАМЕТНО улучшат графику и реалистичность симулятора](#addons)
7. [Итог и скриншоты](#result)
8. [Ссылки](#links)
Системные требования для комфортной игры в FSX
----------------------------------------------
FSX достаточно требователен к ресурсам компьютера. И какой бы компьютер у вас не был, в конечном счете, всё упрётся в компромисс «реалистичность или FPS». Математика здесь простая: чем больше аддонов вы ставите и чем лучше модель летательного аппарата (ЛА) вы используете, тем меньше FPS вы получаете. Поэтому я хочу сразу озвучить минимальные (на мой взгляд) системные требования, которые могут дать качественную и приятную картинку при разумных FPS:* **ОС**: Windows XP, Windows Vista или Windows 7 (рекомендую последнюю)
* **Процессор**: Intel Core Duo / Quad (или лучше), 2ГГц и выше. Чем больше ГГц, тем лучше, количество ядер на FPS в FSX практически не влияет. AMD, разумеется, тоже потянет, но с их процессорами я плохо знаком.
* **Память**: 2Гб и выше. Скорость памяти влияет на FPS, поэтому лучше позаботиться о частоте и таймингах.
* **Жесткий диск**: любой современный винчестер со свободным объемом не менее 100 Гб.
* **Видеокарта**: предпочтительно от nVidia, т.к. у пользователей радеона иногда возникают проблемы. GeForce 8800 GT или лучше. Также, предпочтительнее иметь более высокую частоту GPU и побольше памяти (256Мб — минимум, 512Мб — хорошо, 1024Мб — отлично), нежели делать SLI или покупать крутые многоядерные видеокарты.
* **Джойстик**: джойстик для игры обязателен! Какой именно — дело ваше, я лично пользуюсь [Logitech Extreme 3D Pro](http://market.yandex.ru/model.xml?hid=91117&modelid=2454033&text=logitech+extreme+3d&srnum=3) и очень им доволен. В идеале можно приобрести даже [штурвал](http://market.yandex.ru/model.xml?hid=91117&modelid=1640599&text=%f8%f2%f3%f0%e2%e0%eb+saitek&srnum=2) :)
Для примера, могу привести свою конфигурацию, которая по нынешним временам достаточно скромна: Core Duo E6750 (2.6ГГц), 2GB RAM (OCZ), GeForce 8800GT, Hitachi 500GB. На этой конфигурации FSX выдает: на земле от 10 до 40 FPS в зависимости от аэропорта, ЛА и погодных условий; в полёте от 15 до 60 FPS. Для тех, кто испугался 10-15 FPS, могу добавить, что это происходит достаточно редко, и ниже 20 FPS я вижу лишь в 2-5% от всего времени полёта. Плюс ко всему, 15 FPS в авиа-симуляторе это далеко не то же самое, что 15 FPS в каком-нибудь NFS или GTA :) А качество графики можно оценить по представленным в конце статьи скриншотам.Если ваш компьютер удовлетворяет вышеописанным системным требованиям, тогда можно приступить к установке игры.
Установка FSX
-------------
Установка симулятора состоит из двух этапов:1. Установка базовой версии Flight Simulator X (идёт на двух DVD дисках). После установки желательно запустить симулятор, зайти в игру и выйти, чтобы инициировать создание конфигурационных файлов.
2. Установка дополнения «Разгон» (еще один DVD). Это очень ВАЖНЫЙ этап, т.к. дополнение включает в себя необходимый сервис пак с кучей решенных проблем. После установки рекомендуется перезагрузить компьютер, после чего для верности разок запустить симулятор.
Настройка опций внутри FSX
--------------------------
В игре довольно много различных настроек. Я коснусь лишь тех, что могут повлиять на качество графики и FPS. Я не утверждаю, что приведённые настройки САМЫЕ оптимальные. Таких не бывает. Для одного компьютера они одни, для другого другие. Данный вариант рекомендуется использовать в качестве точки отсчета, чтобы потом можно было подкрутить, если у вас оказался запас FPS, либо наоборот, нехватка.
Ниже я привожу скриншоты всех вкладок с настройками.Основные настройки:
DirectX 10 лучше выключить, этот режим, к сожалению, так и не был доработан до конца, из-за чего сулит одни проблемы.Настройки ЛА:
Пейзаж:
Погода:
Воздушное движение. Здесь всё индивидуально и зависит от того, какой у вас трафик, дефолтный или отдельный аддон. Но в любом случае, правило стандартное: чем больше объектов в игре — тем меньше FPS. Уровень реалистичности вы оцениваете сами.
После применения всех настроек, общее окно настроек в FSX должно выглядеть следующим образом:
Для большего реализма очень рекомендую зайти в раздел «Реализм» и подправить там несколько ползунков, т.к. дефолтные никуда не годятся:
Главное, чтобы ползунок «Общие» был на максимуме, как того требуют многие производители моделей ЛА.Теперь выйдете из симулятора, чтобы настройки сохранились в файл. Потом запустите его снова, чтобы убедиться, что настройки успешно загружены. Теперь опять закрывайте симулятор, т.к. сейчас нужно будет подправить несколько строк вручную в главном конфиге FSX: fsx.cfg. Файл этот находится в папке пользовательских настроек Windows, т.е. в каталоге «C:\Documents and Settings\ВАШЕИМЯ\Application Data\Microsoft\FSX» или «C:\Users\ВАШЕИМЯ\AppData\Roaming\Microsoft\FSX» в зависимости от версии Windows. Чтобы не заморачиваться с путями, можете просто выбрать в пуске команду «Выполнить» и ввести туда строчку:
**notepad %APPDATA%/Microsoft/FSX/fsx.cfg**
Конфиг автоматически откроется в блокноте в любой версии Windows. Не забудьте на всякий случай сохранить копию файла, вдруг где ошибётесь. Нам требуется поменять (если параметр уже присутствует в файле) либо добавить следующие параметры:
`**[Display]**
TEXTURE_BANDWIDTH_MULT=70
**[GRAPHICS]**
TEXTURE_MAX_LOAD=4096
**[Main]**
DisablePreload=1
FIBER_FRAME_TIME_FRACTION=0.33
**[TERRAIN]**
TERRAIN_MAX_AUTOGEN_TREES_PER_CELL=1200
TERRAIN_MAX_AUTOGEN_BUILDINGS_PER_CELL=1000
**[BUFFERPOOLS]**
PoolSize=12000000`Поясню, что означает каждый:
| | |
| --- | --- |
| TEXTURE\_BANDWIDTH\_MULT | Управляет «скоростью» загрузки текстур в память. Рекомендуемое значение 70-80 (по-умолчанию 30). Если симулятор подтормаживает при поворотах камеры — попробуйте выставить значение побольше (максимум 400). |
| TEXTURE\_MAX\_LOAD | Максимальный размер поддерживаемых текстур. Параметр необходим для аддона REX и (возможно) других аддонов. 4096 — максимум. |
| DisablePreload | Симулятор не будет подгружать полёт по-умолчанию каждый раз при запуске, что позволяет слегка увеличить скорость загрузки игры. |
| FIBER\_FRAME\_TIME\_FRACTION | Параметр определяет соотношение процессорного времени, требуемого на подгрузку сцены и рендеринга. Например, 0.33 в данном случае означает, что на подгрузку сцены будет тратиться около 30% процессорного времени, а оставшиеся 70% уйдут на рендеринг. Рекомендуемые значения для пробы в районе 0.05 — 0.66 |
| TERRAIN\_MAX\_AUTOGEN\_TREES\_PER\_CELL | Количество деревьев для автогенерации пейзажа. Больш*и*е значения заметно уменьшают FPS. Можете поэкспериментировать, диапазон оптимальных значений варьируется от 800 до 3000. |
| TERRAIN\_MAX\_AUTOGEN\_BUILDINGS\_PER\_CELL | То же самое, только определяет количество 3D зданий при автогенерации пейзажа. |
| PoolSize | Этот параметр определяет размер буфера для текстурной памяти, чтобы потом вовремя «вытащить» оттуда необходимую текстуру. Некоторые пишут, что он значительно влияет на качество рендеринга, объекты и текстуры появляются более плавно, без рывков, если выставить значение 12000000 или даже больше (в байтах). Если у вас видеокарта с 512+ мегабайтами памяти — можете попробовать поиграться в поисках оптимального значения. |
После сохранения изменений запустите симулятор, чтобы оценить влияние подправленных настроек. Для измерения качества графики и FPS я всегда использовал аэропорт Брисбена — Австралия (ICAO код: YBBN). Выберете какой-нибудь один ЛА и загружайтесь в этом аэропорту (Свободный полёт -> Местоположение -> Изменить -> По коду аэропорта -> YBBN).
Чтобы выжать максимум процессорного времени для FSX, можно запускать его с повышенным приоритетом. Для этого создайте .bat файл и вставьте туда следующую строчку, подставив полный путь к файлу fsx.exe:
**start /HIGH J:\GAMES\FSX\fsx.exe**
Установка nHancer для тонкой настройки видеокарт nVidia
-------------------------------------------------------
Если вы являетесь обладателем какого-либо GeForce, утилитка nHancer даст вам гораздо больше возможностей для тонкой настройки графики, нежели их стандартная панель в панели управления Windows. Утилита совершенно бесплатна и может быть использована для настройки графики в любой другой игре. Скачать её можно [вот здесь](http://www.nhancer.com/) (я использовал версию 2.5.7). Также, советую скачать самые последние драйвера с сайта [nVidia](http://www.nvidia.ru/Download/index.aspx?lang=ru).После запуска программы найдите в списке профайл «MS Flight Simulator X», выделите его, убедитесь, что пункт «Profile» активен и настройте графику согласно следующим рекомендуемым значениям (изменения вносите в правой части окна):
В разделе «Global» тоже необходимо подправить несколько значений:
После всех манипуляций можете закрывать программу, она больше не нужна, ни в трее, нигде. Настройки уже сохранены глобально. Хотя, конечно, никто вам не запрещает поиграться с параметрами самому, особенно с уровнем сглаживания, может для вашей видеокарты есть и более оптимальные параметры. Перезагрузите компьютер и опробуйте новые настройки в действии.
Настройка версии шейдеров
-------------------------
Для настройки версии шейдеров нам нужно подправить еще один конфигурационный файл FSX — display.cfg, который находится В КОРНЕВОЙ директории симулятора. У меня это «J:\GAMES\FSX». Но сначала нам понадобится утилита dxdiag, входящая в Windows. Для её запуска просто наберите «dxdiag» в «Пуск->Выполнить». В появившемся окне нажмите на кнопку «Save all information...» и сохраните полученный dxdiag.txt файл в любую папку.Теперь откройте оба файла (dxdiag.txt и display.cfg) в блокноте для редактирования и создайте (если похожего еще нет) раздел [xxxx:yyyy] в следующем формате:Пример приведён для карты GF 8800 GT, но должен сработать и для ATI карт. После этих манипуляций вы можете заметить небольшой прирост в FPS и качестве рендеринга воды.
Установка аддонов, которые ЗАМЕТНО улучшат графику и реалистичность симулятора
------------------------------------------------------------------------------
FSX — очень хороший симулятор, но до реальности ему всё равно далеко :) Поэтому в сети можно найти сотни аддонов, которые могут добавить в игру новые фотореалистичные пейзажи (фактически, текстуры земли в виде фотографий со спутника), реальные облака, реальные погодные условия, модели чуть ли не всех реальных самолётов, большинство из которых выполнены на все 100%, т.е. любой рычажок или переключатель будет работать так, как на настоящей машине, авиа трафик и еще много других интересных вещей. Ниже я привожу список самых необходимых аддонов (на мой взгляд), которые существенно преображают симулятор. Устанавливать рекомендую по порядку, запуская симулятор после окончания установки каждого аддона:1. **FS Global 2010** — заменяет дефолтную сетку (меш) поверхности земли на более детализированную с разрешением вплоть до 9 метров!.. Вот скриншоты для сравнения:
FSX по-умолчанию:
FS Global 2010:
Фотография:
Размер аддона: около 24Гб! Хочу добавить, что FS Global 2010 заметно лучше предыдущей версии — FS Global 2008, поэтому ищите именно последнюю версию.
2. **Ultimate Terrain X Europe** — делает европейскую часть более детализированной. Добавляет текстуры, разметку дорог и прочее. Размер аддона: 1.5Гб. Также есть версии для США и Канады.
3. **Ground Environment X Europe/USA/Canada** — Лучший аддон для замены стандартных текстур земли для Европы, США и Канады. Можно использовать совместно с Ultimate Terrain X, т.к. в нём только лэнд классы (дороги, озера, мосты, жилые зоны и проч.). Размер аддона: ~3.0Гб.
4. **ORBX Australia** — отличный аддон, который сделает весь австралийский материк фотореалистичным. Аддон состоит из четырех частей (северная, южная, центральная и западные части). Размер аддона: 3.5Гб.
5. **Другие сцены** — Есть еще ОЧЕНЬ много различных сценариев для разных частей света и стран. Например, сценарий [Hawaii](http://www.megascenery.com/images/haw1575.jpg) от [Megascenery](http://www.megascenery.com/). Также можно найти тучу детализированных аэропортов, список вы можете продолжить сами, просто зайдите на [симмаркет](http://secure.simmarket.com/fsx-europe-(en_285)-page-1.chtml) и поищите то, что нравится лично вам.
6. **Real Environment Extreme (REX)** — пожалуй самый лучший аддон для добавления фотореалистичных облаков и погодных условий, а также сногсшибательной воды! При этом FPS сильно не просаживает. Размер аддона: версия 1.0 — 4Гб, плюс апдейт до 2.0 — 100Мб. Имеет встроенный погодный движок, который может загружать реальную погоду в выбранном вами аэропорту и его окрестностях.
7. **MyTraffic 5.2** — создаёт более реалистичный траффик в аэропортах и в небе (выглядит приблизительно [вот так](http://pic.ipicture.ru/uploads/091106/bgOWSBNGx4.jpg)). FPS сильно не просаживает. Включает в себя кучу различный моделей самолётов с ливреями реальных авиакомпаний. Хочу отметить, что существуют и другие варианты траффика для FSX, например, «World of AI Traffic», «Morten's AI Traffic v2.2» и проч. Лично для меня, траффик не играет такой уж важной роли, поэтому я не сравнивал все эти продукты, просто остановил свой выбор на MyTraffic. Размер около 1Гб.
8. **FsPassengers** — аддон позволяет вам создать виртуальную авиакомпанию, покупать виртуальные самолёты, перевозить виртуальных пассажиров и зарабатывать на этом виртуальные деньги :) Выполнен достаточно качественно, на борт самолёта можно нанять экипаж, кормить пассажиров в полёте и еще много всего интересного. С этим аддоном в оффлайне летать станет гораздо интереснее.
9. **FSUIPC** — небольшое дополнение для FSX SDK, которое является обязательным для некоторых аддонов, чтобы те смогли подключиться к симулятору для обмена данными (даже по сети на отдельном компьютере).
10. **FlightSim Commander 8.5** — программа для планирования маршрута полёта. Конечно, планировать маршрут можно и во встроенном планировщике в самом симуляторе, но в FSC, на мой взгляд, это делается гораздо удобнее. Здесь легко можно проложить маршрут по VOR маякам, посмотреть карту аэропорта (рулёжки, гейты) и прочее:
Планируете маршрут, сохраняете в файл .pln, открываете его в FSX и летите. Если вам захочется еще большей реалистичности, можете воспользоваться настоящими картами Jeppesen (программа Jeppview), которыми пользуются реальные пилоты. Карты содержат всю необходимую информацию: схемы SID/STAR, схемы захода по ILS, VOR, DME, GPS, разметку рулёжек и так далее. Программа выглядит вот так:
 
11. **Дополнительные летательные аппараты** — для FSX создано очень много моделей самолётов и вертолётов. Есть даже космические шаттлы :) Из легких самолётов особенно хочу отметить следующие:
**RealAir Beechcraft Duke B60** — мой фаворит :) 
**Carenado C172n** 
**IRIS Pro Christen Eagle** 
Список на этом [не заканчивается](http://secure.simmarket.com/fsx-commercial-aviation-(en_271)-page-1.chtml)! Аэробусы, боинги, Ту-шки — всё в вашем распоряжении.
Итог и скриншоты
----------------
В итоге, после установки и настройки FSX и всех вышеописанных аддонов, можно получить вот такие скриншоты (полноразмерные 1280х1024), которые в динамике еще симпатичнее :)
#### Аэрошоу на Ибице
#### Перелёт по маршруту «Гонолулу — Гавайи»
#### Полёт через горы в Чили
#### Южная Америка, Бразилия
#### Полёт ночью
Ну и на закуску:
1. Небольшой видеоролик (не мой), в котором можно сравнить процесс посадки самолёта с видом из кабины пилота в реале и в симуляторе:
2. [Интересная статья о сравнении полёта на реальной Цессне и Цессне из FSX](http://eugr.livejournal.com/2200.html).
Ссылки
------
Несколько ссылок на самые интересные сайты, касающиеся тематики симуляторов:* Не забывайте про встроенный учебник в самом FSX. Перевод на русский выполнен достойно, и знакомство с симулятором следует начинать именно с него. А учебные миссии с инструктором помогут проверить знания на практике.
* [AVSIM.SU](http://www.avsim.su/forum/forum/102-microsoft-flight-simulator-x/) — самый большой форум об авиа-симуляторах и всему, что с ними связано: навигация, полёты в онлайн сетях и прочее. Ответы на 99.99% вопросов вы сможете найти именно здесь.
* [Как правильно читать схемы Jeppesen?](http://www.malukhin.ru/flight/003.html)
* [База данных аэропортов мира](http://www.world-airport-database.com/airport.aspx?id=473a7f58-fa80-4bd5-8c56-90f60d4de1f8) — удобный сайт, в котором вы можете найти практически любой аэропорт (по коду) и посмотреть как он выглядит в картах Google.
Удачных вам полётов!
--------------------
PS. Это моя первая статья на хабре, прошу не судить строго...
PPS. Хабраэффект сильно нагружает сервер с картинками, поэтому если что не загрузилось, попробуйте чуток попозже… Спасибо :)
UPD. Последнее обновление статьи: 26.11.2009г. | https://habr.com/ru/post/74630/ | null | ru | null |
# Обновление прошивки HP P2000 G3 MSA Array System
HP MSA P2000 — популярный дисковый массив начального уровня компании HP (на самом деле Dothill). Простой, надежный, относительно недорогой, с приемлемой скоростью работы.
В 2014 году HP выпустила новую линейку массивов — HP MSA 1040/2040, [пообещав снять с продаж старую версию](http://habrahabr.ru/company/hp/blog/183530/).
Но пока никто не торопится выводить из эксплуатации старые системы, они готовы прослужить еще не один год.
В этой статье хотелось бы поделиться некоторыми нюансами, возникающими при апгрейде массива и обновлении firmware.
##### **Выбрать правильную полку**
Вы можете увеличить емкость массива, подключив одну или несколько дополнительных дисковых полок.
Несмотря на то, что массив снят с продажи, дополнительные полки доступны для заказа. HP предлагает несколько моделей полок с интерфейсом SAS:
1. HP D2600 (AJ940A), жесткие диски LFF, 3.5":
2. HP D2700 (AJ941A), жесткие диски SFF, 2.5":
Зачастую, эти полки упоминаются как D2600/D2700, из чего можно сделать вывод, что это одна и та же модель, но с разным форм-фактором жестких дисков. Возможно это и так, но! Массив HP MSA P2000 официально совместим только с дисковой полкой модели HP D2700. Не так просто найти эту информацию. Этот неочевидный момент следует из описания массива HP P2000 и скромного упоминания в документе «HP D2000 Disk Enclosures Quick Specs»:
> «The D2700 is also supported when attached to a HP P2000 G3 Modular Smart Array System family.»
>
>
Из этого можно сделать вывод, что полка D2600 официально несовместима с HP P2000. Но, **проверено на практике**, фактически вполне работоспособна. Не покупайте эту полку, если массив все еще на гарантии, а вы не хотите лишних проблем.
##### **Обновление прошивки**
Актуальная версия прошивки массива — [TS251P006-02 от 9 сентября 2014 года](http://h20565.www2.hp.com/hpsc/swd/public/detail?sp4ts.oid=4118563&swItemId=MTX_8253fde8ed454cdf9d477d29df&swEnvOid=4064#tab1).
###### **Не ставьте прошивку от другой модели**
Из документации HP следует, что до TS230 для каждой модели массива (FC/iSCSI, iSCSI, SAS) выпускались отдельные прошивки.
> IMPORTANT: Beginning with TS230, firmware for all HP P2000 G3 MSA System controllers was merged into a common firmware stream, used on all protocols of P2000 G3 MSA controllers.
Казалось бы, зачем вообще прошиваться на такую старую версию? Вы узнаете, когда утилита обновления откажется прошивать с вашей версии на последнюю напрямую, предложив сначала прошиться на промежуточную.
Если вы не захотите довериться мастеру, а будете качать промежуточную прошивку самостоятельно, внимательно читайте раздел «Инструкции по установке». Встретив предупреждение:
> NOTE: This firmware upgrade is applicable ONLY for HP StorageWorks P2000 G3 MSA FC and FC/iSCSI (combo) arrays and is NOT applicable for any other P2000/MSA2000 array products (including HP StorageWorks P2000 G3 SAS MSA and P2000 G3 iSCSI MSA arrays).
задумайтесь, то ли вы собираетесь залить.
###### **Прошиться дважды**
Также неприятный сюрприз поджидает обладателей массива с одним контроллером и прошивкой до TS230. Вероятнее всего, массив не получится напрямую обновить на последнюю версию. Прошивальщик зависает с сообщением [«Restarting MC… Please Wait…»](http://h30499.www3.hp.com/t5/Disk-Array/P2000-G3-firmware-upgrade-stuck-on-Restarting-MC/td-p/6708415#.VVWPwtr7NaQ) . Предположительно, это связано с тем, что скрипт пытается перезагрузить второй несуществующий контроллер.
Выход из этой ситуации следующий — проверяете через telnet что контроллер все еще жив, убиваете процесс прошивальщика. После этого прошиваетесь на TS230-008(B), и только после этого на последнюю версию.
Не любите лишний риск — сразу шейтесь в два этапа, сначала TS230-008(B), затем TS251.
###### **Проблемы, проблемы, проблемы**
Думаете, что проблемы возникают только у тех, кто сэкономил на покупке второго контроллера? Тогда вам будет интересно прочитать об [«Infinite upgrade loop»](http://www.petenetlive.com/KB/Article/0000248.htm). Не испугались? Тогда полистайте подборку документов [«Устранение неисправностей»](http://h20566.www2.hp.com/portal/site/hpsc/template.PAGE/public/psi/troubleshootResults/?javax.portlet.begCacheTok=com.vignette.cachetoken&javax.portlet.endCacheTok=com.vignette.cachetoken&javax.portlet.prp_e97ce00a6f76436cc859bfdeb053ce01=wsrp-navigationalState%3Daction%253Ddoclist%257Cviewall%253Dtrue&javax.portlet.tpst=e97ce00a6f76436cc859bfdeb053ce01&sp4ts.oid=4118559&ac.admitted=1431615077220.876444892.199480143).
Избранное:
* [HP P2000/MSA2000 SAN Array Systems — Unable to Access Management Controller: MC and SC Unable to Communicate](http://h20565.www2.hp.com/hpsc/doc/public/display?docId=emr_na-c03153230&lang=en&cc=us)
* [HP Storageworks P2000 G3 MSA — MSA Management Controller Failed to Upgrade: «Controller version Mismatch!!! Flash Status is 7»](http://h20565.www2.hp.com/hpsc/doc/public/display?sp4ts.oid=4118559&docId=emr_na-c03190947&docLocale=en_US)
##### **Глаза боятся, руки делают**
Смирившись с возможными трудностями, можно приступить к обновлению. Подробную инструкцию вы найдете в разделе «Инструкции по установке» к каждому файлу прошивки.
HP настоятельно рекомендует обновляться из Smart Component Updater — утилиты обновления в виде .exe файла (прошивальщика). Существует возможности прошиться из CLI (интерфейса командной строки) или Storage Management Utility (веб-интерфейс управления массива). Две последние возможности будут запасными, на случай невозможности прошивки из SCU.
Типовая последовательность обновления будет следующей:
1. Скачайте файл обновления. Проверьте хеш (например, утилитой fciv.exe).
2. Проводите обновление с компьютера в той же подсети, что и контроллер, в ближайшем свитче, чтобы сетевые ошибки или межсетевой экран не прервали процесс.
3. Заранее поставьте [драйвер для управления контроллером](http://h20564.www2.hp.com/hpsc/swd/public/detail?swItemId=MTX_8de10954d645450f9e3c0d015d#tab-history) из командной строки через USB кабель на случай потери доступа по сети.
4. Включите в массиве протоколы Telnet и FTP. SSH не подойдет.
5. Снизьте нагрузку на массив. В случае массива с одним контроллером диски будут недоступны, так как контроллер будет неоднократно перезагружен.
6. Запустите прошивальщик, следуйте указаниям мастера. Прошивка — длительный процесс, каждый контроллер прошивается по 30 минут, наберитесь терпения.
После обновления контроллера желательно обновить и прошивки жестких дисков.
Удачи.
UPD 2018-10-15: После обновления контроллера P2000 G3 на TS252P005, полка в интерфейсе загорелась Warning'ом, но все пока работает.
**и вот почему**Из-за отсутствия второго контроллера загорелся красным IO-модуль B.
Попробовал отключить его, но не вышло:
`set expander-phy encl 2 controller B type ingress phy 0 disabled
# set expander-phy encl 2 controller B type ingress phy 0 disabled
Error: PHY control is not supported for the specified enclosure.`
Полезные ссылки:
* **[Программное обеспечение для массива](http://h20564.www2.hp.com/hpsc/swd/public/readIndex?sp4ts.oid=4118572&swLangOid=8&swEnvOid=4064)**
* **[Документация](http://h20566.www2.hp.com/portal/site/hpsc/template.PAGE/public/psi/manualsResults/?sp4ts.oid=4118559&spf_p.tpst=psiContentResults&spf_p.prp_psiContentResults=wsrp-navigationalState%3Daction%253Dmanualslist%257Cviewall%253Dtrue%257Clang%253Den&javax.portlet.begCacheTok=com.vignette.cachetoken&javax.portlet.endCacheTok=com.vignette.cachetoken)** | https://habr.com/ru/post/258007/ | null | ru | null |
# Бюджетный вариант виртуальной АТС с не бюджетными возможностями
В этом топике я попробую рассказать про попытку организовать бюджетный `виртуальный телефонный офис`.
И так, изначально имеется:
* пара десятков мелких офисов (арендаторы).
* телефония приходящая им по сипу
* пользовательские SIP телефоны и софтфоны.
* желание некоторых клиентов вместо просто телефона на столе, иметь фичи: авто секретарь/расписание/голосовая почта/запись звонков и нежелание иметь настоящую PBX и администратора для этого дела.
* наше желание сделать хорошо клиентам.
* системный администратор который знает такие страшные слова как linux и asterisk.
попытка реализовать желания клиентов, вложившись только в сервер, под катом.
Погуглив, решено было копать в сторону [asterisk](http://asterisk.org) или [freeswitch](http://www.freeswitch.org/).
Погуглив еще было обнаружено, что большое количество предложений 'виртуального офиса' для астериска это либо `пять пунктов одноуровнего IVR` либо астериск с [FreePBX](http://www.freepbx.org/) установленный в виртуальную машину ( почему то очень любят OpenVZ ). От FreePBX в виртуальной машине было решено пока отказаться — интерфейс ни сколько не для пользователя, и к каждому такому астериску надо прилагать администратора, да и рулить кучкой астерисков в виртуальных машинах не айс. Для FS есть интересная штука, которая вроде как может Multi-Tenant — [blue.box](http://wiki.2600hz.org/display/bluebox/About+blue.box), но на FS пока смотрим осторожно ( с астериском больше опыта работы ), поэтому тоже пока прошли мимо.
По запросу '*виртуальная атс*' гугл отдает кучу ссылок, почти все из которых собственно предложения провайдеров, например, что то типа 'СВЕТЕЦ' который сейчас в [octopus'e](http://www.octoline.ru/) и ростелекоме — красиво, но у себя поставить не получится, либо дорого либо в принципе продают только услугу.
Еще немного поискав можно нагуглить [VitualPBX](http://code.google.com/p/virtual-pbx/), без особых изысков в гуе, зато на астериске к которому можно допилить, что то свое.
Судя по [документации](http://virtual-pbx.googlecode.com/files/XVB-6707.pdf) хотелки пользователей:
* авто секретарь
* расписание
* голосовая почта
* запись звонков
и наши:
* asterisk + изоляция пользователей
* управление из одного места
* локальные звонки между офисами в одном здании
там реализованы + еще несколько десятков не всегда телефонных, но кому то может и полезных фичь.
#### Собственно его и будем настраивать
Смотрим актуальную версию на [главной странице](http://code.google.com/p/virtual-pbx/) ( latest VMWare image ) и качаем её.
Сейчас это: VM Ware образ с номером [8645](http://virtual-pbx.ru/downloads/VirtualPBX-1_8645.tar.bz2) [9613](http://virtual-pbx.ru/downloads/VirtualPBX-1_9613.tar.bz2) ( [virtual-pbx.ru/ru-downloads.html](http://virtual-pbx.ru/ru-downloads.html) ).
[Проверяем обновления](http://virtual-pbx.ru/updates/vpbx/) и если есть тоже скачиваем последний .tgz.
Для тех у кого была установлена предыдущая версия обновление будет выглядеть примерно так:
```
cd /tmp
wget http://virtual-pbx.ru/updates/vpbx/VirtualPBX-8645.tgz
tar -xzvf VirtualPBX-8645.tgz
cd VirtualPBX-8645
rpm -Fvh *.rpm
```
#### Сделаем предварительную настройку, по [документации](http://virtual-pbx.googlecode.com/files/XVB-AI-6565.pdf), после чего заходим в интерфейс администратора:
\_https://server\_ip/ai\_
в списке групп выберем группу default и поправим нужные нам настройки, у нас это было:
* Dialout asterisk context ( поменяли на vpbx-local )
* Maximum Number of Schedule items in ext
* + лимиты
* разрешаем использование всех дополнительных фичь.
#### Примерный план того, что хочется сделать в качестве шаблона для каждого пользователя:
* зарегистрировать номер у провайдера ( перенести с IP-телефона на asterisk )
* завести телефонные номера ( подключаем IP-телефоны и cофтфоны к нашему virtual-pbx )
* входящая / исходящая маршрутизация
* сделать шаблон стандартного IVR с:
— расписание
— black list
— авто секретарь
— роутинг по отделам
— голосовая почта
#### Приступаем
Добавим контекст для исходящей связи, для всех пользователей. ( будет использоваться если набранный номер не попадет в маршрутизацию настроенную у пользователя )
```
tail -5 /etc/asterisk/extensions.conf
[vpbx-local]
; общий номер для всех
exten => 0999,1,Goto(xvb-main,${EXTEN},1)
; local DID's
exten =>_00XX,1,Goto(xvb-main,${EXTEN},1)
```
во вкладке users добавляем пользователя (так как каждый пользователь есть комбинация номера телефона + кода доступа, мы для себя заводим всех пользователей на номере '0999' — (если на него позвонить система попросит ввести код доступа ) и каждому офису прописываем 4-х значный внутренний дид ):
##### нажимаем 'создать' и получаем примерно это:
##### далее переходим в `кабинет` пользователя:
меняем часовой пояс / язык / устанавливаем имя пользователя / его почту / и тд.
##### Настроим регистрацию на оборудовании провайдера:
тут пропишем:
* ip-адрес провайдера
* имя пользователя на оборудовании провайдера ( у нас это телефон )
* пароль
* поставим галочку принимать звонки
* поставим 0 в колонке 'на внутренний номер'
теперь наш виртуальный офис 43 должен зарегистрироваться на оборудовании провайдера для получения входящих звонков, проверяем:
```
[root@n-test 5701]# asterisk -rx 'sip show registry'
Host dnsmgr Username Refresh State Reg.Time
20-1325847688-14a91d6d49dc91d5c1a9967db N xxxxxxxxxxxp 105 Registered Sat, 07 Jan 2012 00:08:13
1-321ca7dfe1f5aeb15381dcb06a74368c:5060 N 2xxxxxxx 97 Registered Sat, 07 Jan 2012 00:07:55
2 SIP registrations.
[root@n-test 5701]#
```
##### Сделаем регистрацию оборудования клиента в нашем виртуальном офисе 403:
здесь мы создали профили для 2 пользовательских телефонов с номерами 101 и 102
так примерно выглядит подключение телефона Fanvil к нашему виртуальному офису ( в качестве номера 101 ):
далее также регистрируем софтфон на номере 102.
##### Создадим исходящий роутинг по умолчанию через провайдера SIP телефона:
то есть тут все номера, кроме 4-х значных начинающихся на 0, отправляем к провайдеру ( если в дальнейшем пользователь захочет отправлять звонки например через сипнет ему нужно просто сделать маршрут с более высоким весом )
##### Переходим к списку внутренних номеров:
###### И в частности к номеру 0:
мы установили тип внутреннего номера — 'Расписание' и создали простое расписание — с понедельника по субботу с 9 до 18 отправлять звонки на внутренний номер 1 ( тут у нас будет собственно сам IVR ) иначе на 600 ( голосовую почту )
###### далее здесь же настроим фильтрацию входящих звонков по номеру звонящего:
это означает, что при поступлении звонков с номеров 1234567890 и 0987654321 система повесит трубку.
###### Создадим номер 600 — голосовую почту:
( вместо системного сообщения лучше загрузить звуковой файл со своим приветствием. Из коробки, из русских голосов, доступны TTS голос festival и TTS от google.translate )
###### Далее создаем номер 1, в котором попросим звонящего выбрать кого он хочет услышать:
###### и номера для бухгалтерии ( 1\*1 )
###### и технического отдела ( 1\*2 )
Всё вместе это выглядит примерно так:
Далее, чтобы не повторять всё тоже самое для каждого пользователя идем во вкладку 'Профиль пользователя' и делаем бекап настроек ( в xml формате ) после чего его можно загрузить для нового пользователя ( предварительно подправив номера и пароли ).
Собственно всё. Разворачиваем новому пользователю приготовленный шаблон и отдаем рулить своим куском АТС.
#### Итак у нас есть:
* система установленная у нас и контролируемая нами
#### У пользователя есть:
* расписание для всех входящих звонков.
* черный список телефонных спамеров и хулиганов.
* авто секретарь.
* запись разговоров.
* голосовая почта.
* возможность позвонить с 101 на 102 или в город.
* редирект звонков для номеров 101 и 102 на мобильные ( через SIP провайдера ).
* управление своим виртуальным офисом с возможностью расширения вышеперечисленных возможностей.
* подробные CDR для каждого звонка:
Сейчас всё это работает в тестовом режиме и смертельных багов пока не вылезло, про то, что хочется поправить чуть ниже.
#### Пару слов про неудобства:
* Ставить на сервер с нуля из rpm несколько геморойно из за кучи зависимостей, поэтому проще копировать tar'ом прямо из vmare-имиджа.
* В некоторые моменты возникает сильное желание записать таки свои голосовые сообщения ( из коробки идет TTS ) и поправить web интерфейс. | https://habr.com/ru/post/135845/ | null | ru | null |
# Как я делал парсинг расписания
Привет Habr!
Дорогой читатель! Если тебя интересует парсинг html и разработка под Android, то эта статья для тебя. Надеюсь ты найдешь в ней много интересного и полезного. В ней я хочу поделиться своим опытом в данной сфере.
Описание проблемы
-----------------
Немного обо мне. Я студент третьего курса ИТА ЮФУ. Также как и всем студентам, мне нужно каждый день смотреть расписание занятий. Причём мне нужно знать расписание не только на следующий день, но и на одну-две недели вперёд.
Казалось бы, почему нельзя просто сохранить расписание и пользоваться им? К сожалению, есть ряд причин, которые этому препятствуют, а именно:
* Расписание на одну неделю может сильно отличаться от расписания на другую
* Расписание не постоянно и может меняться
Конечно, есть сайт с расписанием, но он не очень удобен, так как на нём выводится просто сырая таблица с расписанием на 20 недель. Студенту приходится листать большую страницу, в поисках расписания на нужный день. Кроме того, в оффлайн режиме расписание становится недоступным.
Я решил сделать небольшое приложение, которое могло бы парсить сайт с расписанием моего института, и обладало бы следующим набором плюшек:
* Отображение: номера текущей недели, даты, дня недели и расписания на этот день
* Возможность перелистывать расписание кнопками «назад» и «далее»
* При отсутствии интернета показывать последнюю загруженную оффлайн версию расписания
Приступим к экзекуции
---------------------
Итак, закатав рукава, я приступил к работе. Начать необходимо с малого. А именно — с редактирования файла манифеста. Стоит помнить, что наше приложение будет работать с интернетом и нам очень важно получить соответствующее разрешение:
**Файл манифестра**Идём в manifests->AndroidManifest.xml. Добавляем permission. В итоге получается что-то типа этого:
```
xml version="1.0" encoding="utf-8"?
...
```
Теперь перейдём к интерфейсу. Пока сделаем акцент на функционал и не будем злоупотреблять виджетами. Поэтому я разместил всего четыре виджета: Заголовок, текстовое поле и кнопки: назад и далее.
**Разметка Activity**
```
xml version="1.0" encoding="utf-8"?
```
Теперь начнём писать парсинг. Тут нам поможет замечательный парсер с открытым исходным кодом Jsoup. Вариант с использованием WebView я сразу отмёл, так как я посчитал этот способ крайне неудобным. К тому же мне не очень хотелось использовать лишний виджет, без которого легко можно обойтись.
**Подключение Jsoup**Добавляем зависимость в build.gradle:
```
implementation 'org.jsoup:jsoup:1.11.1'
```
Не стоит забывать, что работа с web для Android — это тяжёлая задача. Чтобы приложение не висло, нужно чтобы работа с web располагалась вне потока UI. Поэтому будем использовать класс AsyncTask. В него мы и заложим основной функционал, а потом просто передадим данные в UI-поток.
Для тех, кто не знаком с AsyncTask, хочу сказать, что данный класс должен располагаться внутри класса вашего activity. Сам класс приведён ниже.
**Код Activity с классом AsyncTask**
```
package com.example.myapplication;
import androidx.appcompat.app.AppCompatActivity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class MainActivity extends AppCompatActivity {
public boolean offline;
public String request;
public String WeekNumber;
public int count;
//Виджеты
public TextView weeknumber;
public EditText timetable;
public Button next;
public Button down;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
offline = false;// Работаем а онлайн режиме
count = 0;//Описание этой переменной будет дано ниже
weeknumber = findViewById(R.id.WeekNumber);
timetable = findViewById(R.id.timetable);
next = findViewById(R.id.next);
down = findViewById(R.id.down);
getting AsyncTask = new getting();
AsyncTask.execute();
}
class getting extends AsyncTask {
@Override
protected void onPreExecute() {
super.onPreExecute();
//В этом методе код перед началом выполнения фонового процесса
}
@Override
protected String doInBackground(String... params) {
/\*Этот метод выполняется в фоне
Тут мы обращаемся к сайту и вытаскиваем его html код
\*/
String answer = "";// В эту переменную мы будем класть ответ от сайта. Пока что она пустая
String url = "https://ictis.sfedu.ru/rasp/HTML/82.htm";// Адрес сайта с расписанием
Document document = null;
try {
document = Jsoup.connect(url).get();// Коннектимся и получаем страницу
answer = document.body().html();// Получаем код из тега body страницы
} catch (IOException e) {
// Если произошла ошибка, значит вероятнее всего, отсутствует соединение с интернетом
// Загружаем в переменную answer оффлайн версию из txt файла
try {
BufferedReader read = new BufferedReader(new InputStreamReader(openFileInput("timetable.txt")));
String str = "";
while ((str = read.readLine())!=null){
answer +=str;
}
read.close();
offline = true;//работаем в оффлайн режиме
} catch (FileNotFoundException ex) {
//Если файла с сохранённым расписанием нет, то записываем в answer пустоту
answer = "";
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
//Убираю лишний текст из html
//Заменяю html код отсутствия пары на запись nolessone
//Убираю двойные пробелы
answer = answer.replace("Пары","")
.replace("Время","")
.replace("
","br")
.replace("","nolessone")//Заменяем "сигнатуру" пустой пары на nolessone
.replace(" ","");
return Jsoup.parse(answer).text();//Вытаскиваем текст из кода в переменной answer и передаём в UI-поток
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
/\*Этот метод выполняется при завершении фонового кода
Сюда возвращаются данные из потока
\*/
request = "";//Начинаем формировать ответ
String temp = result.toString();//Делаём временную строку
// Записываем содержимое, в файл timetable.txt, в котором будем хранить оффлайн версию расписания
try {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(openFileOutput("timetable.txt",MODE\_PRIVATE)));
writer.write(temp);
writer.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
boolean start = false;
for(String str:temp.split("Неделя: ")){
if(start) {
//В начало каждой недели добавляем слово newweek и добавляем в request
request += "newweek"+str.split("Расписание")[0] + "\n";
}
start = true;
}
// Добавляем к дням недели приставку newday, для дальнейшей разбивки строки
request = request.replace("Пнд","newdayПнд").replace("Втр","newdayВтр")
.replace("Срд","newdayСрд").replace("Чтв","newdayЧтв")
.replace("Птн","newdayПтн").replace("Сбт","newdayСбт");
/\*Получаем дату дня
Если count = 0, то вернётся дата сегодняшнего дня
Если count = -1, то вчерашнего
Если count = 1, то завтрашнего и т.д
\*/
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY\_OF\_YEAR,count);
Date dayformat = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat("dd MMMM");
//Выводим результат
timetable.setText(request);
if(offline && !temp.equals("")){
//Уведомляем пользователя, что загружена оффлайн версия расписания
Toast.makeText(getApplicationContext(),"Загружена оффлайн версия расписания!",Toast.LENGTH\_LONG).show();
}
//Если наш ответ равен пустоте, значит произошла ошибка
if(temp.equals("")){
Toast.makeText(getApplicationContext(),"Произошла ошибка!",Toast.LENGTH\_LONG).show();
}
}
}
}
```
В итоге мы получим данные вот в таком виде:
**Расписание на одну неделю**
Разберём методы, которые мы использовали:
Создаём элемент типа Document
```
Document document = null;
```
Получаем страницу
```
document = Jsoup.connect(url).get();
```
Теперь достаём содержимое тега body
```
answer = document.body().html();
```
В Jsoup также можно получить содержимое других основных тегов. Например можно получить заголовок страницы, используя метод title() и т.д. Метод html() Возвращает html код, а text() — обычный текст без html тегов.
Получив html код, можно преобразовать его в обычный текст, убрав все теги. Это можно сделать с помощью parse(htmlcode).text():
```
return Jsoup.parse(answer).text();
```
Хотелось бы поделиться ещё полезными методами Jsoup, которые не были использованы:
```
Element link = document.select("tag");//выберет элемент с тегом
String url = link.attr("attribute"); // выдаст атрибут тега
```
На картинке в спойлере выше приведён пример расписания на одну неделю. В действительности нам будет возвращено 20 таких недель. Теперь наша задача найти в этом наборе данных сегодняшний день и вывести его.
Доведение до ума
----------------
Итак, что мы имеем? Мы научились приводить html код страницы в строку, которую можно легко распарсить. Это легко можно сделать используя строковые методы .split() и .replace().
В общем случае алгоритм будет выглядеть так.
Сначала получаем нужную дату от Android. Потом делаем два цикла, один вложенный в другой. Первый цикл проходит по неделям, второй, который внутри него, пробегает по дням недели. Если дата данного дня совпадает с датой, полученной от Android, то выводим расписание этого дня в текстовое поле. Однако каждый может написать этот алгоритм по своему. Я прикрепил свою версию его реализации.
**Полный код Activity**
```
package com.example.myapplication;
import androidx.appcompat.app.AppCompatActivity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class MainActivity extends AppCompatActivity {
public boolean offline;
public String request;
public String WeekNumber;
public int count;
//Виджеты
public TextView weeknumber;
public EditText timetable;
public Button next;
public Button down;
public void formating(String day){
String DayTimetable = "";
String[] weeks = request.split("newweek");
String DayData = "";//Тут будет день недели и дата
/*
Переменные ниже будут содержать информацию о каждой паре
Всего в день может быть семь пар
массив less содержит названия каждого предмета
массив tich содержит ФИО преподавателя каждого предмета
массив aud содержит аудиторию, в которой будет проходить предмет (например Д-230)
*/
String less[] = new String[7];
String tich[] = new String[7];
String aud[] = new String[7];
for(String thisweek:weeks){//пробегаемся по неделям
if(thisweek.indexOf(day) != -1) {//Если нужный нам день найден в этой неделе то...
WeekNumber = thisweek.split(" ")[0];//Достаём номер недели
for(String thisday:thisweek.split("newday")){//Теперь пробегаемся по дням этой недели
if(thisday.indexOf(day) != -1) {//Если данный день совпадает с нужным нам днём, то...
//Делаем так, тобы перед каждой парой была приставка newless
//пара всегда начинается с соответствующей приставки пр. лек. лаб. и пр.
thisday = thisday.replace("no","newless")
.replace("пр.","newlessпр.")
.replace("лек.","newlessлек.")
.replace("лаб.","newlessлаб.");
int i = 0;
for(String thislessone:thisday.split("newless")) {//Теперь пробегаемся по предметам данного дня
if(i != 0) {
String[] ScienceInformation = thislessone.replace("br ","").split("br");
String science = ScienceInformation[0];
science = science.replace("lessone","Окно");
String ticher = "";
if(ScienceInformation.length > 1)
ticher = ScienceInformation[1];
DayTimetable += i + "-ая: Предмет - " + science+"\n"+ticher+"\n\n";
ticher = ticher.replace("А-","@А-").replace("А-","@Б-")
.replace("В-","@В-").replace("Г-","@Г-")
.replace("Д-","@Д-").replace("Е-","@Е-")
.replace("И-","@И-").replace("K-","@K-");
String Auditory;
if(ticher.split("@").length == 2){
Auditory = "Аудитория: "+ticher.split("@")[1];
}else
Auditory = "Аудитория: Дома";//На случай если пары нет
ticher = ticher.split("@")[0];
if(ticher.length() >0){
ticher = "Преподаватель: "+ticher;
}else{
ticher = "Самоподготовка";
}
if(i==1){
less[i-1] = "1-ая (8:00-9:35) "+science;
}
if(i==2){
less[i-1] = "2-ая (9:50-11:25) "+science;
}
if(i==3){
less[i-1] = "3-ая (11:55-13:30) "+science;
}
if(i==4){
less[i-1] = "4-ая (13:45-15:20) "+science;
}
if(i==5){
less[i-1] = "5-ая (15:50-17:25) "+science;
}
if(i==6){
less[i-1] = "6-ая (17:40-19:15) "+science;
}
if(i==7){
less[i-1] = "7-ая (19:30-21:05) "+science;
}
tich[i-1] = ticher;
aud[i-1] = Auditory;
}else
DayData = thislessone;//При i=0 в thislessone будет дата текущего дня
i++;
}
}
}
}
}
timetable.setText(DayData);//Выводим дату
for(int i = 0; i <=6; i++){
timetable.setText(timetable.getText()+"\n"+less[i]+tich[i]+aud[i]);//Вывод пары, препода и аудитории каждой пары (от нулевой до шестой)
}
weeknumber.setText("Сейчас "+ WeekNumber + " неделя");//Выводим номер неддели
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
offline = false;// Работаем в онлайн режиме
count = 0;
weeknumber = findViewById(R.id.WeekNumber);
timetable = findViewById(R.id.timetable);
next = findViewById(R.id.next);
down = findViewById(R.id.down);
getting getting = new getting();
getting.execute();
//События для кнопок назад и вперёд
next.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
count++;
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_YEAR,count);
Date dayformat = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat("dd MMMM");
formating(format.format(dayformat));
}
});
down.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
count--;
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_YEAR,count);
Date dayformat = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat("dd MMMM");
formating(format.format(dayformat));
}
});
}
class getting extends AsyncTask {
@Override
protected void onPreExecute() {
super.onPreExecute();
//В этом методе код перед началом выполнения фонового процесса
getSupportActionBar().setTitle("Загрузка...");
}
@Override
protected String doInBackground(String... params) {
/\*Этот метод выполняется в фоне
Тут мы обращаемся к сайту и вытаскиваем его html код
\*/
String answer = "";// В эту переменную мы будем класть ответ от сайта. Пока что она пустая
String url = "https://ictis.sfedu.ru/rasp/HTML/82.htm";// Адрес сайта с расписанием
Document document = null;
try {
document = Jsoup.connect(url).get();// Коннектимся и получаем страницу
answer = document.body().html();// Получаем код из тега body страницы
} catch (IOException e) {
// Если произошла ошибка, значит вероятнее всего, отсутствует соединение с интернетом
// Загружаем в переменную answer офлайн версию из txt файла
try {
BufferedReader read = new BufferedReader(new InputStreamReader(openFileInput("timetable.txt")));
String str = "";
while ((str = read.readLine())!=null){
answer +=str;
}
read.close();
offline = true;//работаем в оффлайн режиме
} catch (FileNotFoundException ex) {
//Если файла с сохранённым расписанием нет, то записываем в answer пустоту
answer = "";
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
//Убираю лишний текст из html
//Заменяю html код отсутствия пары на запись nolessone
//Убираю двойные пробелы
answer = answer.replace("Пары","")
.replace("Время","")
.replace("
","br")
.replace("","nolessone")
.replace(" ","");
return Jsoup.parse(answer).text();//Вытаскиваем текст из кода в переменной answer и передаём в UI-поток
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
/\*Этот метод выполняется при завершении фонового кода
Сюда возвращаются данные из потока
\*/
request = "";//Начинаем формировать ответ
String temp = result.toString();//Делаём временную строку
// Записываем содержимое, в файл timetable.txt, в котором будем хранить оффлайн версию расписания
try {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(openFileOutput("timetable.txt",MODE\_PRIVATE)));
writer.write(temp);
writer.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
boolean start = false;
for(String str:temp.split("Неделя: ")){
if(start) {
//В начало каждой недели добавляем слово newweek и добавляем в request
request += "newweek"+str.split("Расписание")[0] + "\n";
}
start = true;
}
// Добавляем к дням недели приставку newday, для дальнейшей разбивки строки
request = request.replace("Пнд","newdayПнд").replace("Втр","newdayВтр")
.replace("Срд","newdayСрд").replace("Чтв","newdayЧтв")
.replace("Птн","newdayПтн").replace("Сбт","newdayСбт");
/\*Получаем дату дня
Если count = 0, то вернётся дата сегодняшнего дня
Если count = -1, то вчерашнего
Если count = 1, то завтрашнего и т.д
\*/
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY\_OF\_YEAR,count);
Date dayformat = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat("dd MMMM");
//Вызываем функцию, которая будет заниматься представлением данных
formating(format.format(dayformat));
if(offline && !temp.equals("")){
//Уведомляем пользователя, что загружена оффлайн версия расписания
Toast.makeText(getApplicationContext(),"Загружена оффлайн версия расписания!",Toast.LENGTH\_LONG).show();
}
//Если наш ответ равен пустоте, значит произошла ошибка
if(temp.equals("")){
Toast.makeText(getApplicationContext(),"Произошла ошибка!",Toast.LENGTH\_LONG).show();
}
getSupportActionBar().setTitle("Готово");
}
}
}
```
выборка расписания происходит в методе formating(). Подав на вход методу дату, мы получим расписание на данный день. Так мы легко можем реализовать код для кнопок «назад» и «далее»
Код кнопки «Далее»:
```
count++;
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_YEAR,count);
Date dayformat = calendar.getTime();
SimpleDateFormat format = new SimpleDateFormat("dd MMMM");
formating(format.format(dayformat));// Вызываем formating
```
С помощью Calendar мы получаем сегодняшнюю дату. С помощью метода add мы прибавляем к сегодняшней дате количество дней, записанных в count. Код кнопки «назад» будет аналогичен, только из count нужно будет убавлять значение.
**Скриншот**
Заключение
----------
Конечно, можно поработать над дизайном, но это уже другая тема. Я лишь хотел поделиться основными технологиями. В спойлерах ниже я прикрепил скриншоты с улучшенным дизайном. Также я добавил несколько функций, например: настройки, возможность выбрать учебную группу и т.д. Само приложение можно будет посмотреть чуть позже, как только доведу его до ума.
**Скриншот приложения** | https://habr.com/ru/post/483284/ | null | ru | null |
# Интернационализация поиска по городским адресам. Реализуем русскоязычный Soundex на Sphinx Search
Как много в вашем городе иностранных туристов? В моём мало, но встречаются, как правило стоят потерянные посреди улицы и повторяют одно единственное слово – название чего бы то ни было. А прохожие пытаются им на пальцах объяснить куда пройти, а когда «моя твоя не понимать» – берут за руку и ведут к пункту назначения. Как это не удивительно, обычно цель в пяти минутах ходьбы, т.е. какое-то примерное представление о городе эти туристы всё же имели. Может по бумажной карте ориентировались.
А как часто лично вы оказывались в такой ситуации, в незнакомом городе в другой стране?
Появление смартфонов и приложений для навигации решило много проблем. Ура, можно посмотреть свою геолокацию, можно найти куда идти, прикинуть в каком направлении и даже проложить маршрут.
Осталась одна проблема: все улицы в приложении подписаны местными иероглифами на местном наречии, и ладно если в стране пребывания принята латиница, клавиатура на латинице есть во всех смартфонах и мир к ней привык, и то я испытывал дискомфорт, из-за диакритических знаков, принятых в чешском алфавите. А боль и страдания иностранцев, видящих кириллицу, могу только представить, посмотрите псевдокириллицу и поймёте. Если бы я оказался на их месте, я бы писал названия и адреса латиницей, пытаясь воспроизвести звучание - фонетический поиск.
В публикации опишу как реализовать фонетические алгоритмы поиска Soudex на движке [Sphinx Search](http://sphinxsearch.com/). Одной транслитерацией здесь не обойдётся, хотя и без неё никуда. Получившийся конфигурационный файл, доступен на [GitHub Gist](https://gist.github.com/Tkachenko-Ivan/354db31938f7ed4218ac5d20c7f9502b).
Вступление
----------
Понадобится база адресов, например, ФИАС или база названий чего-то, в общем то, что будем искать, и Sphinx Search.
Решение удобно тем, что ничего не придётся доделывать, достраивать дорабатывать в самой базе, т.е. данные останутся как есть, - всё сделает Sphinx.
Если мы решили, что, пользователи будут искать названия так, как они их на слух воспринимают, то наша беда в том, что слух у всех разный. Мы можем придумывать сколько угодно различных стандартов транслитераций, и они нам все в одинаковой степени и подходят, и нет.
Но, ничто не ново под луной и решение уже найдено до нас. Распространены два подхода Soundex и Metaphone, плюс их вариации. В публикации рассмотрим только Soundex и его варианты, Metaphone затрагивать не будем.
Более того, Sphinx уже [поддерживает Soundex](http://sphinxsearch.com/docs/manual-2.3.2.html#conf-morphology), как говорится, из коробки. Но рано бить баклуши, почивать на лаврах и стричь купоны, для кириллицы он не работает. Т.е. по сути не подходит для задачи. Придётся допиливать.
Для начала неплохо разобраться с тем что из себя представляют фонетические алгоритмы. На хабре есть статьи, лично мне нравятся: «[фонетический поиск](https://habr.com/ru/post/28752/)» – краткая и лаконичная, подойдёт для тех кто хочет в двух словах понять идею не вдаваясь в детали реализации, и вторая «[фонетические алгоритмы](https://habr.com/ru/post/114947/)», наоборот, для тех кому нужно подробнее. Я буду опираться на материал, написанный в них, стараясь как можно меньше его дублировать дабы не раздувать статью, для полноты картины, советую ознакомиться с ними, прежде чем продолжать.
А теперь подумаем, как завезти поддержку кириллицы в Soundex, реализовать и его, и улучшенную версию, и NYSIIS, и Daitch-Mokotoff.
К реализации
------------
Будут приведены некоторые примеры работы на SphinxQL, для этого использую подключение в духе:
`mysql -h 127.0.0.1 -P 9306 --default-character-set=utf8`
но публикация про реализацию фонетических алгоритмов на Sphinx, а не про работу с ним, если вам нужно введение в Sphinx Search, то советую посмотреть [блог Чакрыгина](http://chakrygin.ru/), к сожалению уже заброшенный, но для старта более чем достаточно. Там и про создание подключения есть.
### Оригинальный Soundex и Транслитерация
Начнём с самого простого в реализации. Простоты добавляет тот факт, что Sphinx Search, как я уже писал выше, поддерживает из коробки реализацию для английского языка, т.е. половина дела уже в шляпе.
Кстати, делает это он не совсем канонично: не обрезает все коды до четырёх символов, а если символов меньше четырёх – не дополняет всё нулями. Но я в этом, ни каких проблем не вижу.
Всё, что от нас требуется – сделать транслитерацию с великого и могучего, остальное Sphinx сделает сам.
Сделать транслитерацию несложно, сложно выбрать правила, по которым она будет проходить, стандартов уйма, и скорее всего это ещё не всё, ознакомиться с ними можно в Википедии: [транслитерация русского алфавита латиницей](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BB%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D0%B0%D0%BB%D1%84%D0%B0%D0%B2%D0%B8%D1%82%D0%B0_%D0%BB%D0%B0%D1%82%D0%B8%D0%BD%D0%B8%D1%86%D0%B5%D0%B9). Выбор – чистая вкусовщина, если вам не навязывается стандарт каким-нибудь приказом МВД, то берите тот который больше нравится или скомбинируйте их в свой ни на что не похожий, в конце концов задача всех этих фонетических алгоритмов – избавить нас от этих разночтений. Можно ещё посмотреть публикацию "[всё о транслитерации](https://habr.com/ru/post/499574/)", вдруг поможет определиться с выбором. Как ни выбирай, всё равно найдётся ситуация, когда все эти ухищрения не помогут, да и лошадиную фамилию всё равно не найдёт.
Прописываем в конфигурации Sphinx все правила транслита с помощью [регулярных выражений](http://sphinxsearch.com/docs/manual-2.3.2.html#conf-regexp-filter):
`regexp_filter = (А|а) => a`
а для Ъ и Ь можно написать
`regexp_filter = (Ь|ь) =>`
Не буду приводить текст для всего алфавита, если что – можно скопировать [всё там же, с GitHub Gist](https://gist.github.com/Tkachenko-Ivan/354db31938f7ed4218ac5d20c7f9502b).
И не забудьте включить soundex для латиницы:
`morphology = soundex`
Теперь, когда мы будем искать текст на кириллице он будет сначала транслитерироваться с помощью регулярных выражений, а полученная латиница будет обрабатываться Sphinx в соответствии с правилами оригинального Soundex.
Всё настроили, проиндексировали данные, создали подключение к Sphinx. Давайте попробуем найти что-нибудь. Раз уж наша цель - ~~коммунизм~~ интернационализм поисковой выдачи, то и искать будем улицы названные в честь деятелей интернационала, и сочувствующих. Поищем Ленина. Искать будем именно «Ленина», а не «Ленин», я почему-то уверен, что интуристы прямо так и будут искать «Lenina», может даже «ulitsa Lenina».
Чтобы понять что с ним происходит воспользуемся командой [CALL KEYWORDS](http://sphinxsearch.com/docs/manual-2.3.2.html#sphinxql-call-keywords):
```
mysql> call keywords('Ленин Ленина Lenina Lennina Lenin', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | lenin | l500 |
| 2 | lenina | l500 |
| 3 | lenina | l500 |
| 4 | lennina | l500 |
| 5 | lenin | l500 |
+------+-----------+------------+
```
Обратите внимание, в tokenized хранится то, что было получено после применения всех регулярных выражений. А в normalized, то по какому ключу Sphinx будет осуществлять поиск, и результат обусловлен тем, что включена morphology. 'Lenina' преобразуется в ключевое слово l500, и 'Ленина' в l500, спасибо транслиту, - уровнял, теперь на каком бы языке не искали найдётся одно и то же. Всё тоже самое и для Lennina, и для Lenena, и даже Lennona. Так что, если в вашем городе есть улица Джона Леннона, то тут может накладочка выйти.
Выполним поиск, наконец:
```
mysql> select * from STREETS where match('Lenena');
+------+--------------------------------------+-----------+--------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+--------------+
| 387 | 4b919f60-7f5d-4b9e-99af-a7a02d344767 | ул | Ленина |
+------+--------------------------------------+-----------+--------------+
```
Sphinx вернул нам один результат, даже если ввели с ошибкой. Вот с Плехановым посложнее. Тут уже в зависимости от того, какой мы способ транслитерации выберем:
```
mysql> call keywords('Плехановская Plechanovskaya Plehanovskaja Plekhanovska', 'STREETS', 0);
+------+----------------+------------+
| qpos | tokenized | normalized |
+------+----------------+------------+
| 1 | plekhanovskaja | p42512 |
| 2 | plechanovskaya | p42512 |
| 3 | plehanovskaja | p4512 |
| 4 | plekhanovska | p42512 |
+------+----------------+------------+
```
`plehanovskaja -`выбивается. Sphinx ничего не вернёт. Но, можно воспользоваться [CALL QSUGGEST](http://sphinxsearch.com/docs/manual-2.3.2.html#sphinxql-call-qsuggest):
```
mysql> CALL QSUGGEST('Plehanovskaja', 'STREETS');
+----------------+----------+------+
| suggest | distance | docs |
+----------------+----------+------+
| plekhanovskaja | 1 | 1 |
| petrovskaja | 4 | 1 |
+----------------+----------+------+
```
Функция вернёт предложения по исправлению запроса, и расстояние Левенштейна между запросом, и возможным результатом. Т.е. можно попробовать опять взять напильник в руки.
Не забудьте включить инфикс, для работы этой функции:
`min_infix_len = 2`
suggest содержит запись аналогичную по смыслу колонке tokenized, т.е. то, что получилось после применения регулярных выражений. В этом случае регулярные выражения касались только транслитерации, ***в других реализациях Soudex регулярные выражения будут применяться в том числе и для генерации кода, поэтому QSUGGEST работать не будет.***
Попробуем что-нибудь ещё найти:
```
mysql> select * from STREETS where match('30 let Pobedy');
+------+--------------------------------------+-----------+------------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+------------------------+
| 677 | 87234d80-4098-40c0-adb2-fc83ef237a5f | ул | 30 лет Победы |
+------+--------------------------------------+-----------+------------------------+
mysql> select * from STREETS where match('30 лет Побуды');
+------+--------------------------------------+-----------+------------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+------------------------+
| 677 | 87234d80-4098-40c0-adb2-fc83ef237a5f | ул | 30 лет Победы |
+------+--------------------------------------+-----------+------------------------+
```
Хорошо справляется, заодно и опечатки может исправить.
**Спойлер:** именно этот вариант в итоге и окажется самым приемлемым. Если лень читать полотенце ниже, то сразу переходите к [итогам](#itog), всё равно вывод в пользу оригинального Soundex.
### Улучшенный Soundex
Попробуем реализовать улучшенную версию. Улучшенность в том, что больше групп для кодирования символов, значит больше вариантов кодирования, значит меньше ложноположительных срабатываний.
Вначале копируем транслитерацию.
*Sphinx поддерживает наследование для* `index`*, но вынести транслитерацию в родительский индекс, а потом унаследовать её в дочерних, не получится. При наследовании индексов, Sphinx полностью игнорирует регулярные выражения родителя, они считаются переопределёнными если вы добавляете в дочерний класс новые регулярные выражения. Т.е. наследовать можно, пока в дочернем не объявить* `regexp_filter`*, который переопределит все* `regexp_filter` *родителя.*
Можно убрать `morphology = soundex` из конфигурации – она нам уже ничем не поможет, только под ногами путается. Придётся всё прописывать самим, опять через регулярные выражения.
Sphinx будет их применять последовательно, в том порядке, в котором они в конфигурации прописаны! Это важно. Для регулярных выражений используется движок RE2.
Сразу после блока с транслитерацией запишем сохранение первого символа, например: `regexp_filter = \A(A|a) => a`
Затем остальные символы заменяются на числовой код, Гласные на 0.
```
regexp_filter = \B(A|a) => 0
regexp_filter = \B(Y|y) => 0
...
```
Хотя, гласные можно просто удалять `regexp_filter = \B(Y|y) =>`
Решайте сами какой вариант нравится больше, хозяин - барин. Но я гласные выкидываю, хотя бы для того чтобы «ВЛКСМ» и «Veelkaseem» давали один результат.
```
mysql> call keywords('ВЛКСМ Veelkaseem', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | v738 | v738 |
| 2 | v738 | v738 |
+------+-----------+------------+
```
иначе будет что-то такое:
```
mysql> call keywords('ВЛКСМ Veelkaseem', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | v738 | v738 |
| 2 | v0730308 | v0730308 |
+------+-----------+------------+
```
Далее, согласные H и W просто выкидываются.
Идущие подряд символы, или входящие в одну и ту же группу, или символы/группы, разделенные буквами H или W, записываются как один. Это самое последнее действие.
```
regexp_filter = 0+ => 0
regexp_filter = 1+ => 1
...
```
Проверяем что получается:
```
mysql> call keywords('Ленин Ленина Lenina Lennina Lenin', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | l8 | l8 |
| 2 | l8 | l8 |
| 3 | l8 | l8 |
| 4 | l8 | l8 |
| 5 | l8 | l8 |
+------+-----------+------------+
mysql> select * from STREETS where match('Lenina');
+------+--------------------------------------+-----------+--------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+--------------+
| 387 | 4b919f60-7f5d-4b9e-99af-a7a02d344767 | ул | Ленина |
+------+--------------------------------------+-----------+--------------+
```
Вроде всё нормально, и Ленина мы находим во всех вариациях. Но обратите внимание, поле tokenized теперь содержит не индексируемый текс, а soundex-код. QSUGGEST отказывается работать. Если кто-то знает, как включить – пишите. Я пытался добавить юникод для цифр в [ngram\_chars](http://sphinxsearch.com/docs/manual-2.3.2.html#ngram_chars). Но это не помогло.
Проверим на Плеханове:
```
mysql> call keywords('Плехановская Plechanovskaya Plehanovskaja Plekhanovska', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | p738234 | p738234 |
| 2 | p73823 | p73823 |
| 3 | p78234 | p78234 |
| 4 | p73823 | p73823 |
+------+-----------+------------+
```
Стало вариантов много, а правильный всего один, и QSUGGEST не придёт на помощь:
```
mysql> CALL QSUGGEST('Plehanovskaja', 'STREETS');
Empty set (0.00 sec)
mysql> CALL QSUGGEST('p73823', 'STREETS');
Empty set (0.00 sec)
mysql> CALL QSUGGEST('p78234', 'STREETS');
Empty set (0.00 sec)
```
Хотели, как лучше, а получилось, как всегда. Сам алгоритм реализовали, вроде правильно, но непрактично. Хотя нерабочим его тоже не назовёшь. Например, вот как он побеждает «30 лет Победы»:
```
mysql> call keywords('30 let Podedy', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | 30 | 30 |
| 2 | l6 | l6 |
| 3 | p6 | p6 |
+------+-----------+------------+
mysql> select * from STREETS where match('30 let Pobedy');
+------+--------------------------------------+-----------+------------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+------------------------+
| 677 | 87234d80-4098-40c0-adb2-fc83ef237a5f | ул | 30 лет Победы |
+------+--------------------------------------+-----------+------------------------+
```
И даже так работает:
```
mysql> select * from STREETS where match('Вэлкасэем');
+------+--------------------------------------+--------------+----------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+--------------+----------------------+
| 873 | abdb0221-bfe8-4cf8-9217-0ed40b2f6f10 | проезд | 30 лет ВЛКСМ |
| 1208 | f1127b16-8a8e-4520-b1eb-6932654abdcd | ул | 50 лет ВЛКСМ |
+------+--------------------------------------+--------------+----------------------+
```
Может подойти, если механизма исправления запросов, на которые ничего не вернулось, не предусмотрено.
### NYSIIS
Ходят слухи что разработан он был для работы с американскими фамилиями. «Американские» это вообще какая-то условность. Да и «фамилии» тоже, подойдёт и для поиска по названиям улиц и другим именам собственным, тем более в России многие улицы названы чьей-то фамилией, хотя американцами эти люди не стали.
*Далее будет использоваться модификатор (?i) для работы регулярных выражений без учёта регистра.*
Начинаем с транслитерации, как всегда. Затем:
1. Преобразовать начало слова
`regexp_filter = (?i)\b(mac) => mcc`
2. Преобразовать конец слова
`regexp_filter = (?i)(ee)\b => y`
3. После гласных: удалить H, преобразовать W в А
`regexp_filter = (?i)(a|e|i|o|u|y)h => \1`
`regexp_filter = (?i)(a|e|i|o|u|y)w => \1a`
4. Преобразовываем все буквы кроме первой
`regexp_filter = (?i)\B(e|i|o|u) => a`
`regexp_filter = (?i)\B(q) => g`
5. Удалить S на конце
`regexp_filter = (?i)s\b =>`
6. Преобразуем AY на конце в Y
7. Удалить A на конце
*Напоминаю что регулярные выражения приведены не все, а минимум, для примера!!!*
Самое замечательное, - это то, что код не числовой, а буквенный, а значит снова заработает CALL QSUGGEST.
Проверяем:
```
mysql> call keywords('Ленин Ленина Lenina Lennina Lenin', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | lanan | lanan |
| 2 | lanan | lanan |
| 3 | lanan | lanan |
| 4 | lannan | lannan |
| 5 | lanan | lanan |
+------+-----------+------------+
mysql> call keywords('Плехановская Plechanovskaya Plehanovskaja Plekhanovska', 'STREETS', 0);
+------+---------------+---------------+
| qpos | tokenized | normalized |
+------+---------------+---------------+
| 1 | plachanavscaj | plachanavscaj |
| 2 | plachanavscay | plachanavscay |
| 3 | plaanavscaj | plaanavscaj |
| 4 | plachanavsc | plachanavsc |
+------+---------------+---------------+
```
Пробуем понять что имел в виду пользователь, используем для этого CALL QSUGGEST Plehanovskaja, преобразовавшуюся в plaanavscaj:
```
mysql> CALL QSUGGEST('plaanavscaj', 'STREETS');
+---------------+----------+------+
| suggest | distance | docs |
+---------------+----------+------+
| paanarscaj | 2 | 1 |
| plachanavscaj | 2 | 1 |
| latavscaj | 3 | 1 |
| sladcavscaj | 3 | 1 |
| pacravscaj | 3 | 1 |
+---------------+----------+------+
```
И тут возникают коллизии. Да ещё и без пол-литра не разберёшься что тут такое.
Узнать правдуpaanarscaj **→** Пионерская
plachanavscaj **→** Плехановская
latavscaj **→** Литовская
sladcavscaj **→** Сладковская
pacravscaj **→** Покровская
С таким подходом мы любой адрес из-под земли достанем, даже если пользователь искал не его и ему туда не надо. Зато шансов что-то НЕ найти не осталось. Берите, если на неправильный запрос нужно возвращать много разных вариантов исправления. Может пользователь туда и не хотел, но вдруг передумает, глядя на предложенные варианты.
### Daitch-Mokotoff Soundex
И последний по списку, но не по значению, из алгоритмов Soundex.
Чувствителен к порядку преобразования. Например, если преобразование выполняется по принципу «за гласной», то нам не нужно запоминать что гласную удалили ещё не предыдущем шаге, раз удалили, - значит там её уже нет, и правило не сработает и не должно, - так и задумано.
Как всегда, в начале транслитерация.
Потом выполняем пошаговую трансформацию.
Каждый шаг состоит из трёх условий, т.е. три разных регулярных выражения:
* если буквосочетание в начале слова
`regexp_filter = (?i)\b(au) => 0`
* если за гласной
`regexp_filter = (?i)(a|e|i|o|u|y)(au) => \17`
* и остальные случаи, здесь даже \B в регулярном выражении можно не писать, потому что другие варианты уже были ранее обработаны
`regexp_filter = (?i)au =>`
Иногда нет никакой разницы между двумя или тремя разными ситуациями – и одного-два регулярных выражения на шаг хватит:
`regexp_filter = (?i)j => 1`
Глянем что получается:
```
mysql> call keywords('Ленин Ленина Lenina Lennina Lenin', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | 866 | 866 |
| 2 | 866 | 866 |
| 3 | 866 | 866 |
| 4 | 8666 | 8666 |
| 5 | 866 | 866 |
+------+-----------+------------+
mysql> call keywords('Плехановская Plechanovskaya Plehanovskaja Plekhanovska', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | 7856745 | 7856745 |
| 2 | 7856745 | 7856745 |
| 3 | 786745 | 786745 |
| 4 | 7856745 | 7856745 |
+------+-----------+------------+
```
Опять исключительно числовой код, и опять QSUGGEST не поможет понять пользователя. Со всякими непонятками всё ещё справляется неплохо.
```
mysql> select * from STREETS where match('Veelkaseem'); show meta;
+------+--------------------------------------+--------------+----------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+--------------+----------------------+
| 873 | abdb0221-bfe8-4cf8-9217-0ed40b2f6f10 | проезд | 30 лет ВЛКСМ |
| 1208 | f1127b16-8a8e-4520-b1eb-6932654abdcd | ул | 50 лет ВЛКСМ |
+------+--------------------------------------+--------------+----------------------+
2 rows in set (0.00 sec)
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| total | 2 |
| total_found | 2 |
| time | 0.000 |
| keyword[0] | 78546 |
| docs[0] | 2 |
| hits[0] | 2 |
+---------------+-------+
```
Ну и всё на этом, никакого чуда не произошло, - мы уже это видели.
Итоги
-----
Реализовать Soundex, в целом получилось, из всех вариантов предпочтительнее оригинальный Soundex и NYSIIS, по той простой причине что работаем мы напрямую с буквенным кодом и можно вызвать CALL QSUGGEST, а Sphinx предложит варианты исправления, при том в NYSIIS много и всяких-разных. Улучшенный Soundex и Daitch-Mokotoff Soundex, должны снизить количество коллизий, охотно верю, что так и происходит, но проиндексировав 1286 названий улиц своего города, я не заметил, чтобы коллизии были хоть какой-то проблемой. Хотя встречаются:
```
mysql> call keywords('Воровского Вербовая', 'STREETS', 0);
+------+------------+------------+
| qpos | tokenized | normalized |
+------+------------+------------+
| 1 | vorovskogo | v612 |
| 2 | verbovaja | v612 |
+------+------------+------------+
```
Это был оригинальный Soundex, в улучшенном уже нормально:
```
mysql> call keywords('Воровского Вербовая', 'STREETS', 0);
+------+-----------+------------+
| qpos | tokenized | normalized |
+------+-----------+------------+
| 1 | v9234 | v9234 |
| 2 | v9124 | v9124 |
+------+-----------+------------+
```
Зато алгоритмы стали менее терпимы к опечаткам, особенно если она допущена в согласной. Например, оригинальный Soundex:
```
mysql> select * from STREETS where match('Ордхоникидзе');
+------+--------------------------------------+-----------+--------------------------+
| id | aoguid | shortname | offname |
+------+--------------------------------------+-----------+--------------------------+
| 12 | 0278d3ee-4e17-4347-b128-33f8f62c59e0 | ул | Орджоникидзе |
+------+--------------------------------------+-----------+--------------------------+
```
А остальные реализации ничего не возвращают.
Невозможность вызова QSUGGEST, тоже кажется существенной проблемой. Хотя, может я просто не умею её готовить. Если знаете, как – делитесь рецептом.
В общем, не мудрствуя лукаво, мой совет: используйте оригинальный Soundex с транслитерацией. Единственный риск - коллизии, чтобы их разрешить, просто-напросто возьмите оригинальный запрос, и подсчитайте [расстояние Левенштейна](https://ru.wikipedia.org/wiki/%20%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0) между ним, и теми несколькими записями что вам предлагает Sphinx.
Если возможности проводить постобработку нет, ни для исправления, ни для разрешения коллизий, то выбирайте улучшенный Soundex или Daitch-Mokotof - хотя бы Вербовую, вместо Воровского не получите. NYSIIS подойдёт если вы хотите пользователю, на запрос с ошибкой, предложить, как можно больше самых непохожих друг на друга вариантов.
Всё написанное испытано на sphinx-3.3.1, но должно работать на всём с версии 2.1.1-beta, в которой появились регулярные выражения. В том числе на Manticore. Разработчики Manticore Search, хвастаются что [прогресс идёт в гору семимильными шагами](https://habr.com/ru/post/541126/). Может там будет поддержка и прочих алгоритмов, хотя бы для латиницы, а может и сразу для кириллицы.
И по большому счёту этот подход приемлем для всего, к чему можно прикрутить транслит. Можно хоть китайскую грамоту индексировать, только транслитерацию знай прикручивай.
P.S.
----
Статья получилось неожиданно большой, сам не ожидал. Поэтому про Metaphone не написал. Для него будет, или не будет, отдельная статья. Хотя принцип тот же:
1. Транслит-регулярки
2. Ещё регулярки
3. ????
4. PROFIT
### UPD Metaphone
Статья по Metaphone вышла: "[Продолжаем интернационализацию поиска по адресам с помощью Sphinx или Manticore. Теперь Metaphone](https://habr.com/ru/post/550690/)".
UPD Docker
----------
Подготовил докер образ, в котором можно посмотреть результат. В образе построен поисковый индекс по улицам города Тюмень: [tkachenkoivan/searchfonetic](https://hub.docker.com/r/tkachenkoivan/searchfonetic) | https://habr.com/ru/post/547652/ | null | ru | null |
# Systemd и контейнеры: знакомство с systemd-nspawn
Контейнеризация сегодня — одна из самых актуальныx тем. Количество публикаций о таких популярных инструментах, как LXC или Docker, исчисляется тысячами, если не десятками тысяч.
В этой статье бы хотели мы обсудить ещё одно решение, о котором публикаций на русском языке пока что мало. Речь идёт о [systemd-nspawn](http://www.freedesktop.org/software/systemd/man/systemd-nspawn.html) — инструменте для создания изолированных сред, который является одним из компонентов systemd. А закрепление systemd в качестве стандарта в мире Linux — уже свершившийся факт. В свете этого факта есть все основания полагать, что в ближайшее время сфера применения systemd-nspawn существенно расширится, и познакомиться с этим инструментом поближе стоит уже сейчас.
Systemd-nspawn: общая информация
---------------------------------
Название systemd-nspawn представляет собой сокращение от namespaces spawn. Уже из этого названия следует, что systemd-nspawn управляет только изоляцией процессов, но при этом не может изолировать ресурсы (однако это можно сделать средствами самого systemd, о чём ещё пойдёт речь ниже).
С помощью systemd-nspawn можно создать полностью изолированое окружение, в котором автоматически будут смонтированы псевдофайловые системы /proc и /sys, а также созданы изолированный loopback-интерфейс и отдельное пространство имён для идентификаторов процессов (PID), внутри которого можно запускать ОС, основанную на ядре Linux.
Cпециального репозитория образов, как в Docker, в systemd-nspawn не существует. Для создания и загрузки образов можно использовать любые сторонние инструменты. Поддерживаются форматы tar, raw, qcow2 и dkr (dkr — это образы для Docker; в документации к systemd-nspawn об этом в явной форме нигде не написано, а её авторы старательно избегают самого слова Docker). Работа с образами осуществляется на базе файловой системы [BTRFS](https://btrfs.wiki.kernel.org/).
Запускаем в контейнере Debian
-----------------------------
Знакомство с systemd-nspawn начнём с простого, но показательного практического примера. На сервере под управлением OC Fedora мы создадим изолированное окружение, в котором будет запущен ОС Debian. Все примеры команд ниже приводятся для Fedora 22 c systemd 219-й версии; в других дистрибутивах Linux и других версиях systemd команды могут отличаться.
Начнём с установки необходимых зависимостей:
```
sudo dnf install debootstrap bridge-utils
```
Затем создадим файловую систему для будущего контейнера:
```
sudo debootstrap --arch=amd64 jessie /var/lib/machines/container1/
```
По завершении всех подготовительных работ можно приступать к запуску контейнера:
```
sudo systemd-nspawn -D /var/lib/machines/container1/ --machine test_container
```
На консоли появится приглашение гостевой операционной системы:
```
root@test_container
```
Установим для неё root-пароль:
```
passwd
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
```
Выйдем из контейнера, нажав комбинацию клавиш Ctrl+]]], а затем выполним следующую команду:
```
sudo systemd-nspawn -D /var/lib/machines/container1/ --machine test_container -b
```
В ней присутствует флаг -b (или −−boot), который указывает, что при запуске экземпляра операционной системы в контейнере нужно выполнить init с запуском всех демонов.Этот флаг можно использовать только в случае, если в контейнере будет запущена система с поддержкой systemd.В противном случае загрузка системы не гарантируется.
По завершении всех указанных операций система предложит ввести логин и пароль.
Итак, полноценная ОС в изолированном окружении запущена. Теперь нужно настроить для неё сеть, Выйдем из контейнера и создадим мост, через который он будет соединятся с интерфейсом на основном хосте:
```
sudo brctl addbr cont-bridge
```
Назначим для этого моста IP-адрес:
```
ip a a [IP-адрес] dev cont-bridge
```
После этого выполним команду:
```
sudo systemd-nspawn -D /var/lib/machines/container1/ --machine test_container --network-bridge=cont-bridge -b
```
Для настройки сети можно также воспользоваться опцией −−network-ipvlan, которая свяжет контейнер с указанным интерфейсом на основном хосте с помощью ipvlan:
```
sudo systemd-nspawn -D /var/lib/machines/container1/ --machine test_container -b --network-ipvlan=[сетевой интерфейс]
```
Запускаем контейнер как службу
------------------------------
С помощью systemd можно настроить автоматический запуск контейнеров при загрузке системы. Для этого добавим в директорию /etc/systemd/system вот такой конфигурационный файл:
```
[Unit]
Description=Test Container
[Service]
LimitNOFILE=100000
ExecStart=/usr/bin/systemd-nspawn --machine=test_container --directory=/var/lib/machines/container1/ -b --network-ipvlan=[сетевой интерфейс]
Restart=always
[Install]
Also=dbus.service
```
Прокомментируем приведённый фрагмент. В cекции [Description] мы просто указываем имя контейнера. В секции [Service] мы сначала задаём лимит на количество открытых файлов в контейнере (LimitNOFILE), затем указываем команду на запуск контейнера с необходимыми опциями (ExecStart). Указание Restart=always означает, что контейнер нужно перезапустить в случае «падения». В секции [Install] указывается дополнительный юнит, который должен быть добавлен в автозапуск на хосте (в нашем случае это система межпроцесcного взаимодействия D-Bus).
Сохраним изменения в конфигурационном файле и выполним команду:
```
sudo systecmctl start test_container
```
Запускать контейнер как службу можно и другим, более простым способом. В systemd имеется заготовка конфигурационного файла для автоматического запуска контейнеров, помещённых в директорию /var/lib/machines. Активировать запуск на базе этой заготовки можно с помощью следующих команд:
```
sudo systemctl enable machine.target
mv ~/test_container /var/lib/machines/test_container
sudo systemctl enable systemd-nspawn@test_container.service
```
Управление контейнерами: утилита machinectl
-------------------------------------------
Контейнерами можно управляться с помощью утилиты machinectl. Кратко рассмотрим её основные опции.
Вывести список всех имеющихся в системе контейнеров:
```
sudo machinectl list
```
Просмотреть информацию о статусе контейнера:
```
sudo machinectl status test_container
```
Войти в контейнер:
```
sudo machinectl login test_container
```
Перезагрузить контейнер:
```
sudo machinectl reboot test_container
```
Остановить контейнер:
```
sudo machinectl poweroff test_container
```
Последняя команда cработает, если в контейнере установлена ОС, совместимая с systemd. Для операционных систем, использующих sysvinit, нужно воспользоваться опцией terminate.
Мы рассказали лишь о самых базовых возможностях утилиты machinectl; с подробной инструкцией по её использованию можно ознакомиться, например, [здесь](http://www.freedesktop.org/software/systemd/man/machinectl.html).
Загрузка образов
----------------
Выше мы уже говорили, что с помощью systemd-nspawn можно запускать образами любых других форматов. Есть, однако, одно важное условие: работа с образами возможна только на базе файловой системы BTRFS, которую нужно примонтировать к директории /var/lib/machines:
```
sudo dnf install btrfs-progs
mkfs.btrs /dev/sdb
mount /dev/sdb /var/lib/machines
mount | grep btrfs
dev/sdb on /var/lib/machines type btrfs (rw,relatime,seclabel,space_cache)
```
Если нет свободного диска, BTRFS можно сделать и в файле.
В более новых версиях systemd возможность загрузки образов поддерживается «из коробки», и монтировать BTRFS не нужно.
Попробуем загрузить образ Docker:
```
sudo machinectl pull-dkr --verify=no library/redis --dkr-index-url=https://index.docker.io
```
Запуск контейнера на базе загруженного образа осуществляется просто:
```
sudo systemd-nspawn --machine redis
```
Просмотр логов контейнера
-------------------------
Информация обо всех событиях, происходящих внутри контейнеров, записывается в логи. Настройки логгирования можно устанавливать непосредственно при создании контейнера с помощью опции
−−link-journal, например:
```
sudo systemd-nspawn -D /var/lib/machines/container1/ --machine test_container -b --link-journal=host
```
Приведённая команда указывает, что логи контейнера будут храниться с на основном хосте в директории /var/log/journal/machine-id. Если же выставить опцию −−link-journal=guest, то вся логи будут храниться в контейнере в директории /var/log/journal/machine-id, а на основном хосте будет создана символическиая ссылка в директории c аналогичным адресом. Опция −−link-journal будет работать только в случае, если в контейнере будет запущена система с systemd. В противном случае корректное логгирование не гарантируется.
Просмотреть информацию о запусках и остановках контейнера можно с помощью утилиты journalctl, о которой мы уже писали [одной из предыдущих публикаций](http://habrahabr.ru/company/selectel/blog/264731/):
```
journalctl -u test_container.service
```
В journalctl предусмотрена возможность просмотра логов событий внутри контейнера.
Для этого используется опция -M (приводим лишь небольшой фрагмент вывода):
```
journalctl -M test_container
Sep 18 11:50:21 octavia.localdomain systemd-journal[16]: Runtime journal is using 8.0M (max allowed 197.6M, trying to leave 296.4M free of 1.9G available <86><92> current limit 197.6M).
Sep 18 11:50:21 octavia.localdomain systemd-journal[16]: Runtime journal is using 8.0M (max allowed 197.6M, trying to leave 296.4M free of 1.9G available <86><92> current limit 197.6M).
Sep 18 11:50:21 octavia.localdomain systemd-journal[16]: Journal started
Sep 18 11:50:21 octavia.localdomain systemd[1]: Starting Slices.
Sep 18 11:50:21 octavia.localdomain systemd[1]: Reached target Slices.
Sep 18 11:50:21 octavia.localdomain systemd[1]: Starting Remount Root and Kernel File Systems...
Sep 18 11:50:21 octavia.localdomain systemd[1]: Started Remount Root and Kernel File Systems.
Sep 18 11:50:21 octavia.localdomain systemd[1]: Started Various fixups to make systemd work better on Debian.
```
Выделение ресурсов
------------------
Основные особенности systemd-nspawn мы рассмотрели. Остался один важный момент: выделение контейнерам ресурсов. Как уже отмечалось выше, systemd-nspawn ресурсы не изолирует. Ограничить потребление ресурсов для контейнера можно с помощью systemctl, например:
```
sudo systemctl set-property [имя контейнера] CPUShares=200 CPUQuota=30% MemoryLimit=500M
```
Ограничения ресурсов для контейнера можно прописать и в юнит-файле, в секции [Slice].
Заключение
----------
Systemd-nspawn — инструмент интересный и перспективный. В числе его несомненных плюсов стоит выделить:
* тесную интеграцию с другими компонентами systemd;
* возможность работы с образами в разных форматах;
* отсутствие необходимости устанавливать какие-либо дополнительные пакеты или накладывать патчи на ядро.
Конечно, говорить о полноценном использовании systemd-nspawn в продакшне пока что рано: инструмент пока что находится в «сыром» состоянии и подходит только для тестирования и экспериментов. Однако по мере дальнейшего распространения systemd стоит ждать и усовершенствования systemd-nspawn.
Естественно, что в рамках обзорной статьи невозможно рассказать абсолютно обо всём. В комментариях приветствуются любые вопросы, замечания и дополнения.
Если мы упустили какие-то детали или не рассказали о каких-то интересных возможностях systemd-nspawn — напишите, и мы обязательно дополним наш обзор.
А если кто-то из вас пользуется systemd-nspawn, приглашаем поделиться опытом.
Читателей, которые по тем или иным причинам не могут оставлять комментарии здесь, [приглашаем в наш блог](https://blog.selectel.ru/systemd-i-kontejnery-znakomstvo-s-systemd-nspawn/). | https://habr.com/ru/post/271957/ | null | ru | null |
# Улучшаем border-radius.htc
Думаю многим верстальщикам известно решение, которое заставляет IE рисовать скругленные уголки: «[curved-corner](http://code.google.com/p/curved-corner/)» (или border-radius.htc).
В этой статье я расскажу, как избавиться от ошибок «Invalid argument» при его использовании, а также как в разы ускорить его работу.
В одном проекте, где применялся этот способ, в IE вылетало 7 окон с ошибкой следующего содержания:
Возникала она именно в border-radius.htc и вот что ее вызывало:
`var css = el.document.createStyleSheet();`
[Выяснилось](http://www.spravkaweb.ru/css/reference/methods/createstylesheet/), что с помощью метода `createStyleSheet` можно добавить до 31 таблицы стилей. После этого значения будет выведена ошибка Неправильный аргумент (Invalid Argument).
Открыв DebugBar, я увидел следующее:
<Встроенная таблица стилей> — это и есть таблица стилей, созданная скриптом. Причем их было около 38 штук и они все содержали одинаковый код.
`v\:roundrect {
BEHAVIOR: url(#default#VML)
}
v\:fill {
BEHAVIOR: url(#default#VML)
}`
Отсюда вполне очевидное решение: просто вставляем этот код в css-файл, который подключаем через Conditional comments только для IE. А в border-radius.htc удаляем (или комментируем) эти 3 строчки:
`var css = el.document.createStyleSheet();
css.addRule("v\\:roundrect", "behavior: url(#default#VML)");
css.addRule("v\\:fill", "behavior: url(#default#VML)");`
В результате пропали ошибки Invalid Argument и уменьшилось время загрузки сайта в IE, т.к. больше не нужно генерировать 38 таблиц стилей.
Profit! | https://habr.com/ru/post/102904/ | null | ru | null |
# Свои потоки ввода-вывода в C++ с помощью std::streambuf
*В статье на примерах объясняется, как реализовать поддержку потокового ввода-вывода из стандартной библиотеки () для своих классов.
В тексте статьи будет часто встречаться слово «поток», что означает именно поток ввода-вывода ((i/o)stream), но не поток выполнения (thread). Потоки выполнения в статье не рассматриваются.*
Введение
========
Потоки из стандартной библиотеки — мощный инструмент. Аргументом функции можно указать поток, и это обеспечивает ее универсальность: она может работать как со стандартными файлами (fstream) и консолью (cin/cout), так и с сокетами и COM-портами, если найти соответствующую библиотеку.
Однако не всегда можно найти готовую библиотеку, где подходящий функционал уже реализован, может даже вы разрабатываете собственную библиотеку со своими классами. Тогда возникает задача реализации интерфейса потоков своими силами.
### Используемое окружение
При написании статьи для теста примеров использовался компилятор g++ (Ubuntu 5.4.0-6ubuntu1~16.04.4), а также стандарт c++11. Для наглядности я использовал из него ключевое слово override, чтобы пометить переопределяемые методы базового класса, однако если его убрать (а еще nullptr на NULL заменить), то должно собраться и на более старых стандартах.
Все примеры также доступны на github: [streambuf\_examples](https://github.com/iassasin/streambuf_examples).
Содержание
==========
* [Как устроены потоки?](#General)
* [Простые случаи — без буферизации](#No_buffers)
+ [Пример 1 — фильтруем цифры](#Example_1)
* [Используем буферы](#Use_buffers)
+ [Пример 2 — блочный вывод](#Example_2)
+ [Пример 3 — буферизированный ввод из файла](#Example_3)
* [Расширенные возможности](#Extended)
+ [seekoff и seekpos для перемещения по файлу](#Seeks)
+ [pbackfail — возврат прочитанных символов назад](#pbackfail)
+ [Пример 4 — чтение файла с позиционированием и возвратом символов](#Example_4)
+ [Другие возможности](#Other)
* [Заключение](#End)
* [Ссылки](#Links)
Как устроены потоки?
====================
Каждый класс, поддерживающий потоковый ввод-вывод, наследует классы **std::istream** (ввод), **std::ostream** (вывод) или **std::iostream** (ввод и вывод). Именно они обеспечивают возможность использования перегруженных операторов '<<' и '>>', форматирования вывода, преобразование чисел в строки и наоборот и т.д.
Однако непосредственное чтение или запись данных происходят не в нем, а в классе, наследующем **std::streambuf**. Сам по себе streambuf является лишь интерфейсом с набором виртуальных функций, которые надо переопределить в классе-наследнике и уже в них реализовать свою логику чтения/записи данных (именно так и сделано в классах std::filebuf и std::stringbuf для fstream и stringstream соответственно).
Кроме того streambuf реализует часть логики работы с буфером. Программисту остается лишь задать начало и конец буфера и реализовать обработчики событий его переполнения, опустошения, синхронизации и т.п.
При разработке собственных потоков наиболее сложной частью является реализация наследника **std::streambuf**. Производные классы от istream, ostream или iostream в простых случаях могут и вовсе отсутствовать.
Простые случаи — без буферизации
================================
В простом случае или когда производительность не играет важной роли, буферы могут быть не нужны. Тогда достаточно переопределить всего три виртуальные функции:
* **int overflow(int c)** — вызывается при переполнении буфера. Аргументом является символ, который «не влез» в буфер.
Возвращаемое значение: в случае успеха, код записанного сивола, приведенный к типу int, иначе EOF.
Поведение по-умолчанию: всегда возвращает EOF.
* **int underflow()** — вызывается для получения текущего символа без перехода к следующему.
Возвращаемое значение: в случае успеха, код считанного символа, приведенный к типу int, иначе EOF.
Поведение по-умолчанию: если буфер доступен и есть несчитанные символы, возвращает символ на текущей позиции в буфере, иначе EOF.
* **int uflow()** — то же самое, что underflow, но в случае успеха сдвигает указатель буфера к следующему символу.
Возвращаемое значение: как в underflow.
Поведение по-умолчанию: вызывает underflow. Если результат успешен, сдвигает указатель буфера к следующему символу и возвращает результат вызова underflow, в случае неудачи возвращает EOF. Попытка сдвинуть указатель незаданного буфера окончится segmentation fault-ом, не забудьте переопределить это поведение, если не используете буфер!
*Здесь и далее описание функций взято с cppreference.com*
Пример 1 — фильтруем цифры
--------------------------
Пожалуй, пока хватит текста. В качестве примера разберем фильтрующий поток, который будет пропускать только символы цифр и пробелы (чтобы числа можно было как-то разделять друг от друга), сами данные будем брать из другого потока.
**Код**
```
#include
#include
#include
using namespace std;
class numfilterbuf : public streambuf {
private:
istream \*in;
ostream \*out;
int cur; //последнее считанное значение, используется в underflow()
protected:
/\* функции записи в поток: \*/
virtual int overflow(int c) override {
if (c == traits\_type::eof()){
return traits\_type::eof();
}
char\_type ch = static\_cast(c);
if (ch == ' ' || (ch >= '0' && ch <= '9')){ // отдаем пробелы и цифры
out->put(ch);
//если что-то не записалось, отдаем EOF
return out->good() ? ch : traits\_type::eof();
}
return ch;
}
/\* функции чтения из потока: \*/
//реализация по-умолчанию инкрементирует позицию указателя в буфере и вызывает segmentation fault
virtual int uflow() override {
int c = underflow();
cur = traits\_type::eof(); //говорим underflow() считать следующий символ при следующем вызове
return c;
}
virtual int underflow() override {
if (cur != traits\_type::eof()){
return cur;
}
// пока можем читать, читаем
while (in->good()){
cur = in->get();
if (cur == traits\_type::eof()){
return traits\_type::eof();
}
char\_type ch = static\_cast(cur);
if (ch == ' ' || (ch >= '0' && ch <= '9')){ // отдаем только пробелы и цифры
return ch;
}
}
return traits\_type::eof();
}
public:
numfilterbuf(istream &\_in, ostream &\_out)
: in(&\_in), out(&\_out), cur(traits\_type::eof())
{}
};
int main(int argc, char \*\*argv){
const char str1[] = "In 4 bytes contains 32 bits";
const char str2[] = "Unix time starts from Jan 1, 1970";
istringstream str(str1);
numfilterbuf buf(str, cout); // читать из stringstream, выводить в консоль
iostream numfilter(&buf); // таким образом обходимся без реализации своего наследника iostream
string val;
getline(numfilter, val);
numfilter.clear(); // сбросить невалидное состояние после EOF в процессе чтения из stringstream
cout << "Original: '" << str1 << "'" << endl;
cout << "Read from numfilter: '" << val << "'" << endl;
cout << "Original: '" << str2 << "'" << endl;
cout << "Written to numfilter: '";
numfilter << str2;
cout << "'" << endl;
return 0;
}
```
Результат работы программы:
```
Original: 'In 4 bytes contains 32 bits'
Read from numfilter: ' 4 32 '
Original: 'Unix time starts from Jan 1, 1970'
Written to numfilter: ' 1 1970'
```
Основные моменты в коде уже прокомментированы, однако дополнительно стоит отметить, что для чтения важно реализовать обе функции — **uflow** и **underflow**, поскольку underflow может вызываться *до* uflow и даже *несколько раз подряд*. Если добавить в начало этих функций отладочный вывод, это можно увидеть наглядно, например, при чтении из потока в целочисленную переменную.
Также в коде вы могли заметить использование типа `char_type`. Он определяется в классе streambuf и в нашем случае является алиасом к типу `char`, т.е. однобайтовый символ. Подробнее об этом будет сказано в конце статьи.
Используем буферы
=================
Как я уже ранее говорил, streambuf уже реализует в себе часть логики работы с буфером и предоставляет доступ к 6-и указателям, по 3 указателя на входной и выходной буферы. Однако streambuf не реализует выделение памяти под буферы. Эта задача возлагается на программиста вместе с инициализацией буферных указателей.
Для входного буфера указатели следующие:
* **eback()** *(end back pointer)* — указатель на первый элемент буфера
* **gptr()** *(get pointer)* — указатель на на элемент буфера, который будет считан следующим
* **egptr()** *(end get pointer)* — указатель на элемент, следующий за последним элементом буфера. Когда `gptr` достигает его, это означает, что буфер исчерпан и его нужно снова заполнить
*Наглядная иллюстрация с сайта mr-edd.co.uk*
Также для управления указателями входного буфера служат следующие фукнции:
* **setg(eback, gptr, egptr)** — устанавливает значения соответствующих указателей
* **gbump(offset)** — сдвинуть указатель `gptr` на `offset` позиций. Фактически, после выполнения функции `gptr` примет значение `gptr + offset`
Указатели выходного буфера имеют схожие имена и назначение:
* **pbase()** *(put base pointer)* — указатель на первый элемент буфера
* **pptr()** *(put pointer)* — указатель на на элемент буфера, который будет записан следующим
* **epptr()** *(end put pointer)* — указатель на элемент, следующий за последним элементом буфера.
*Еще одна наглядная иллюстрация с сайта mr-edd.co.uk*
Управляющие функции выходного буфера также схожи:
* **setp(pbase, epptr)** — устанавливает значения соответствующих указателей. Обратите внимание, что у `setp` только два аргумента, в отличие от `setg`. При инициализации указателей выходного буфера `pptr` автоматически приравнивается `pbase` (т.е. устанавливается на начало буфера)
* **pbump(offset)** — сдвинуть указатель `pptr` на `offset` позиций. Фактически, после выполнения функции `pptr` примет значение `pptr + offset`
На этом теория кончается, и мы переходим к практике.
Пример 2 — блочный вывод
------------------------
В одном проекте мне понадобилось прозрачно делить поток на небольшие части, каждая из которых при выводе сопровождалась некоторым заголовком. Реализовал я это с помощью нового наследника `streambuf`. Мне показалось, что этот класс достаточно просто и понятно показывает простую работу с выходным буфером. Поэтому в следующем примере мы будем делить вывод на части и обрамлять каждую тегами и :
**Код**
```
#include
#include
#include
#include
using namespace std;
class blockoutputbuf : public streambuf {
private:
ostream \*out;
vector buffer;
string startb, endb;
protected:
virtual int overflow(int c) override {
if (out->good() && c != traits\_type::eof()){
\*pptr() = c; //тут нам пригодился 1 "лишний" символ, убранный в конструкторе
pbump(1); //смещаем указатель позиции буфера на реальный конец буфера
return sync() == 0 ? c : traits\_type::eof();
}
return traits\_type::eof();
}
virtual int sync() override {
if (pptr() == pbase()) //если буфер пуст, то и синхронизировать нечего
return 0;
ptrdiff\_t sz = pptr() - pbase(); //вычисляем, сколько символов записано в буффер
//заворачиваем буфер в наш блок
\*out << startb;
out->write(pbase(), sz);
\*out << endb;
if (out->good()){
pbump(-sz); //при успехе перемещаем указатель позиции буфера в начало
return 0;
}
return -1;
}
public:
blockoutputbuf(ostream &\_out, size\_t \_bufsize, string \_startb, string \_endb)
: out(&\_out), buffer(\_bufsize), startb(\_startb), endb(\_endb)
{
char\_type \*buf = buffer.data();
setp(buf, buf + (buffer.size() - 1)); // -1 для того, чтобы упростить реализацию overflow()
}
};
int main(int argc, char \*\*argv){
const char str1[] = "In 4 bytes contains 32 bits";
const char str2[] = "Unix time starts from Jan 1, 1970";
blockoutputbuf buf(cout, 10, "", "\n");
ostream blockoutput(&buf);
cout << "Original: '" << str1 << "'" << endl;
cout << "Written to blockoutputbuf: '";
blockoutput << str1;
blockoutput.flush(); //"сбросить" то, что не отправлено на консоль из str1
cout << "'" << endl;
cout << "Original: '" << str2 << "'" << endl;
cout << "Written to blockoutputbuf: '";
blockoutput << str2;
blockoutput.flush();
cout << "'" << endl;
return 0;
}
```
Внимательный читатель наверняка давно уже задумался: буфер буфером, но ведь его надо как-то сбрасывать и не только при переполнении, но и по требованию программиста (подобно тому, как это происходит при записи в файл).
Для этого и служит еще одна виртуальная функция **int sync()**. Обычно она вызывается как раз по требованию программиста, однако в примере выше мы также вызываем ее сами при переполнении буфера. Возвращаемое ею значение говорит об успешной синхронизации (0) или неудачной (-1), при неудаче поток приобретает невалидное состояние. Реализация по-умолчанию ничего не делает и просто возвращает 0 (успех).
Кстати о переполнении буфера. В примере для упрощения реализации `overflow()` применен небольшой трюк: фактический размер буфера всегда на 1 элемент больше, чем «думает» streambuf. Это позволяет поместить переданный функции `overflow` «не влезший» символ в буфер и не усложнять код его специфичной обработкой.
Вывод программы для блоков размером в 10 символов следующий:
**Вывод**
```
Original: 'In 4 bytes contains 32 bits'
Written to blockoutputbuf: 'In 4 bytes
contains
32 bits
'
Original: 'Unix time starts from Jan 1, 1970'
Written to blockoutputbuf: 'Unix time
starts fro
m Jan 1, 1
970
'
```
Пример 3 — буферизированный ввод из файла
-----------------------------------------
С чтением все несколько сложнее, поэтому начнем с простого. В примере ниже с помощью потока реализовано простое последовательное чтение файла. Для получения данных из файла используем средства стандартной библиотеки языка Си.
**Код**
```
#include
#include
#include
#include
#include
using namespace std;
class cfilebuf : public streambuf {
private:
vector buffer;
FILE \*file;
protected:
virtual int underflow() override {
if (!file)
return traits\_type::eof();
if (gptr() < egptr()) //если буфер не пуст, вернем текущий символ
return \*gptr();
char\_type \*start = eback();
//читаем не больше символов, чем вмещает буфер
size\_t rd = fread(start, sizeof(char\_type), buffer.size(), file);
//указываем размер буфера не больше, чем было считано символов
setg(start, start, start + rd);
return rd > 0 ? \*gptr() : traits\_type::eof();
}
public:
cfilebuf(size\_t \_bufsize)
: buffer(\_bufsize), file(nullptr)
{
char\_type \*start = buffer.data();
char\_type \*end = start + buffer.size();
setg(start, end, end); //устанавливаем eback = start, gptr = end, egptr = end
//т.к. gptr == egptr, буфер по факту пуст и будет заполнен при первой попытке чтения
}
~cfilebuf(){
close();
}
bool open(string fn){
close();
file = fopen(fn.c\_str(), "r");
return file != nullptr;
}
void close(){
if (file){
fclose(file);
file = nullptr;
}
}
};
int main(int argc, char \*\*argv){
cfilebuf buf(10);
istream in(&buf);
string line;
buf.open("file.txt");
while (getline(in, line)){
cout << line << endl;
}
return 0;
}
```
Так как пример простой, он обладает рядом недостатков, основные из которых мы разберем далее.
Расширенные возможности
=======================
Несмотря на то, что получившиеся в предыдущих разделах потоки уже можно использовать, их реализация является неполной. На практике могут возникнуть более сложные ситуации, требующие дополнительного функционала, про который и будет рассказано далее.
seekoff и seekpos для перемещения по файлу
------------------------------------------
При работе с файлом может потребоваться перемещение позиции в файле в произвольное место. Как вы уже догадались, в примере выше это не реализовано: файл читается только в одном направлении, назад вернуться нельзя, только переоткрывать файл. Чтобы исправить этот существенный недостаток, нам потребуется переопределить следующие методы класса `streambuf`:
* **streampos seekpos(streampos sp, openmode which)** — вызывается при попытке перемещения в позицию, заданную абсоолютной величиной, т.е. позицией от начала последовательности.
Возвращаемое значение: в случае успеха, новая установленная позиция, иначе -1.
Поведение по-умолчанию: ничего не делает и возвращает -1.
* **streampos seekoff(streamoff off, seekdir way, openmode which)** — вызывается при попытке перемещения в позицию, заданную относительно некоторой точки отсчета, которая задается аргументом `way`.
Возвращаемое значение: в случае успеха, новая установленная **абсолютная** позиция, иначе -1.
Поведение по-умолчанию: ничего не делает и возвращает -1.
В функциях, помимо первого аргумента (позиции или смещения), присутствуют еще два:
* **openmode** — тип указателя, который необходимо передвинуть: `ios_base::in` (позиция чтения) и `ios_base::out` (позиция записи). Заметьте что аргумент является битовой маской: т.е. может содержать как одно из значений, так и сразу **оба**.
* **seekdir** — применяется при относительном сдвиге и указывает точку отсчета для перемещения указателя. Может принимать одно из трех значений: `ios_base::beg` (от начала потока), `ios_base::cur` (от текущей позиции) или `ios_base::end` (от конца потока).
Теперь, вооружившись этим знанием, представим, как может выглядеть реализация перемещения по файлу в примере 3:
```
virtual streampos seekpos(streampos sp, ios_base::openmode which) override {
if (!(which & ios_base::in))
return streampos(-1);
return fill_buffer_from(sp);
}
virtual streampos seekoff(streamoff off, ios_base::seekdir way, ios_base::openmode which) override {
if (!(which & ios_base::in))
return streampos(-1);
switch (way){
default:
case ios_base::beg: return fill_buffer_from(off, SEEK_SET);
case ios_base::cur: return fill_buffer_from(pos_base + gptr() - eback() + off, SEEK_SET); //учитываем позицию от начала в нашем буфере
case ios_base::end: return fill_buffer_from(off, SEEK_END);
}
}
```
Пояснение: в поле `pos_base` хранится смещение в файле, с которого данные были загружены в буфер.
Выглядит довольно просто, но на самом деле всю сложность на себя берет функция `fill_buffer_from`. Ее реализация следующая:
```
streampos fill_buffer_from(streampos newpos, int dir = SEEK_SET){
if (!file || fseek(file, newpos, dir) == -1)
return -1;
long pos = ftell(file);
if (pos < 0)
return -1;
pos_base = pos;
char_type *start = eback();
size_t rd = fread(start, sizeof(char_type), buffer.size(), file);
setg(start, start, start + rd);
return rd > 0 && pos_base >= 0 ? pos_base : streampos(-1);
}
```
Функция пытается переместить указатель в файле на заданную позицию и заполнить весь наш буфер от начала до конца. Не очень производительно при любой операции заново заполнять буфер из файла, но в примере это сделано для упрощения реализации. Когда вы будете реализовывать вашего собственного наследника streambuf, вам наверняка будут известны тонкости работы с вашими данными, чтобы написать максимально эффективные функции позиционирования указателей.
Ну а мы идем далее.
pbackfail — возврат прочитанных символов назад
----------------------------------------------
Бывают алгоритмы, которые не требуют свободного перемещения в произвольное место потока, однако в процессе чтения и обработки они могут попросить вернуть несколько символов (обычно 1-3) назад в поток. Для этого у `istream` предусмотрены методы `unget()` и `putback(character)`. В классе `streambuf` при совпадении возвращенного в поток символа с предыдущим в буфере никаких дополнительных вызовов не происходит. Однако если символы не совпали или указатель буфера в самом его начале, то вызывается функция, позволяющая обработать эту ситуацию:
* **int pbackfail(int c)** — вызывается при несовпадении возвращаемого в поток символа `c` и символа, находящегося в буфере на предыдущей позиции (или она не существует).
Возвращаемое значение: код возвращенного в поток символа, приведенный к типу int, в случае неудачи — EOF.
Поведение по-умолчанию: ничего не делает и возвращает EOF.
Теперь реализуем наш `pbackfail`:
```
virtual int pbackfail(int c) override {
//символ не совпал
if (pos_base <= 0 || gptr() > eback())
return traits_type::eof();
//загружаем в буфер данные, начиная с предыдущего символа
if (fill_buffer_from(pos_base - 1L) == -1)
return traits_type::eof();
if (*gptr() != c){
gbump(1);
return traits_type::eof();
}
return *gptr();
}
```
Как я говорил ранее, в этом примере производительность будет ужасная, т.к. практически при каждом вызове `pbackfail` данные будут заново читаться из файла в буфер ради всего одного символа — предыдущего. Но целю этой статьи является понимание принципа работы, а не соревнование в производительности реализаций.
Пример 4 — чтение файла с позиционированием и возвратом символов
----------------------------------------------------------------
Здесь просто представлен код, в котором добавлены правки, реализованные в предыдущих разделах, а также примеры использования этого функционала, с пояснениями:
**Код**
```
#include
#include
#include
#include
#include
using namespace std;
class cfilebuf : public streambuf {
private:
vector buffer;
FILE \*file;
streampos pos\_base; //позиция в файле для eback
streampos fill\_buffer\_from(streampos newpos, int dir = SEEK\_SET) {
if (!file || fseek(file, newpos, dir) == -1)
return -1;
//запоминаем текущую позицию в файле для eback
long pos = ftell(file);
if (pos < 0)
return -1;
pos\_base = pos;
char\_type \*start = eback();
//читаем не больше символов, чем вмещает буфер
size\_t rd = fread(start, sizeof(char\_type), buffer.size(), file);
//указываем размер буфера не больше, чем было считано символов
setg(start, start, start + rd);
return rd > 0 && pos\_base >= 0 ? pos\_base : streampos(-1);
}
protected:
virtual int underflow() override {
if (!file)
return traits\_type::eof();
if (gptr() < egptr()) //если буфер не пуст, вернем текущий символ
return \*gptr();
streampos pos;
if (pos\_base < 0) { //если буфер еще не заполнялся, заполняем с начала
pos = fill\_buffer\_from(0);
}
else { //иначе заполняем со следующего несчитанного символа
pos = fill\_buffer\_from(pos\_base + egptr() - eback());
}
return pos != streampos(-1) ? \*gptr() : traits\_type::eof();
}
//второй аргумент в нашем случае всегда содержит ios\_base::in
//однако в общем случае может содержать и ios\_base::out и даже сразу оба (побитовое ИЛИ)
virtual streampos seekpos(streampos sp, ios\_base::openmode which) override {
if (!(which & ios\_base::in))
return streampos(-1);
return fill\_buffer\_from(sp);
}
//обработка трех вариантов позиционирования: с начала, с текущей позиции и с конца
virtual streampos seekoff(streamoff off, ios\_base::seekdir way, ios\_base::openmode which) override {
if (!(which & ios\_base::in))
return streampos(-1);
switch (way) {
default:
case ios\_base::beg: return fill\_buffer\_from(off, SEEK\_SET);
case ios\_base::cur: return fill\_buffer\_from(pos\_base + gptr() - eback() + off); //учитываем позицию от начала в нашем буфере
case ios\_base::end: return fill\_buffer\_from(off, SEEK\_END);
}
}
virtual int pbackfail(int c) override {
//когда gptr > eback, значит в буфере есть символ на нужной позиции,
//но он не совпал с переданным, запрещаем
if (pos\_base <= 0 || gptr() > eback())
return traits\_type::eof();
//загружаем в буфер данные, начиная с предыдущего символа
if (fill\_buffer\_from(pos\_base - streampos(1L)) == streampos(-1))
return traits\_type::eof();
if (\*gptr() != c) {
gbump(1); //возвращаемся назад, неудачная операция
return traits\_type::eof();
}
return \*gptr();
}
public:
cfilebuf(size\_t \_bufsize)
: buffer(\_bufsize), file(nullptr), pos\_base(-1)
{
char\_type \*start = buffer.data();
char\_type \*end = start + buffer.size();
setg(start, end, end); //устанавливаем eback = start, gptr = end, egptr = end
}
~cfilebuf() {
close();
}
bool open(string fn) {
close();
file = fopen(fn.c\_str(), "r");
return file != nullptr;
}
void close() {
if (file) {
fclose(file);
file = nullptr;
}
}
};
void read\_to\_end(istream ∈) {
string line;
while (getline(in, line)) {
cout << line << endl;
}
}
int main(int argc, char \*\*argv) {
cfilebuf buf(10);
istream in(&buf);
buf.open("file.txt");
read\_to\_end(in);
in.clear(); //очистить невалидное состояние после конца файла
cout << endl << endl << "Read last 6 symbols:" << endl;
in.seekg(-5, ios\_base::end); //передвинем позицию так, чтобы можно было считать 5 последних символов
in.seekg(-1, ios\_base::cur); //а лучше 6, чтобы слово целиком влезло :)
read\_to\_end(in);
in.clear();
cout << endl << endl << "Read all again:" << endl;
in.seekg(0);
read\_to\_end(in);
in.clear();
in.seekg(2); //заставляем наш буфер начинаться с 3-го символа в файле (чтобы в буфере не было первых 2-ух)
in.get();
in.putback('b');
in.putback('a'); //без pbackfail() этот код не сработал бы и привел бы поток в невалидное состояние
in.putback('H');
string word;
in >> word;
cout << endl << endl << "Read word after putback(): " << word << endl;
return 0;
}
```
Другие возможности
------------------
Помимо возможностей, рассмотренных в статье, есть и другие. Некоторые довольно просто реализуются, другие нужны лишь в специфических случаях, поэтому подробно они не рассматриваются. Далее приведен перечень таких функций и краткое описание, зачем они нужны. Более подробное описание о них вы можете найти в официальной документации (ссылка есть в конце статьи).
Другие доступные для переопределения методы:
* **imbue()** — переопределение этой функции позволяет работать с различными локалями для преобразования читаемых и записываемых символов.
* **setbuf()** — позволяет использовать пользовательский буфер, вместо встроенного. По-умолчанию эта функция ничего не делает, но вы можете добавить в своей реализации такую возможность.
* **showmanyc()** — позволяет сообщить использующей функции, сколько символов еще можно прочесть из потока до блокировки. По-умолчанию возвращает 0 (т.е. нет информации о количестве символов).
* **xsgetn() и xsputn()** — пара методов для чтения/записи цельных блоков данных, по функциональности схожи с `fread` и `fwrite`. Если вдруг для блочного чтения или записи в вашем случае можно реализовать более эффективный алгоритм, чем посимвольная обработка, то эти методы для вас.
Также в ваших проектах может возникнуть ситуация, когда размер одного символа больше 1 байта. В этом случае следует наследоваться от шаблонного класса `basic_streambuf` и использовать нужный вам тип символа. В реализации вам помогут такие алиасы типов, как `char_type`, `int_type`, `pos_type` и т.д. Использовать их предпочтительнее, так как они всегда соответствуют тем типам, с которыми работает библиотечная реализация `streambuf`.
Заключение
==========
Стандартная библиотека предлагает большой объем функций для гибкой и производительной реализации ваших собственных потоков. Однако помните, что реальная производительность всегда зависит именно от вашей реализации переопределенных методов для вашего конкретного случая.
Ссылки
------
* <https://github.com/iassasin/streambuf_examples> — все примеры из статьи на гитхабе;
* <http://www.cplusplus.com/reference/streambuf/streambuf/> — официальная документация по streambuf;
* <http://www.mr-edd.co.uk/blog/beginners_guide_streambuf> — англоязычная статья, из которой были позаимствованны иллюстрации и идеи для некоторых примеров. | https://habr.com/ru/post/326578/ | null | ru | null |
# Трансляция запросов в SQL с использованием LinqToSql в тестах
Мы уже несколько лет делаем наш продукт автоматизации маркетинга, и пилить фичи с высокой скоростью нам помогает CI, а точнее — большое количество автоматических тестов.
В продукте примерно 700 000 строк кода со всеми кастомизациями, и на это всё мы имеем около 7 000 тестов, и их количество постоянно растёт. За счет них мы не боимся совершать большие рефакторинги, затрагивающие многие части системы. Но, к сожалению, тесты не панацея. Каких-то тестов может не быть, какие-то тесты могут оказаться слишком дорогими, а какие-то ситуации не воспроизводятся в тестовой среде.
Практически каждая транзакция в нашей системе связана с работой с MS SQL с использованием LinqToSql. Да, технология старенькая, но мигрировать с неё нам довольно сложно, и по бизнесу она нас вполне устраивает. Более того, как я уже [писал раньше](https://habrahabr.ru/company/mindbox/blog/253779/), у нас даже есть [свой форк LinqToSql](https://www.nuget.org/packages/Mindbox.Data.Linq), где мы чуть-чуть чиним его баги и добавляем кое-какой функциональности.
Для того, чтобы делать запросы к БД, используя LinqToSql, нужно использовать интерфейс IQueryable. В момент получения Enumerator’а или выполнения Execute у QueryProvider’а построенное дерево выражений с помощью Extension-методов к IQueryable транслируется в SQL, который и выполняется на SQL Server.
Так как наша бизнес-логика сильно завязана на сущностях в базе данных, наши тесты много работают с базой данных. Однако в 95% тестов мы не используем реальную базу, так как это очень дорого по времени, а довольствуемся InMemoryDatabase. Она является частью нашей тестовой инфраструктуры, о которой можно написать отдельную статью, и на самом деле представляет из себя просто Dictionary для каждого существующего типа сущности. В тестах наш UnitOfWork прозрачно работает с такой базой, давая доступ к EnumerableQueryable, который просто получить из любого IEnumerable, вызвав у него AsQueryable().
Покажу пример теста для понимания происходящего:
```
[TestMethod]
public void ФильтрПоСегментуНеВозвращаетТехУКогоНеБылоСегментов()
{
var customer = new CustomerTestDataBuilder(TestDatabase).Build();
using (var modelContext = CreateModelContext())
{
var filter = new SegmentFilter(null, modelContext)
{
Segmentation = Controller.PeriodicalSegmentation,
Segment = FilterValueWithPresence.Concrete(Controller.PeriodicalSegment1)
};
var result = modelContext.Repositories.Get().GetFiltered(filter).ToList();
Assert.IsFalse(result.Contains(customer));
}
}
```
В тесте мы создаем modelContext — наш UnitOfWork, обёртка над DataContext со всякими плюшками, и потом пользуемся им, чтобы добраться до репозитория и пофильтровать какие-то сегменты. Разумеется, репозиторий ни о каких тестах не знает, просто ModelContext работает с InMemoryDatabase. Метод GetFiltered(filter) формирует некий IQueryable, а потом мы его материализуем.
С таким подходом есть проблема: мы никак не тестируем, что тот IQueryable, который мы получили из GetFiltered, транслируется в SQL. В итоге можем получить баг на продакшене примерно такого содержания:
> [NotSupportedException: Method 'Boolean DoesCurrentUserHaveSmsPermissionOnProject(Int32)' has no supported translation to SQL.]
>
> at System.Data.Linq.SqlClient.PostBindDotNetConverter.Visitor.VisitMethodCall(SqlMethodCall mc)
>
> at System.Data.Linq.SqlClient.SqlVisitor.Visit(SqlNode node)
>
> at System.Data.Linq.SqlClient.SqlVisitor.VisitExpression(SqlExpression exp)
>
> at System.Data.Linq.SqlClient.SqlVisitor.VisitSelectCore(SqlSelect select)
>
> at System.Data.Linq.SqlClient.PostBindDotNetConverter.Visitor.VisitSelect(SqlSelect select)
>
> …
>
>
Как сделать так, чтобы такие баги не попадали на продакшен? Можно писать тесты с реальной базой, и у нас такие есть. Они несильно отличаются от тех, что работают с InMemoryDatabase, тестовый класс просто имеет другого родителя. Вот пример:
```
[TestMethod]
public void ЗакрытиеАктивнойСессииИСозданиеНовойВОднойТранзакции()
{
Controller.CurrentDateTimeUtc = new DateTime(2016, 11, 1, 0, 0, 0, DateTimeKind.Utc);
var sessionStartDateTime = Controller.CurrentDateTimeUtc.Value.AddHours(-1);
using (var modelContext = CreateModelContext())
{
var customer = new CustomerTestDataBuilder(modelContext).Build();
var activeSession = new CustomerSessionTestDataBuilder(modelContext)
.WithLastCustomer(customer)
.Active()
.WithStartDateTimeUtc(sessionStartDateTime)
.Build();
modelContext.SubmitTestData();
var newSession = new CustomerSession
{
PointOfContact = activeSession.PointOfContact,
DeviceGuid = activeSession.DeviceGuid,
IpAddress = activeSession.IpAddress,
ScreenResolution = activeSession.IpAddress,
IsAuthenticated = false
};
newSession.SetStartDateTimeUtc(modelContext, Controller.CurrentDateTimeUtc.Value, customer);
newSession.SetUserAgent(activeSession.UserAgent.UserAgentString, modelContext);
newSession.SetLastCustomer(modelContext, customer, copyWebSiteVisitActions: false);
modelContext.Repositories.Get().Add(newSession);
modelContext.SubmitChanges();
Assert.IsNull(activeSession.IsActiveOrNull);
Assert.IsNotNull(newSession.IsActiveOrNull);
}
}
```
В этом тесте всё происходит в реальной базе с последующим откатом Snapshot транзакции, и подобных ошибок пролезть не может. Но, разумеется, таких тестов у нас не очень много, всего около сотни. Число ни в какое сравнение не идёт с 7 000. И они стоят по времени заметно дороже, чем обычные.
Решение напрашивалось само: написать свою реализацию IQueryable и соответственно IQueryProvider, декорирующих EnumberableQueryble и System.Data.Linq.DataQuery. Такая реализация должна, при попытке получить результат запроса с помощью получение энумератора, или же с помощью вызова методов, приводящих к немедленному выполнению запроса, таких как Any, Count, Single, и т.д., сначала проверять, можно ли транслировать такой запрос в SQL, и если можно, просто выполнять его над обычными коллекциями.
Теперь я расскажу, как именно это реализовано, и начну с теста, что такая трансляция вообще работает:
```
[TestMethod]
public void ПолучениеВсехСущностейИзТаблицы()
{
var testEntity1 = new SomeTestEntityTestDataBuilder(TestDatabase).Build();
var testEntity2 = new SomeTestEntityTestDataBuilder(TestDatabase).Build();
using (var modelContext = CreateModelContext())
{
var query = modelContext.Repositories.Get().Items.Select(e => e.Id);
var sqlQuery = query.ToString();
var expectedQuery =
$"SELECT [t0].[{nameof(SomeTestEntity.Id)}]\r\n" +
$"FROM [{SomeTestEntity.TableName}] AS [t0]";
Assert.AreEqual(expectedQuery, sqlQuery);
var entities = query.ToList();
Assert.AreEqual(2, entities.Count);
Assert.IsTrue(entities.Contains(testEntity1.Id));
Assert.IsTrue(entities.Contains(testEntity2.Id));
}
}
```
Этот и ещё несколько тестов были написаны для проверки того, что трансляция в SQL действительно происходит и работает корректно. Вот ещё несколько примеров:
**Парочка тестов под спойлером**
```
[TestMethod]
public void ЗапросСИспользованиемДвухСущностейСИспользованиемEntityRefиInheritanceMapping()
{
SomeAbstractTestEntity testEntity1 = new SomeTestEntityChildTestDataBuilder(TestDatabase).WithId(1).Build();
var testEntity2 = new SomeTestEntityTestDataBuilder(TestDatabase).WithId(2).Build();
var anotherTestEntity1 = new AnotherTestEntityTestDataBuilder(TestDatabase).WithLinkedEntity(testEntity1).Build();
var anotherTestEntity2 = new AnotherTestEntityTestDataBuilder(TestDatabase).WithId(3).Build();
using (var modelContext = CreateModelContext())
{
var query = modelContext.Repositories.Get()
.Items
.Where(a => a.SomeTestEntity == testEntity1)
.Select(a => a.Id);
var entities = query.ToList();
Assert.AreEqual(1, entities.Count);
Assert.IsTrue(entities.Contains(anotherTestEntity1.Id));
var sqlQuery = query.ToString();
var expectedQuery =
$"SELECT [t0].[{nameof(AnotherTestEntity.Id)}]\r\n" +
$"FROM [{AnotherTestEntity.TableName}] AS [t0]\r\n" +
$"WHERE [t0].[{nameof(AnotherTestEntity.SomeTestEntityId)}] = @p0";
Assert.AreEqual(expectedQuery, sqlQuery);
}
}
```
```
[TestMethod]
public void ЗапросНеТранслируетсяВSQL()
{
using (var modelContext = CreateModelContext())
{
var query = modelContext.Repositories.Get().Items.Where(e => e.ToString() == "asdf");
AssertException.Throws(
() => query.ToList(),
"ToStringOnlySupportedForPrimitiveTypes");
}
}
```
Как вы видите в последнем примере, при попытке проэнумерироваться по IQueryable, который не имеет трансляции в SQL, в тесте возникает exception.
Теперь перейдём непосредственно к реализации. Нас интересуют запросы, которые происходят внутри модели, то есть фактически нам интересны любые обращения к репозиториям. Репозиторий для каждой сущности обладает некоторым набором бизнес методов и даёт доступ к IQueryable через свойство Items, который является просто DataTable. Посмотрим на пример использования свойства Items.
Базовый класс для всех репозиториев:
```
public abstract class Repository : Repository
{
private ITable table;
public IQueryable Items
{
get { return table; }
}
}
```
Пример использования Items внутри репозитория
```
public class CustomerRepository : ChangeRestrictedRepository
{
public List GetCustomersByEmail(string email)
{
if (String.IsNullOrEmpty(email))
throw new ArgumentException("Email не указан.", nameof(email));
return Items.Where(user => user.Email == email).ToList();
}
}
```
Пример использования вне репозитория:
```
FmcgPurchase = Add(ReverseSingleLinkedItemFilter.GetFactory(
"fmcgpurchase",
modelContext => customerAction => modelContext
.Repositories
.Get()
.Items
.Where(fmcgPurchase => fmcgPurchase.CustomerAction == customerAction),
canLinkedItemBeAbsent: true));
```
Выходит, нужно добиться, чтобы Repository.Items возвращал наш хитрый IQueryable. Ну и написать наш хитрый IQueryable :)
Как уже было видно выше, Repository.Items фактически возвращает ITable, а сам table инициализируется при создании UnitOfWork:
```
public override void SetRepositoryRegistry(RepositoryRegistry repositories)
{
table = repositories.DatabaseContext.GetTable();
}
```
Метод DatabaseContext.GetTable() абстрактный. У DatabaseContext есть 2 наследника: LinqDatabaseContext и InMemoryDatabaseContext. В LinqDatabaseContext, который используется при работе с реальной базой, всё просто: GetTable возвращает System.Data.Linq.Table. В InMemoryDatabase код написан такой:
```
protected internal override ITable GetTable()
{
if (!tables.ContainsKey(typeof(T)))
tables.Add(
typeof(T),
new StubTableImpl(
this,
(InMemoryTable)database.GetTable(),
linqToSqlTranslateHelperContext));
return (ITable)tables[typeof(T)];
}
```
Тут немного магии с кэшом и пока не очень понятный linqToSqlTranslateHelperContext, но уже видно, что требуемый нам IQueryable, который нам нужно подменять — это StubTableImpl, а так же используется вызов database.GetTable().
Начнём с database.GetTable(). Тут смысл в том, что StubTable создаётся, когда мы обращаемся при уже созданном UnitOfWork к каким-то репозиториям. Но в тесте может существовать множество UnitOfWork, и все они должны работать с одной базой. Database — и есть эта база, а StubTable — это просто способ получения доступа к этой базе.
Теперь посмотрим внимательнее на класс StubTableImpl:
```
public class StubTableImpl : ITable, IStubTable
where T : class
{
internal StubTableImpl(
InMemoryDatabaseContext databaseContext,
InMemoryTable inMemoryTable,
DataContext linqToSqlTranslateHelperContext)
{
InnerTable = inMemoryTable;
innerQueryable = new StubTableQueryable(
databaseContext,
linqToSqlTranslateHelperContext.GetTable());
}
public Type ElementType
{
get { return innerQueryable.ElementType; }
}
public Expression Expression
{
get { return innerQueryable.Expression; }
}
public IQueryProvider Provider
{
get { return innerQueryable.Provider; }
}
Type IStubTable.EntityType
{
get { return typeof(T); }
}
public override string ToString()
{
return innerQueryable.Select(e => e).ToString();
}
IEnumerable IStubTable.Items
{
get { return InnerTable; }
}
}
```
StubTableImpl реализует IQueryable и IQueryProvider, делегируя всю реализацию StubTableQueryable innerQueryable. Сам StubTableQueryable выглядит так:
```
internal class StubTableQueryable : IOrderedQueryable
{
private readonly InMemoryDatabaseContext inMemoryContext;
private readonly IQueryable dataContextQueryable;
private readonly StubTableQueryProvider stubTableQueryProvider;
public StubTableQueryable(
InMemoryDatabaseContext inMemoryContext,
IQueryable dataContextQueryable)
{
this.inMemoryContext = inMemoryContext;
this.dataContextQueryable = dataContextQueryable;
stubTableQueryProvider = new StubTableQueryProvider(inMemoryContext, dataContextQueryable);
}
public IEnumerator GetEnumerator()
{
inMemoryContext.CheckConvertionToSql(Expression);
IEnumerable enumerable =
new EnumerableQuery(inMemoryContext.ConvertDataContextExpressionToInMemory(Expression));
return enumerable.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public Expression Expression { get { return dataContextQueryable.Expression; } }
public Type ElementType { get { return dataContextQueryable.ElementType; } }
public IQueryProvider Provider { get { return stubTableQueryProvider; } }
public override string ToString()
{
return inMemoryContext.GetQueryText(Expression);
}
}
```
Приведу сразу код StubTableQueryProvider, потому что они очень связаны между собой (теперь даже кажется, что возможно было бы разумным, чтобы это был один класс):
```
internal class StubTableQueryProvider : IQueryProvider
{
private static readonly IQueryProvider enumerableQueryProvider = Array.Empty().AsQueryable().Provider;
private readonly InMemoryDatabaseContext inMemoryContext;
private readonly IQueryable dataContextQueryable;
public StubTableQueryProvider(
InMemoryDatabaseContext inMemoryContext,
IQueryable dataContextQueryable)
{
this.inMemoryContext = inMemoryContext;
this.dataContextQueryable = dataContextQueryable;
}
public IQueryable CreateQuery(Expression expression)
{
return new StubTableQueryable(
inMemoryContext,
dataContextQueryable.Provider.CreateQuery(expression));
}
public object Execute(Expression expression)
{
inMemoryContext.CheckConvertionToSql(expression);
return enumerableQueryProvider.Execute(inMemoryContext.ConvertDataContextExpressionToInMemory(expression));
}
public TResult Execute(Expression expression)
{
inMemoryContext.CheckConvertionToSql(expression);
return enumerableQueryProvider.Execute(inMemoryContext.ConvertDataContextExpressionToInMemory(expression));
}
}
```
Тут необходимо пояснить, как вообще работает построение деревьев выражений с использованием методов расширения на IQueryable в System.Linq.
Сами эти методы определены в статическом классе Queryable. Вот кусочек этого класса для понимания происходящего:
```
public static class Queryable
{
public static IQueryable Where(this IQueryable source, Expression> predicate)
{
return source.Provider.CreateQuery(
Expression.Call(
null,
GetMethodInfo(Queryable.Where, source, predicate),
new Expression[] { source.Expression, Expression.Quote(predicate) }
));
}
public static int Count(this IQueryable source)
{
return source.Provider.Execute(
Expression.Call(
null,
GetMethodInfo(Queryable.Count, source),
new Expression[] { source.Expression }
));
}
}
```
Я привел тут примеры реализации двух методов: Where и Count. Мой выбор пал на них, потому что они показывают разные способы взаимодействия интерфейсов IQueryable и IQueryProvider.
Посмотрим сначала на реализацию метода Where. Этот метод принимает IQueryable и условие фильтрации, и возвращает IQueryable. При этом вы можете легко заметить, что этот метод ничего не фильтрует. Всё, что он делает — это создаёт дерево выражений: вытаскивает дерево выражений из входящего IQueryable, добавляет к нему вызов метода Where, то есть себя же, с параметром условия фильтрации. После этого полученное новое дерево выражений передаётся в IQueryProvider.CreateQuery, который нужен как раз для того, чтобы оборачивать Expression в IQueryable.
Попробуем разобрать на примере. Допустим, у нас такой код:
Customers.Where(c => c.Sex == Sex.Male)
При этом Customers — Table. Тогда в метод Where будет передан IQueryable, в котором будет Expression — Table. После этого Where добавит себя же в конец этого Expression’а с условием, которое мы передали. Получится Table.Where(c => c.Sex == Sex.Male). Далее этот Expression оборачивается обратно в IQueryable и возвращается из метода. Тут не происходит никаких обращений к БД, просто вызов чистой функции.
Теперь посмотрим на метод Count. Он вычисляет количество элементов в запрашиваемой коллекции сразу при обращении к нему. Это происходит посредством вызова метода IQueryProvider.Execute. Этот метод принимает Expression, на основании которого он должен построить запрос, и возвращает результат этого запроса — количество. Построение Expression’а тут аналогично методу Where: берется исходный IQueryable, из него получается Expression и достраивается Count’ом. Таким образом IQueryProvider.Execute должен обойти этот Expression, понять, что от него требуется и сделать соответствующий запрос к бд.
Теперь, вооружившись новыми знаниями, вернёмся к StubTableQueryable и StubTableQueryProvider. Сейчас мы примерно понимаем, чего мы от них хотим: при вызове методов StubTableQueryable.GetEnumerator и StubTableQueryProvider.Execute мы должны взять наш Expression или IQueryable, попытаться транслировать его в SQL, используя какой-нибудь DataContext, а затем получить данные просто из памяти. Для этого в StubTableQueryProvider.Execute и StubTableQueryable.GetEnumerator написан похожий код, который сначала вызывает CheckConvertionToSql, а затем с помощью ConvertDataContextExpressionToInMemory преобразует исходный Expression и либо выполняет его с помощь EnumerableQueryble, либо вызывает Enumerator у EnumerableQueryble с преобразованным Expression’ом.
Начнём с того, как выполняется проверка, что запрос действительно транслируется в SQL. Метод CheckConversionToSql пытается получить текст запроса по его Expression’у, для чего использует DataContext.GetCommand. Небольшая проблема заключается в том, что GetCommand принимает IQueryable, а мы имеем Expression, но это не беда, на самом деле ему нужен только Expression :)
В итоге код, проверяющий, что запрос транслируется в SQL, выглядит так:
```
public string GetQueryText(Expression expression)
{
return queryExpressionToQueryText.GetOrAdd(
expression.ToString(),
expressionText =>
{
var fakeQueryable = new FakeQueryable(expression);
var result = linqToSqlTranslateHelperContext.GetCommand(fakeQueryable);
return result.CommandText;
});
}
```
Класс FakeQueryable нужен просто как адаптер, вот его реализация:
```
public class FakeQueryable : IQueryable
{
public FakeQueryable(Expression expression)
{
Expression = expression;
}
public IEnumerator GetEnumerator()
{
throw new NotSupportedException();
}
public Expression Expression { get; }
public Type ElementType { get { throw new NotSupportedException(); } }
public IQueryProvider Provider { get { throw new NotSupportedException(); } }
}
```
Правильнее было бы всё-таки поправить Mindbox.Data.Linq так, чтобы существовала перегрузка GetCommand(Expression), но пока этого сделано не было.
Используемый выше linqToSqlTranslateHelperContext — это инстанс DataContext’а, который используется не только для вызова на нём GetCommand, но и для получения из него Table, связанных с базой данных. Изначальный запрос строится относительно этих Table. Если мы попробуем реально выполнить такой запрос, мы получим исключение о том, что соединение для этого DataContext’а отсутствует, ведь Connection не нужен для того, чтобы транслировать запросы, но нужен, чтобы их выполнять.
Однако получать данные из этого Expression’а нам всё-таки нужно. Для этого его приходится немного преобразовывать, для чего и используется ConvertDataContextExpressionToInMemory.
Обычно, чтобы что-то делать с Expression’ами, нужно наследоваться от ExpressionVisitor, где для каждого типа выражения есть метод, который можно переопределить, и писать там свою логику. Для замены LinqToSql-таблиц на таблицы InMemoryDatabase в Expression’ах мы так и поступили. Вот этот Visitor:
```
public class ConstantObjectReplaceExpressionVisitor : ExpressionVisitor
where T : class
{
private readonly Dictionary replacementDictionary;
public ConstantObjectReplaceExpressionVisitor(Dictionary replacementDictionary)
{
this.replacementDictionary = replacementDictionary;
}
protected override Expression VisitConstant(ConstantExpression node)
{
var value = node.Value as T;
if (value == null)
return base.VisitConstant(node);
if (!replacementDictionary.ContainsKey(value))
return base.VisitConstant(node);
return Expression.Constant(replacementDictionary[value]);
}
public Expression ReplaceConstants(Expression sourceExpression)
{
return Visit(sourceExpression);
}
}
```
Смысл этого Visitor’а — заменить одну константу на другую. Что на что заменять передаётся в конструкторе. Вся логика написана в VisitConstant и довольно прямолинейна.
Посмотрим на создание экземпляра этого Visitor’а:
```
private ConstantObjectReplaceExpressionVisitor CreateTableReplaceVisitor(DataContext dataContext)
{
var dataContextTableToInMemoryTableMap = new Dictionary();
var entityTypes = ModelApplicationHostController.Instance
.ModelConfiguration
.DatabaseModel
.GetRepositoriesByEntity()
.Keys;
foreach (var entityType in entityTypes)
{
var dataContextTable = dataContextGetTableFunc(dataContext, entityType);
if (dataContextTable == null)
throw new InvalidOperationException($"Для типа {entityType} не удалось получить таблицу из DataContext'а");
var inMemoryContextTable = GetInMemoryTable(database, entityType);
if (inMemoryContextTable == null)
throw new InvalidOperationException($"Для типа {entityType} не удалось получить InMemory таблицу");
dataContextTableToInMemoryTableMap.Add(dataContextTable, inMemoryContextTable);
}
return new ConstantObjectReplaceExpressionVisitor(dataContextTableToInMemoryTableMap);
}
```
Тут мы проходимся по всем типам сущностей, которые зарегистрированы, и для каждого типа получаем Table из DataContext’а — это будет Key в конечном Dictionary, а так же InMemoryTable — это будет Value. В итоге, получившийся Visitor будет подменять все ContantExpression, Value которых присутствуют в ключах переданного в него словаря и соответствуют Table какой-то из наших сущностей, в InMemoryTable.
Может показаться, что с таким проходом будут проблемы с деревьями выражений, где мы используем не константное значение Table, а выражение, значением которого является Table. На этот случай написан вот такой тест:
```
[TestMethod]
public void ЗапросСИспользованиемДвухСущностей()
{
var testEntity1 = new SomeTestEntityTestDataBuilder(TestDatabase).WithId(1).Build();
var testEntity2 = new SomeTestEntityTestDataBuilder(TestDatabase).WithId(2).Build();
var anotherTestEntity1 = new AnotherTestEntityTestDataBuilder(TestDatabase).WithId(testEntity1.Id).Build();
var anotherTestEntity2 = new AnotherTestEntityTestDataBuilder(TestDatabase).WithId(3).Build();
using (var modelContext = CreateModelContext())
{
var query = modelContext.Repositories.Get().Items
.SelectMany(e => modelContext.Repositories.Get()
.Items
.Where(a => a.Id == e.Id))
.Select(a => a.Id);
var entities = query.ToList();
Assert.AreEqual(1, entities.Count);
Assert.IsTrue(entities.Contains(anotherTestEntity1.Id));
var sqlQuery = query.ToString();
var expectedQuery =
$"SELECT [t1].[{nameof(AnotherTestEntity.Id)}]\r\n" +
$"FROM [{SomeTestEntity.TableName}] AS [t0], [{AnotherTestEntity.TableName}] AS [t1]\r\n" +
$"WHERE [t1].[{nameof(AnotherTestEntity.Id)}] = [t0].[{nameof(SomeTestEntity.Id)}]";
Assert.AreEqual(expectedQuery, sqlQuery);
}
}
```
Тут modelContext.Repositories.Get().Items является частью дерева выражений, и не будет заменен нашим Visitor'ом. Почему же тогда такой тест проходит? Каким образом запрос верно транслируется и каким образом происходит энумерация?
Трансляция запроса в такой ситуации не должна вызывать удивления, ведь LinqToSql во время трансляции запроса обходит дерево выражений, выполняя в нём выражения, которые являются фактическими константами. Все вызовы методов C# будут вызваны до настоящей трансляции, если они не используются в контексте, требующем выполнения на SQL сервере. Именно поэтому в запросе можно написать modelContext.Repositories.Get().Items.Where(a => a.TestNumber == GetSomeTestNumber()), но нельзя написать modelContext.Repositories.Get().Items.Where(a => a.TestNumber == GetSomeTestNumber(a)). Потому что в первом случае результат GetSomeTestNumber() будет вычислен на этапе трансляции и подставлен в запрос, а во втором GetSomeTestNumber принимает аргументом сущность, по которой идёт запрос, то есть зависит от сущность, а значит должен быть тоже транслирован. В тесте modelContext.Repositories.Get().Items будет выполнен на этапе трансляции, а Items любого репозитория возвращает StubTableImpl, Expression которого — это Table. Для особо любознательных [даю ссылку на код](https://github.com/mindbox-moscow/data-linq/blob/master/Mindbox.Data.Linq/SqlClient/Query/QueryConverter.cs#L347), который делает то, что я описал выше.
Что же касается непосредственного выполнения запроса, то тут всё ещё проще. После замены первого и единственного Table в Expression'е исходного запроса он начинает выполняться как обычный Enumerable. И SelectMany просто выполняет свою часть выражения как делегат. В рамках этого выполнения мы попробуем транслировать вложенный запрос в SQL, что у нас, разумеется получится, заменим в нём Table на InMemoryTable и выполним точно так же.
Какие проблемы есть в этом решении? Основная проблема заключается в том, что всё ещё существуют ошибки в маппинге, которые не будут обнаружены таким образом. То, что запрос из IQueryable транслируется в SQL, ещё не значит, что фаза материализации, когда LinqToSql читает поток с данными и создаёт из них объекты, пройдёт успешно. Например, на этой фазе могут возникать ошибки, связанные с попытками записи Null-значний в свойства сущностей, которые не могут содержать Null. Нужно сказать, что мы попробовали тестировать и фазу материализации, но это пришлось откатить, так как нас не устроила производительность тестов в такой ситуации: она ухудшилась почти в 2 раза.
Тем не менее, наш код точно стал стабильнее, чему мы очень рады.
Вот и всё. С удовольствием отвечу на ваши вопросы :) | https://habr.com/ru/post/322604/ | null | ru | null |
# Быстрый старт на React Native
Какие горизонты открывает React? Single Page Application (и веб-приложения, и десктопные приложения на Electron) — это цветочки. Очень заманчиво выглядит разработка мобильных приложений на React Native. Лозунг "learn once, write anywhere" стоит того, чтобы приложить некоторые усилия. Go!
13 марта объявлено стабильным чудесное решение:
> Многие разработчики сталкиваются с проблемой установки и настройки существующих зависимостей React Native, особенно для Android. С помощью Create React Native App нет необходимости использовать XCode или Android Studio, и вы можете разрабатывать для своего iOS-устройства, используя Linux или Windows. Это достигается при помощи приложения Expo, которое загружает и запускает проекты CRNA, написанные на чистом JavaScript без компиляции любого собственного кода.
CRNA повторяет идею Create React App (CRA). Никакой настройки окружения — всё готово "из коробки": запуск тестов, запуск в режиме разработки, боевая сборка и деплой.
```
$ npm i -g create-react-native-app
$ create-react-native-app my-app
$ cd my-app
$ npm start
```
Как видно, нужно выполнить несколько условий: установить управляющую оболочку Expo на мобильник, запустить тестируемое приложение через QR-код, при этом мобильник должен находиться в одной локальной сети с вашим компом разработчика.
Можно ещё проще. Подключите мобильник USB-шнурком, и выполните:
```
$ npm run android
```
Оно само поставит оболочку Expo на мобильник и запустит тестируемое приложение. Дальше горячая перезагрузка работает почти так же быстро, как при разработке веб-приложения на CRA. Магия!
На Ubuntu/Windows оно доступно только для подключенных Android/iOS устройств; но на Mac-е работает и вовсе без мобильника — на симуляторе iOS:
```
$ npm run ios
```
Опционально можно установить на комп Expo XDE:
С помощью этого инструмента также можно запускать тестируемое приложение, при этом отображается лог с мобильного устройства — жирный плюс; но горячая перезагрузка работает медленно, видимо приложение пересобирается каждый раз полностью. **UPDATE** Нужно вызвать меню разработчика (буквально встряхнуть мобилку), и выбрать "Enable Hot Reloading". При этом выключите Live Reload — [оба варианта вместе не поддерживаются](https://docs.expo.io/versions/v16.0.0/guides/debugging.html#hot-reloading-and-live-reloading).
→ [Исходная заметка в блоге React Native](https://facebook.github.io/react-native/blog/2017/03/13/introducing-create-react-native-app.html)
**UPDATE** Mac не нужен для разработки iOS-версии; просто подключите iOS-устройство и наслаждайтесь процессом на Ubuntu/Windows (спасибо, [andreylat](https://habrahabr.ru/users/andreylat/)). | https://habr.com/ru/post/327668/ | null | ru | null |
# Scrolling в web slices или как впихать невпихуемое
 Одна из новых возможностей IE 8 — это web slices, фрагменты веб-страниц, которые можно просматривать браузером не открывая всю страницу целиком.
И все бы хорошо, вот только одна неприятная мелочь — в preview окне для web slice нет автоматической прокрутки (scrolling). Если один и тот же html просто открыть в браузере и он там не помещается — полоса прокрутки появится, если в preview окне для web slices — прокрутки нет.
Для некоторых web slices это не играет никакой роли. Например, для [лотов с eBuy](http://ie8.ebay.com/), которые так любят приводить в пример. Один лот можно комфортно разместить в окошке размером 320 x 240 (размер preview окна по умолчанию). Однако часто web slices представляют собой какие-нибудь списки — последние новости, анонсы, комментарии, да мало ли. Попробуйте открыть страницу [valuta.online.ua](http://valuta.online.ua/) и добавьте web slice с курсами валют. А теперь откройте его в preview окне. Что, тоже пробуете крутить колесико мышки чтобы просмотреть содержимое, как и я?
В принципе, пользователь может растянуть окно до какого-то предела. Но не факт, что все поместится даже в этом случае да и управлять размерами окна сами вы никак не сможете. А изначально оно открывается размером 320 x 240 и никак не подстраивается под размер отображаемого html.
Конечно, что-то можно сделать и в этом случае. Например, ограничить количество элементов списка (первые 5) и выводить не более 100 символов в каждом элементе. Но тогда web slice может потерять свое главное преимущество и вместо информации, которую можно быстро просмотреть, превращается в обычный баннер типа «Эй, посмотри, что у нас есть! Хочешь посмотреть — заходи на сайт!».
Так что можно попробовать добавить прокрутку самому. Это будет выглядеть примерно так:
`Заголовок web slice
<br/>
html { height: 100% }<br/>
body { padding: 0px; margin: 0px; height: 100% !important; overflow: hidden; }<br/>
#outer { overflow-x: hidden; overflow-y: auto; height: 100% }<br/>
#inner { padding: 10px; }<br/>`
В результате мы получим web slice, окруженный 10px отступами от краев preview окна. Если содержимое html не будет помещаться — появиться вертикальная прокрутка. Аттрибуты «overflow-x» и «overflow-y» уникальны для IE, но и сами web slices тоже уникальны для IE, так что проблему это не создаст.
Как будет выглядеть такая прокрутка можно посмотреть на примере [online результатов футбольных матчей](http://fannet.org/live).
Есть еще один момент, на который нужно обратить внимание. Так как мы должны отдавать специально сформированный html для preview окна, простейший способ создания web slices при помощи 2-3 аттрибутов нас не устроит. Мы будем использовать «alternative display source» — возможность указать url, возвращающий html для preview. Для этого:
Создаем страницу, которая будет формировать нужный нам html. Допустим, это будет /webslices.php (/webslices.aspx — для .NET-чиков и просто /webslices для SEO оптимизаторов :)
Добавляем к коду web slice указатель на этот html:
`Заголовок web slice`
Более длинное описание вы сможете найти в моем посте "[Web Slices для IE 8](http://developernotes.net/post/web-slices-ie-8-scrolling.aspx)". Ну и конечно никакая статья не заменит [документации по Web Slice](http://msdn.microsoft.com/en-us/library/cc956158(VS.85).aspx) в MSDN. Удачи вам в разработке! | https://habr.com/ru/post/55310/ | null | ru | null |
# 3 простых совета, которые сделают ваше Rails приложение быстрее, часть #3
Заключительная статья по оптимизация Ruby on Rails приложения.
[Совет #1: Приберите ваш статический контент](http://habrahabr.ru/blogs/ruby/50840/)
[Совет #2: Уберите все лишнее](http://habrahabr.ru/blogs/ruby/50946/)
[Совет #3: Кэшируйте всю страницу](http://habrahabr.ru/blogs/ruby/51042/)
**Совет #3: Кэшируйте всю страницу**
Этот, последний совет, является наиболее эффективным. Веб-сервер [кэширует страницу](http://api.rubyonrails.com/classes/ActionController/Caching/Pages.html) полностью, а затем отдает лишь статический контент. Что бы начать работать с caches\_page достаточно просто посмотреть замечательный [railscasts](http://railscasts.com/episodes/89-page-caching).
Необходимо помнить что после полного кэширования страницы, она будет отображаться одинаково для всех пользователей, не будет производиться не каких проверок или запросов к базе. Поэтому следует избавиться в странице от всех конструкций вида: `<%= ... if logged_in? %>`
Вы все ещё можете использовать JavaScript для того чтобы показывать или скрывать код для зарегистрированных пользователей. Вот небольшой пример:
`var CurrentUser = {
loggedIn: false,
author: false,
admin: false,
init: function() {
this.loggedIn = Cookie.get('token') != null;
this.admin = Cookie.get('admin') != null;
}
};
var Application = {
init: function() {
CurrentUser.init();
},
onBodyLoaded: function() {
if (CurrentUser.loggedIn) {
$$('.if_logged_in').invoke('show');
$$('.unless_logged_in').invoke('hide');
}
if (CurrentUser.admin) {
$$('.if_admin').invoke('show');
}
}
};`
Так же, вы больше не сможете полноценно использовать `<%= flash[:notice] %>`. Однако это не проблема, есть замечательный плагин [Cacheable Flash](http://pivotallabs.com/users/brian/blog/articles/276-cacheable-flash)
Ставим:
`ruby script/plugin install svn://rubyforge.org/var/svn/pivotalrb/cacheable_flash/trunk`
В ApplicationController пишем:
`include CacheableFlash`
В контроллере:
`flash[:notice] = "Welcome to Eternity" if current_user`
А в layout:
Теперь все flash сообщения будут записываться в Куки. Кстати для работы этого плагина необходимо поставить gem json, но в моей Ubuntu 8.10 с этим возникли проблемы, этот гем упорно не хотел вставать, как потом выяснилось подобная проблема не только у меня. ешил я эту проблему так, поставил `ruby-json`, и заменил в /vendor/plugins/cachable-flash/init.rb строчку `gem "json"` на `gem "ruby-json"`. И все заработало как часы.
Надеюсь эти советы вам помогли. | https://habr.com/ru/post/51042/ | null | ru | null |
# CPrompt — интерпретатор языка си
С июня 2009 года я занимаюсь разработкой интерпретатора Си. (я уже упоминал об этом [в статье о вызовах функций](http://habrahabr.ru/blogs/cpp/78886/)).
Сейчас уже реализовано достаточно много конструкций: циклы, выбор, вычисление выражений, вызовы функций (как объявленных пользователем, так и стандартных), инклуды и другое.
Название CPrompt программа получила по аналогии с «prompt» — приглашением командной строки (D:>, root@comp#, ...).
Немного о работе самого интерпретатора
======================================
Запуск на интерпретацию файла с исходным кодом делается просто:
$cprompt /path/to/file.c
Интерпретация разделена на 3 этапа:
1) Препроцессинг
2) Построение дерева выполнения
3) Вызов main()
Первый этап, препроцессинг, важный и скучный: обрабатывает инклуды, дефайны, комментарии и другое.
На выходе — чистый код, без директив и лишнего текста.
Второй этап — построение дерева выполнения. Тут берется код и строится граф (дерево), в корне которого лежит некий объект APPLICATION, который содержит информацию о запускаемом файле. В поддеревьях — функции, каждая лексема переходит в элемент дерева. Каждый элемент графа имеет свой «тип» — число, которое показывает его предназначение.
Функции делятся на 2 типа — объявленные пользователем и «внешние». Последние — например, стандартные из libc, из других разделяемых библиотек.
На выходе получается дерево, подобное этому:
…
Tree was built:
t0;APPLICATION;;;
| t0;FUNCTIONS;;;
| | t14;double;cos;;
| | t14;double;floor;;
| | t14;int;isdigit;;
…
| | t2;double;round;;
| | | t5;floor(value+0.5);;;
| | t14;int;printf;;
| | t2;int;main;;
| | | t1;int;l;round(7.2);
…
(это часть лога, который выводит интерпретатор).
t0, t2, t14 — тип элементов.
0 — без типа
1 — выражение (присвоение считается одной из операций, наравне с +,-,\*… но в другом приоритете).
2 — функция
5 — «return»
14 — «внешняя функция»,
И другие, для разных действий.
Аргументы к функциям хранятся в структурах, поэтому их нет в видимой части дерева. На самом деле указатели на них прописаны в в каждой ветке функции.
Все выполнение программы логируется очень подробно — при указании параметра --dbg выводит в стандартный вывод много информации.
Если посмотреть лог, то вы заметите что выполнение разделено на 5 пунктов, а не на 3 как я говорил в начале. Два пункта — перед препроцессингом и после — это парсинг исходного текста. Парсинг перед обработкой — и разбор обработанного текста.
Единственный выход за рамки стандарта, который я себе позволил — добавил конструкцию «outside», которая ввиду невозможности статической линковки позволяет объявлять функции из внешних библиотек. Сейчас возможно объявить только те функции, с библиотеками которых был собран интерпретатор, но в будущем будет возможность импорта из разделяемых библиотек.
Например,
outside cdecl: double cos(double x);
outside cdecl: double floor(double x);
Где cdecl — соглашение вызова функции. [Подробнее о таком вызове функций](http://habrahabr.ru/blogs/cpp/78886/).
Пишется продукт на С++.
[Посмотреть или скачать исходный код (Google Code)](http://code.google.com/p/cprompt/).
Надеюсь, скоро появится рабочий релиз продукта, который можно будет использовать, так как с каждым днем я всё ближе приближаюсь к стандарту. Конечная цель — полная поддержка C99.
Пример
======
`#include
int main(int argv,char\* argc[])
{
int l=round(7.2);
}`
На такой код лог будет [таким](http://paste.org.ru/?po4bz1).
Много лишнего, но при желании разобрать можно.
А какие ваши варианты использования интерпретатора си? Где бы можно было применить этот продукт?
UPD перенес в Языки программирования
UPD2 Добавил в репозиторий make-файл.
Для компиляции:
`svn checkout cprompt.googlecode.com/svn/trunk/ cprompt
cd cprompt
make`
и запускаем ./cprompt /path/to/file | https://habr.com/ru/post/80141/ | null | ru | null |
# Визуализация пересечений и перекрытий с помощью Python
### Изучение вариантов решения одной из самых сложных задач визуализации данных
Преобладающая задача в любом анализе данных — сравнение нескольких наборов чего-либо. Это могут быть списки IP-адресов для каждой целевой страницы вашего сайта, клиенты, которые купили определённые товары в вашем магазине, несколько ответов из опроса и многое другое.
В этой статье воспользуемся Python для изучения способов визуализации перекрытий и пересечений множеств, наших возможностей, а также их преимуществ и недостатков.
[](https://habr.com/ru/company/skillfactory/blog/536228/)
*Диаграмма Венна*
---
В следующих примерах я воспользуюсь [датасетом](https://github.com/data-visualization-society/data_visualization_survey/tree/master/data/2020) из [переписи общества визуализации данных 2020 года](https://www.datavisualizationsociety.com/census).
Я буду работать с опросом, потому что в нём много разнотипных вопросов; некоторые из них — это вопросы со множественным выбором и несколькими ответами, как показано ниже.
*Источник — [Datavisualizationsurvey Git](https://github.com/data-visualization-society/data_visualization_survey/tree/master/data/2020)*
Допустим, мы будем считать каждый ответ. В нашей диаграмме итоговые числа будут больше, чем общее число респондентов, что может вызвать трудности в понимания аудиторией, будут подниматься вопросы, непонимание заставит аудиторию скептически относиться к данным.
Например, если бы у нас было 100 респондентов и три возможных ответа — A, B и C.
У нас может быть что-то вроде этого:
50 ответов — A и B;
25 ответов — А и С;
25 ответов — А.
*Гистограмма*
Выглядит запутанным. Даже если мы объясним аудитории, что респондент может выбрать несколько вариантов ответа, трудно понять, что представляет собой эта диаграмма.
Кроме того, с такой визуализацией у нас нет никакой информации о пересечении ответов. Например, нельзя сказать, что никто не выбрал все три варианта.
Диаграммы Венна
---------------
Давайте начнём с простого и очень знакомого решения — диаграмм Венна. Я использую [Matplotlib-Venn](https://pypi.org/project/matplotlib-venn/) для этой задачи.
```
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib_venn import venn3, venn3_circles
from matplotlib_venn import venn2, venn2_circles
```
Теперь загрузим набор данных и подготовим данные, которые хотим проанализировать.
Вопрос, который мы проверим: «Что из этого лучше всего описывает вашу роль в качестве визуализатора данных за прошедший год?»
Ответы на этот вопрос распределены по 6 столбцам, по одному на каждый ответ. Если респондент выбрал ответ, в поле появится текст. Если нет, поле будет пустым. Мы преобразуем эти данные в 6 списков, содержащих индексы выбравших каждый ответ пользователей.
```
df = pd.read_csv('data/2020/DataVizCensus2020-AnonymizedResponses.csv')
nm = 'Which of these best describes your role as a data visualizer in the past year?'
d1 = df[~df[nm].isnull()].index.tolist() # independent
d2 = df[~df[nm+'_1'].isnull()].index.tolist() # organization
d3 = df[~df[nm+'_2'].isnull()].index.tolist() # hobby
d4 = df[~df[nm+'_3'].isnull()].index.tolist() # student
d5 = df[~df[nm+'_4'].isnull()].index.tolist() # teacher
d6 = df[~df[nm+'_5'].isnull()].index.tolist() # passive income
```
Диаграммы Венна просты в понимании и применении.
Нам нужно передать наборы с ключами/предложениями, которые мы будем анализировать. Если это пересечение двух наборов, воспользуемся Venn2; если это три набора, тогда используем Venn3.
```
venn2([set(d1), set(d2)])
plt.show()
```
*Диаграмма Венна*
Здорово! С помощью диаграмм Венна мы можем чётко показать, что 201 респондент выбрал А и не выбрал B, 974 респондента выбрали B и не выбрали A, а 157 респондентов выбрали A и B.
Можно даже настроить некоторые аспекты графика.
```
venn2([set(d1), set(d2)],
set_colors=('#3E64AF', '#3EAF5D'),
set_labels = ('Freelance\nConsultant\n
Independent contractor',
'Position in an organization\nwith some data
viz job responsibilities'),
alpha=0.75)
venn2_circles([set(d1), set(d2)], lw=0.7)
plt.show()
```
```
venn3([set(d1), set(d2), set(d5)],
set_colors=('#3E64AF', '#3EAF5D', '#D74E3B'),
set_labels = ('Freelance\nConsultant\n
Independent contractor',
'Position in an organization\nwith some data
viz job responsibilities',
'Academic\nTeacher'),
alpha=0.75)
venn3_circles([set(d1), set(d2), set(d5)], lw=0.7)
plt.show()
```
Это здорово, но что, если мы захотим отобразить перекрытия более трёх наборов? Здесь есть пара возможностей. Например, мы могли бы использовать несколько диаграмм.
```
labels = ['Freelance\nConsultant\nIndependent contractor',
'Position in an organization\nwith some data viz\njob responsibilities',
'Non-compensated\ndata visualization hobbyist',
'Student',
'Academic/Teacher',
'Passive income from\ndata visualization\nrelated products']
c = ('#3E64AF', '#3EAF5D')
# subplot indexes
txt_indexes = [1, 7, 13, 19, 25]
title_indexes = [2, 9, 16, 23, 30]
plot_indexes = [8, 14, 20, 26, 15, 21, 27, 22, 28, 29]
# combinations of sets
title_sets = [[set(d1), set(d2)], [set(d2), set(d3)],
[set(d3), set(d4)], [set(d4), set(d5)],
[set(d5), set(d6)]]
plot_sets = [[set(d1), set(d3)], [set(d1), set(d4)],
[set(d1), set(d5)], [set(d1), set(d6)],
[set(d2), set(d4)], [set(d2), set(d5)],
[set(d2), set(d6)], [set(d3), set(d5)],
[set(d3), set(d6)], [set(d4), set(d6)]]
fig, ax = plt.subplots(1, figsize=(16,16))
# plot texts
for idx, txt_idx in enumerate(txt_indexes):
plt.subplot(6, 6, txt_idx)
plt.text(0.5,0.5,
labels[idx+1],
ha='center', va='center', color='#1F764B')
plt.axis('off')
# plot top plots (the ones with a title)
for idx, title_idx in enumerate(title_indexes):
plt.subplot(6, 6, title_idx)
venn2(title_sets[idx], set_colors=c, set_labels = (' ', ' '))
plt.title(labels[idx], fontsize=10, color='#1F4576')
# plot the rest of the diagrams
for idx, plot_idx in enumerate(plot_indexes):
plt.subplot(6, 6, plot_idx)
venn2(plot_sets[idx], set_colors=c, set_labels = (' ', ' '))
plt.savefig('venn_matrix.png')
```
*Матрица диаграммы Венна*
Ничего страшного, но это не решило проблему. Мы не можем определить, есть ли кто-то, кто выбрал все ответы, а также невозможно определить пересечение трёх наборов. Как насчёт диаграммы Венна с четырьмя кругами?
Здесь всё начинает усложняться. На изображении выше нет пересечения только синего и зелёного. Чтобы решить эту проблему, вместо кругов мы можем использовать эллипсы.
В двух следующих примерах применяется [PyVenn](https://pypi.org/project/venn/).
```
from venn import venn
sets = {
labels[0]: set(d1),
labels[1]: set(d2),
labels[2]: set(d3),
labels[3]: set(d4)
}
fig, ax = plt.subplots(1, figsize=(16,12))
venn(sets, ax=ax)
plt.legend(labels[:-2], ncol=6)
```
Вот оно!
Но мы потеряли размер — критически важную для диаграммы информацию. Синий (807) меньше жёлтого (62), что не очень помогает в визуализации. Чтобы понять, что есть что, мы можем использовать легенду и метки, но таблица была бы яснее.
Есть несколько реализаций пространственных пропорциональных диаграмм Венна, которые могут работать с более чем тремя наборами, но на Python я не смог найти ни одной.
График UpSet
------------
Но есть и другое решение. [Графики UpSet](https://ieeexplore.ieee.org/document/6876017) — отличный способ отображения пересечения нескольких множеств. Они не так интуитивно понятны для чтения, как диаграммы Венна, но делают свою работу. Я воспользуюсь [UpSetPlot](https://pypi.org/project/UpSetPlot/), но сначала подготовлю данные.
```
upset_df = pd.DataFrame()
col_names = ['Independent', 'Work for Org', 'Hobby', 'Student', 'Academic', 'Passive Income']
nm = 'Which of these best describes your role as a data visualizer in the past year?'
for idx, col in enumerate(df[[nm, nm+'_1', nm+'_2', nm+'_3', nm+'_4', nm+'_5']]):
temp = []
for i in df[col]:
if str(i) != 'nan':
temp.append(True)
else:
temp.append(False)
upset_df[col_names[idx]] = temp
upset_df['c'] = 1
example = upset_df.groupby(col_names).count().sort_values('c')
example
```
При правильном расположении данных нам нужен только один метод, чтобы нарисовать нашу диаграмму, и всё.
```
upsetplot.plot(example['c'], sort_by="cardinality")
plt.title('Which of these best describes your role as a data visualizer in the past year?', loc='left')
plt.show()
```
*График UpSet*
Потрясающе! Наверху — столбцы, показывающие, сколько раз появлялась комбинация. Внизу — матрица, показывающая, какую комбинацию представляет каждый столбец, а внизу слева — горизонтальная гистограмма, представляющая общий размер каждого набора.
Это большое количество информации, но хорошо организованный макет позволяет легко извлекать её.
Даже с моими плохо написанными метками мы легко можем увидеть, что большинство людей выбрали «работать на организацию».
Второй наиболее распространённый ответ даже не отображался на предыдущих диаграммах Венна: количество людей, которые не выбрали ни одного ответа.
В целом визуализация множеств и их пересечений может быть задачей для решения в уме, но у нас есть несколько хороших вариантов её решения.
Я предпочитаю диаграммы Венна, когда имею дело с небольшим количеством множеств, и графики Upset, когда множеств больше трёх. Всегда полезно объяснить, что показывает визуализация и как читать диаграммы, которые вы представляете, особенно в случаях, когда диаграммы не очень дружелюбны.
*Визуализация трех наборов*
*Визуализация шести наборов*
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=060121)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=060121)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=060121)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=060121)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=060121)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=060121)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=060121)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=060121)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=060121)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=060121)
---
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=060121)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=060121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=060121)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=060121)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=060121)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=060121)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=060121) | https://habr.com/ru/post/536228/ | null | ru | null |
# Создание сапера при помощи модуля Tkinter
День добрый. Почти каждый начинающий программист стремится к созданию своей первой игры. Спустя пол года ~~ленивого~~ кропотливого обучения я решился написать сапера. Языком написания был выбран Python, модулем для добавления интерфейса tkinter, потому как уже имелся опыт работы с ним. Этот пост будет полезен скорее начинающим кодерам, но если вы итак все знаете, можете написать свои советы по улучшению кода в комменты.
Приступим. Первым делом нужно было определиться, что будет собой представлять клетка. Самое выгодное решение — создать класс поля:
```
class pole(object): #создаем Класс поля, наследуемся от Object
def __init__(self,master,row, column): #Инициализация поля. master - окно Tk().
self.button = Button(master, text = ' ') #Создаем для нашего поля атрибут 'button'
self.mine = False #Переменная наличия мины в поле
self.value = 0 #Кол-во мин вокруг
self.viewed = False #Открыто/закрыто поле
self.flag = 0 #0 - флага нет, 1 - флаг стоит, 2 - стоит "?"
self.around = [] #Массив, содержащий координаты соседних клеток
self.clr = 'black' #Цвет текста
self.bg = None #Цвет фона
self.row = row #Строка
self.column = column #Столбец
```
Теперь надо создать интерфейс для настройки игры:
```
settings = Tk() #Создаем окно
settings.title('Настройки') #Пишем название окна
settings.geometry('200x150') #Задаем размер
mineText = Text(settings, width = 5, height = 1) #Создаем поля для ввода текста и пояснения
mineLabe = Label(settings, height = 1, text = 'Бомбы:')
highText = Text(settings, width = 5, height = 1)
highLabe = Label(settings, height = 1, text = 'Ширина:')
lenghtText = Text(settings, width = 5, height = 1)
lenghtLabe = Label(settings, height = 1, text = 'Высота:')
mineBut = Button(settings, text = 'Начать:', command = bombcounter) #Создаем кнопку
mineBut.place(x = 70, y = 90) #Размещаем это все
mineText.place(x = 75, y = 5)
mineLabe.place(x = 5, y = 5)
highText.place(x = 75, y = 30)
highLabe.place(x = 5, y = 30)
lenghtText.place(x = 75, y = 55)
lenghtLabe.place(x = 5, y = 55)
settings.mainloop()
```
В итоге получаем вот такое вот окно:
Теперь нужно прописать функцию bombcounter
```
def bombcounter():
global bombs
if mineText.get('1.0', END) == '\n': #Проверяем наличие текста
bombs = 10 #Если текста нет, то по стандарту кол-во бомб - 10
else:
bombs = int(mineText.get('1.0', END)) #Если текст есть, то это и будет кол-во бомб
if highText.get('1.0', END) == '\n':
high = 9
else:
high = int(highText.get('1.0', END))
if lenghtText.get('1.0', END) == '\n':
lenght = 9
else:
lenght = int(lenghtText.get('1.0', END))
game(high,lenght) #Начинаем игру, передавая кол-во полей
```
Теперь приступаем к основной части, написанию функции игры:
```
def game(high,lenght): #получаем значения
root = Tk()
root.title('Сапер')
global buttons
global mines
global flags
flags = [] #Массив, содержащий в себе места, где стоят флажки
mines = [] #Массив, содержащий в себе места, где лежат мины
buttons = [[pole(root,j,i) for i in range(high)] for j in range(lenght)] #Двумерный массив, в котором лежат поля
for i in range(len(buttons)): #Цикл по строкам
for j in range(len(buttons[i])): #Цикл по элементам строки
buttons[i][j].button.grid(column = j, row = i, ipadx = 7, ipady = 1) #Размещаем все в одной сетке при помощи grid
buttons[i][j].button.bind('', buttons[i][j].view) #Биндим открывание клетки
buttons[i][j].button.bind('', buttons[i][j].setFlag) #Установка флажка
buttons[i][j].setAround() #Функция заполнения массива self.around
buttons[0][0].button.bind('', cheat) #создаем комбинацию клавиш для быстрого решения
root.resizable(False,False) #запрещаем изменения размера
root.mainloop()
```
У нас появилось целых три функции, которые нужно написать. Начнем с .setAround():
```
def setAround(self):
if self.row == 0:
self.around.append([self.row+1,self.column])
if self.column == 0:
self.around.append([self.row,self.column+1])
self.around.append([self.row+1,self.column+1])
elif self.column == len(buttons[self.row])-1:
self.around.append([self.row,self.column-1])
self.around.append([self.row+1,self.column-1])
else:
self.around.append([self.row,self.column-1])
self.around.append([self.row,self.column+1])
self.around.append([self.row+1,self.column+1])
self.around.append([self.row+1,self.column-1])
elif self.row == len(buttons)-1:
self.around.append([self.row-1,self.column])
if self.column == 0:
self.around.append([self.row,self.column+1])
self.around.append([self.row-1,self.column+1])
elif self.column == len(buttons[self.row])-1:
self.around.append([self.row,self.column-1])
self.around.append([self.row-1,self.column-1])
else:
self.around.append([self.row,self.column-1])
self.around.append([self.row,self.column+1])
self.around.append([self.row-1,self.column+1])
self.around.append([self.row-1,self.column-1])
else:
self.around.append([self.row-1,self.column])
self.around.append([self.row+1,self.column])
if self.column == 0:
self.around.append([self.row,self.column+1])
self.around.append([self.row+1,self.column+1])
self.around.append([self.row-1,self.column+1])
elif self.column == len(buttons[self.row])-1:
self.around.append([self.row,self.column-1])
self.around.append([self.row+1,self.column-1])
self.around.append([self.row-1,self.column-1])
else:
self.around.append([self.row,self.column-1])
self.around.append([self.row,self.column+1])
self.around.append([self.row+1,self.column+1])
self.around.append([self.row+1,self.column-1])
self.around.append([self.row-1,self.column+1])
self.around.append([self.row-1,self.column-1])
```
Все, что здесь происходит, это заполнение массива self.around. Мы рассматриваем различные случаи и на выходе получаем верный ответ. Если есть варианты, как сделать это проще, я приму их во внимание.
Пишем view()
```
def view(self,event):
if mines == []: #При первом нажатии
seter(0,self.around,self.row,self.column) #Устанавливаем мины
if self.value == 0: #Устанавливаем цвета. Можно написать и для 6,7 и 8, но у меня закончилась фантазия
self.clr = 'yellow'
self.value = None
self.bg = 'lightgrey'
elif self.value == 1:
self.clr = 'green'
elif self.value == 2:
self.clr = 'blue'
elif self.value == 3:
self.clr = 'red'
elif self.value == 4:
self.clr = 'purple'
if self.mine and not self.viewed and not self.flag: #Если в клетке есть мина, она еще не открыта и на ней нет флага
self.button.configure(text = 'B', bg = 'red') #Показываем пользователю, что тут есть мина
self.viewed = True #Говорим, что клетка раскрыта
for q in mines:
buttons[q[0]][q[1]].view('') #Я сейчас буду вскрывать ВСЕ мины
lose() #Вызываем окно проигрыша
elif not self.viewed and not self.flag: #Если мины нет, клетка не открыта и флаг не стоит
self.button.configure(text = self.value, fg = self.clr, bg = self.bg) #выводим в текст поля значение
self.viewed = True
if self.value == None: #Если вокруг нет мин
for k in self.around:
buttons[k[0]][k[1]].view('') #Открываем все поля вокруг
```
Итак. Сейчас у нас написаны функции: открытия клетки, заполнения массива around, начала игры и получения значения насчет размера игрового поля и кол-ва мин. Но до сих пор нет функции для установки мин. Исправляемся:
```
def seter(q, around,row,column): #Получаем массив полей вокруг и координаты нажатого поля
if q == bombs: #Если кол-во установленных бомб = кол-ву заявленных
for i in range(len(buttons)): #Шагаем по строкам
for j in range(len(buttons[i])): #Шагаем по полям в строке i
for k in buttons[i][j].viewAround(): #Шагаем по полям вокруг выбранного поля j
if buttons[k[0]][k[1]].viewMine(): #Если в одном из полей k мина
buttons[i][j].setValue(buttons[i][j].viewValue()+1) #То увеличиваем значение поля j
return
a = choice(buttons) #Выбираем рандомную строку
b = choice(a) #Рандомное поле
if [buttons.index(a),a.index(b)] not in mines and [buttons.index(a),a.index(b)] not in around and [buttons.index(a),a.index(b)] != [row,column]: #Проверяем, что выбранное поле не выбиралось до этого и, что не является полем на которую мы нажали (или окружающим ее полем)
b.setMine() #Ставим мину
mines.append([buttons.index(a),a.index(b)]) #Добавляем ее в массив
seter(q+1,around,row,column) #Вызываем установщик, сказав, что одна мина уже есть
else:
seter(q,around,row,column) #Вызываем установщик еще раз
```
И вторая важная для нас функция: setValue()
```
def setValue(self,value):
self.value = value
```
На этом заканчивается основная часть. Игра может работать прямо сейчас, но без установки флажка и определения победы/проигрыша. Тут все просто. Установка флажка:
```
def setFlag(self,event):
if self.flag == 0 and not self.viewed: #Если поле не открыто и флага нет
self.flag = 1 #Ставим флаг
self.button.configure(text = 'F', bg = 'yellow') #Выводим флаг
flags.append([self.row,self.column]) #Добавляем в массив флагов
elif self.flag == 1: #Если флаг стоим
self.flag = 2 #Ставим значение '?'
self.button.configure(text = '?', bg = 'blue') #Выводим его
flags.pop(flags.index([self.row,self.column])) #Удаляем флаг из массива флагов
elif self.flag == 2: #Если вопрос
self.flag = 0 #Устанавливаем на отсутствие флага
self.button.configure(text = ' ', bg = 'white') #Выводим пустоту
if sorted(mines) == sorted(flags) and mines != []: #если массив флагов идентичен массиву мин
winer() #Сообщаем о победе
```
Функции lose() и winer() просты и не требуют объяснений. Если будет нужно, напишу в комменты.
Финальный вид:
Свои вопросы, предложения и критику пишите в комменты, постараюсь ответить, обсудить и подумать. | https://habr.com/ru/post/326358/ | null | ru | null |
# Кроссбраузерный <progress>-бар
Доброе время суток, Хабро-сообщество!
Совсем недавно по работе мне попалась интересная задачка, которую я всё же [реализовал](http://css-live.ru/Primer/progress-bar/progress-result.html). Нужно было соорудить прогресс-бар, который был бы полностью универсальный, поддающийся любой стилизации и плюс ко всему кроссбраузерный (начиная c IE7+)!
Здесь привожу конечный результат. Полный вариант статьи можно найти [здесь](http://css-live.ru/tricks/krossbrauzernyj-progress-bar/)
Как вы понимаете, в задачу входило не только сделать, но и ещё по максимуму использовать в работе натуральный элемент . Его плюс в том, что он является уже почти что готовым решением + семантически правильным в данной ситуациии. Но каково было моё разочарование, когда я понял, что этот элемент, мало того, что очень плохо стилизуется, так ещё и не поддерживается даже в одном из последних браузеров.
Что с поддержкой в браузерах?
-----------------------------
На сегодняшний день поддержка в браузерах такова: Firefox 11, Opera 11.61, Chrome 17.
Такой скудный расклад меня явно огорчил и абсолютно не устраивал((. Честно говоря, я рассчитывал на нечто большее, предполагая, что и Safari 5.1 и Internet Explorer 9 всё будет так же здорово.
Что же делать?
--------------
В общем для начала я решил порыскать в инете и попробовать найти какие нибудь полезные проприетарные штуки для браузеров. В итоге нашлись три вещи:
* **::-webkit-progress-bar**
* **::-webkit-progress-value**
* **::-moz-progress-bar**
Вкратце, это псевдоэлементы, благодаря которым можно достучаться до элемента в браузерах Firefox и в Webkit-ных.
Промежуточный тест
------------------
Не смотря на то, что в некоторых браузерах есть поддержка элемента , его стилизация, даже там, оставляет желать лучшего. Например, Opera не хочет поддаваться стилизации и на любое неверное движение приводит полосу индикатора к ненужному нам цвету, а в Safari вообще не работает сам индикатор. Поэтому, я решил использовать найденные свойства и посмотреть, что это мне даст.
```
Текст
```
```
progress {
margin: 2em auto;
display: block;
width: 100px;
border-radius : 8px;
background: #fff;
padding: 0;
border: 0;
text-align: center;
height: 20px;
box-shadow: 1px 2px rgba(0,0,0,.3) inset, 0 0 0 1px rgba(0,0,0,.5);
overflow:hidden;
background: -o-linear-gradient(#4c4, #8f8 50%, #4c4);
}
progress::-moz-progress-bar {
background: -moz-linear-gradient(#4c4, #8f8 50%, #4c4);
border-radius: 8px;
}
progress::-webkit-progress-bar {
background: #fff;
box-shadow: 1px 2px rgba(0,0,0,.3) inset, 0 0 0 1px rgba(0,0,0,.5);
}
progress::-webkit-progress-value {
background: -webkit-linear-gradient(#4c4, #8f8 50%, #4c4);
border-radius: 8px;
}
```
И вот что получилось:
В Firefox и Chrome мы смогли подчинить себе прогресс-бар полностью, включая каркас и сам индикатор. Случилось это благодаря проприетарным свойтсвам (без них почему-то картина была такая же, как и в Opera) Но, к сожалению в Safari такой номер не прошёл и даже фон исчез полностью. В Opera цвет полоски стал иным после того, как я применил стили к элементу , а про IE я вообще помолчу.
Естественно, я в любом случае собирался применять скрипт, но мне хотелось сократить его основное применение хотя бы к ряду браузеров.
Однозначно можно сказать про две вещи. Основные скрипты не нужны для Firefox и Chrome, но полюбому нужны для IE6-9 и Safari. А вот с Opera я решил вообще не париться и оставить в ней цвет индикатора на совести разработчиков этого браузера.
Задача
------
Перед написанием скрипта, нужно подитожить нашу задачу и определится, что мы вообще хотим получить.
* По максимуму задействовать элемент там, где это возможно. Семантика здесь играет ключевую роль (если это не вредит качеству) и поэтому использовать семантические элементы для нас очень важно.
* Прогресс-бар должен содержать отдельный текст, который будет отображать текущий процент заполнения индикатора.
* Прогресс-бар должен быть легко настраиваемый и видоизменяющимся. В зависимости от класса он должен менять ширину, высоту, цвет и т.д.
* Наш прогресс-бар должен работать по возможности одинаково во всех браузерах, начиная с IE7+
Исходя из задачи, я сделал вывод, что в нашем случае подошёл бы общий контейнер, в котором находились бы сам элемент и второй элемент для текста.
```
*0%*
```
Далее уже должно идти путешествие по скрипту, но я решил оставить эту часть для тех, кто захочет [прочитать статью](http://css-live.ru/tricks/krossbrauzernyj-progress-bar/) полностью.
Единственное скажу, что суть в том, что для «нормальных» браузеров я применил скрипт только лишь для заполнения индикатора, а для всех остальных браузеров сделал подмену элемента на элемент со спец. классом, через который в итоге можно стилизовать наш прогресс-бар как нам вздумается.
Так что здесь я выложу [уже готовое решение](http://css-live.ru/Primer/progress-bar/progress-result.html), а тем, кто уже знаком [с моим стилем](http://habrahabr.ru/post/138501/) и хочет прочитать всю статью целиком, [милости прошу в саму статью](http://css-live.ru/tricks/krossbrauzernyj-progress-bar/). Не забудьте о печеньках! :) | https://habr.com/ru/post/140167/ | null | ru | null |
# Не Dagger'ом едины
В последнее время многим программистам очень понравилась библиотека для реализации внедрения зависимостей Dagger2. Хотя, как мне кажется, из-за неочевидной работы под капотом и большим семейством аннотаций Dagger долго заходил в комьюнити. И так получается что сейчас куда не глянь многие использую эту библиотеку почти везде. И уже Dependancy Injection становится синонимом этой самой библиотеки. Хотя это всего лишь библиотека. Да, хорошая, не спорю. Статья будет не о свержение Dagger'a с трона короля библиотек DI. А я бы хотел рассказать о другом инструменте для подобных целей — это [Koin](https://insert-koin.io/).
### Что такое KOIN?
Koin — это небольшая библиотека для написания внедрений зависимостей. Без прокси, кодогенерации и интроинспекции ([introspection](http://web.archive.org/web/20090226224821/http://java.sun.com/docs/books/tutorial/javabeans/introspection/index.html)). Работает как [Service Locator](https://www.reddit.com/r/androiddev/comments/7awvhp/moving_from_dagger_to_koin_simplify_your_android/). Использует DSL и фичи языка Kotlin. Сама библиотека подразумевает, что будет использоваться в приложениях написанные на Kotlin, но можно и с [Java](https://gist.github.com/arnaudgiuliani/446e0d8ee79f4bda38b3057b01098f2e).
Посмотрим как его можно использовать в проекте. Для начала надо реализовать модуль и все зависимости.
```
// Koin module
val mainModule: Module = applicationContext {
viewModel { UserProfileViewModel(get()) }
viewModel { MyProfileViewModel(get()) }
viewModel { DisplayUsersViewModel(get()) }
viewModel { RegistrationViewModel(get()) }
bean { Cicerone.create().navigatorHolder }
bean { UserRepository(get(), get()) as IUsersRepository }
bean { createFirestore() }
}
val remoteDatasourceModule = applicationContext {
// provided web components
bean { createOkHttpClient() }
bean { createWebService(get(), SERVER\_URL) }
}
```
**Зависимости**
```
fun createFirestore(): FirebaseFirestore {
val store = FirebaseFirestore.getInstance()
store.firestoreSettings = providesFirestoreSettings()
return store
}
fun providesFirestoreSettings(): FirebaseFirestoreSettings = FirebaseFirestoreSettings.Builder()
.setPersistenceEnabled(true)
.setSslEnabled(true)
.build()
fun createOkHttpClient(): OkHttpClient {
val httpLoggingInterceptor = HttpLoggingInterceptor()
httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
return OkHttpClient.Builder()
.addInterceptor(httpLoggingInterceptor)
.readTimeout(TIMEOUT, TimeUnit.SECONDS)
.connectTimeout(TIMEOUT, TimeUnit.SECONDS)
.build()
}
inline fun createWebService(okHttpClient: OkHttpClient, url: String): T {
val retrofit = Retrofit.Builder()
.baseUrl(url)
.addConverterFactory(GsonConverterFactory.create(GsonBuilder().setLenient().create()))
.addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io()))
.client(okHttpClient)
.build()
return retrofit.create(T::class.java)
}
```
Рассмотрим, что же есть в Koin DSL.
*applicationContext* — Это лямбда для создание Koin модуля. Эта функция возвращает модуль Koin и является началом каждого определения компонента в Koin.
*factory* — Предоставление зависимости как фабричный компонент, т.е. создает каждый раз новый экземпляр.
*bean* — Предоставление зависимости как Singleton.
*bind* — Дополнительное связывание типа Kotlin для данного определения компонента.
*get* — Разрешает компонентные зависимости. Функция сама поймет какая зависимость требуется для каждого класса.
*context* — Обьявление логического контекста.
*viewModel* — Специальное предоставление зависимости для ViewModel, находится в отдельном пакете *compile «org.koin:koin-android-architecture:$koin\_version»*
В конкретном примере мы работаем с архитектурными компонентами и используем ViewModel в проекте. У нас есть потребность инжектить IUserRepository во ViewModel. Koin позволяет довольно просто доставлять зависимости через конструктор во ViewModel.
Модуль необходимо будет запустить с помощью функции startKoin() в классе Application().
```
override fun onCreate() {
super.onCreate()
startKoin(this, listOf(mainModule, remoteDatasourceModule))
}
```
По факту этого уже нам хватит, чтобы использовать viewmodel в различных фрагментах и активити.
```
class MyActivity : AppCompatActivity(){
// Inject MyPresenter
val presenter : MyPresenter by inject()
// or Inject MyViewModel
val myViewModel : MyViewModel by viewModel()
// or Sharing ViewModel
val mySharedViewModel : MySharedViewModel by sharedViewModel()
```
К тому же, используя *by inject(),* у нас происходит ленивая инициализация компонента.
Если мы против ленивых вещей, тогда можем сделать инициализировать напрямую:
```
val myViewModel : MyViewModel = getViewModel()
```
Если вдруг вам надо поделиться своей ViewModel с Acitivity/Fragment, тогда можно использовать sharedViewModel(). В этот момет Acitivity или Fragment будут иметь один и тот же экземпляр MySharedViewModel.
Бывают случаи когда надо делать инжект например в кастомное вью, здесь вам поможет [Koin Components](http://insert-koin.io/docs/1.0/reference/koin-components/). Достаточно отнаследоваться от KoinComponent и появится возможность использовать by inject<>(). На данный момент это не требуется в следующих классах: `Application`,`Context`, `Activity`, `Fragment`, `Service.
Для ViewMode ничего особенного, просто получаем необходимые зависимости в конструкторе.
```
// Use Repository - injected by constructor by Koin
class MyViewModel(val repository : Repository) : ViewModel(){
....
}
```
**Пример с BaseViewModel и BaseFragment**
```
open class BaseViewModel : ViewModel(), LifecycleObserver {
val disposables = CompositeDisposable()
val loadingStatus = MutableLiveData()
fun addObserver(lifecycle: Lifecycle) {
lifecycle.addObserver(this)
}
fun removeObserver(lifecycle: Lifecycle) {
lifecycle.removeObserver(this)
}
override fun onCleared() {
disposables.dispose()
super.onCleared()
}
}
abstract class BaseFragment(viewModelClass: KClass) : Fragment() {
protected val viewModel: T by viewModelByClass(true, viewModelClass)
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
viewModel.addObserver(lifecycle)
}
override fun onDestroyView() {
viewModel.removeObserver(lifecycle)
super.onDestroyView()
}
@LayoutRes
protected abstract fun getLayoutRes(): Int
}
class UserProfileFragment : BaseFragment(UserProfileViewModel::class) {
....// Здесь вы уже можете сразу использовать viewModel
}
```
### Тесты
Тут все просто, надо тестовый класс наследовать от KoinTest и появляется возможность инжектить прямо в тестовый класс.
**Пример теста**
```
val localJavaDatasourceModule = applicationContext {
provide { LocalDataSource(JavaReader()) as WeatherDatasource }
}
val testRxModule = applicationContext {
// provided components
provide { TestSchedulerProvider() as SchedulerProvider }
}
val testApp = weatherApp + testRxModule + localJavaDatasourceModule
class ResultPresenterTest : KoinTest {
val view: ResultListContract.View = mock(ResultListContract.View::class.java)
val presenter: ResultListContract.Presenter by inject { mapOf(RESULT_VIEW to view) }
@Before
fun before() {
startKoin(testApp)
}
@After
fun after() {
closeKoin()
}
@Test
fun testDisplayWeather() {
presenter.getWeather()
Mockito.verify(view).displayWeather(emptyList())
}
}
```
#### Логирование.
Ошибки Koin будет выкидавать в runtime. Так что тестировать необходимо все.
В процессе дебага Koin делает логгирование и в случае ошибки кидает вполне понятный stacktrace:
**Пример логирования при создании**
```
04-02 12:45:23.344 ? I/KOIN: [context] create
04-02 12:45:23.377 ? I/KOIN: [module] declare Factory[class=ru.a1024bits.bytheway.viewmodel.UserProfileViewModel, binds~(android.arch.lifecycle.ViewModel)]
[module] declare Factory[class=ru.a1024bits.bytheway.viewmodel.MyProfileViewModel, binds~(android.arch.lifecycle.ViewModel)]
[module] declare Factory[class=ru.a1024bits.bytheway.viewmodel.DisplayUsersViewModel, binds~(android.arch.lifecycle.ViewModel)]
[module] declare Factory[class=ru.a1024bits.bytheway.viewmodel.RegistrationViewModel, binds~(android.arch.lifecycle.ViewModel)]
[module] declare Bean[class=ru.a1024bits.bytheway.router.LocalCiceroneHolder]
[module] declare Bean[class=ru.terrakok.cicerone.NavigatorHolder]
[module] declare Bean[class=ru.a1024bits.bytheway.repository.IUsersRepository]
[module] declare Bean[class=com.google.firebase.firestore.FirebaseFirestore]
04-02 12:45:23.379 ? I/KOIN: [module] declare Bean[class=okhttp3.OkHttpClient]
[module] declare Bean[class=ru.a1024bits.bytheway.MapWebService]
[modules] loaded 10 definitions
[properties] load koin.properties
04-02 12:45:23.397 ? I/KOIN: [init] Load Android features
04-02 12:45:23.566 ? I/KOIN: [Properties] no assets/koin.properties file to load
[init] ~ added Android application bean reference
[module] declare Bean[class=android.app.Application, binds~(android.content.Context)]
04-02 12:45:23.593 ? I/KOIN: [ViewModel] get for FragmentActivity @ ru.a1024bits.bytheway.ui.activity.SplashActivity@3cd01a24
04-02 12:45:23.594 ? I/KOIN: Resolve class[ru.a1024bits.bytheway.viewmodel.RegistrationViewModel] with Factory[class=ru.a1024bits.bytheway.viewmodel.RegistrationViewModel, binds~(android.arch.lifecycle.ViewModel)]
04-02 12:45:23.596 ? I/KOIN: Resolve class[ru.a1024bits.bytheway.repository.IUsersRepository] with Bean[class=ru.a1024bits.bytheway.repository.IUsersRepository]
Resolve class[com.google.firebase.firestore.FirebaseFirestore] with Bean[class=com.google.firebase.firestore.FirebaseFirestore]
04-02 12:45:23.600 ? I/KOIN: (*) Created
04-02 12:45:23.601 ? I/KOIN: Resolve class[ru.a1024bits.bytheway.MapWebService] with Bean[class=ru.a1024bits.bytheway.MapWebService]
Resolve class[okhttp3.OkHttpClient] with Bean[class=okhttp3.OkHttpClient]
04-02 12:45:23.608 ? I/KOIN: (*) Created
04-02 12:45:23.615 ? I/KOIN: (*) Created
04-02 12:45:23.616 ? I/KOIN: (*) Created
(*) Created
04-02 12:45:23.749 ? I/KOIN: [ViewModel] get for FragmentActivity @ ru.a1024bits.bytheway.ui.activity.RegistrationActivity@187baf0
Resolve class[ru.a1024bits.bytheway.viewmodel.RegistrationViewModel] with Factory[class=ru.a1024bits.bytheway.viewmodel.RegistrationViewModel, binds~(android.arch.lifecycle.ViewModel)]
Resolve class[ru.a1024bits.bytheway.repository.IUsersRepository] with Bean[class=ru.a1024bits.bytheway.repository.IUsersRepository]
(*) Created
```
**Пример ошибки**
```
I/KOIN: Resolve class[ru.a1024bits.bytheway.viewmodel.RegistrationViewModel] with Factory[class=ru.a1024bits.bytheway.viewmodel.RegistrationViewModel, binds~(android.arch.lifecycle.ViewModel)]
W/System.err: org.koin.error.NoBeanDefFoundException: No definition found to resolve type 'ru.a1024bits.bytheway.repository.UserRepository'.
Check your module definition
W/System.err: at org.koin.KoinContext.getVisibleBeanDefinition(KoinContext.kt:119)
at org.koin.KoinContext.resolveInstance(KoinContext.kt:77)
at ru.a1024bits.bytheway.koin.ModuleKt$mainModule$1$4.invoke(Module.kt:39)
at ru.a1024bits.bytheway.koin.ModuleKt$mainModule$1$4.invoke(Unknown Source:2)
at org.koin.core.instance.InstanceFactory.createInstance(InstanceFactory.kt:58)
at org.koin.core.instance.InstanceFactory.retrieveInstance(InstanceFactory.kt:22)
at org.koin.KoinContext$resolveInstance$$inlined$synchronized$lambda$1.invoke(KoinContext.kt:85)
at org.koin.KoinContext$resolveInstance$$inlined$synchronized$lambda$1.invoke(KoinContext.kt:23)
at org.koin.ResolutionStack.resolve(ResolutionStack.kt:23)
at org.koin.KoinContext.resolveInstance(KoinContext.kt:80)
at org.koin.android.architecture.ext.KoinExtKt.getWithDefinitions(KoinExt.kt:56)
at org.koin.android.architecture.ext.KoinExtKt.getByTypeName(KoinExt.kt:32)
at org.koin.android.architecture.ext.KoinExtKt.get(KoinExt.kt:66)
at org.koin.android.architecture.ext.KoinFactory.create(KoinFactory.kt:31)
at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:134)
at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:102)
at ru.a1024bits.bytheway.ui.activity.SplashActivity.onCreate(SplashActivity.kt:56)
```
### Заключение.
На данный момент доступна версия 0.9.1, наверное с этим и связано малое распространение KOIN в проектах. Лично мне очень понравилась простота использования, возможность работы с ViewModel и ленивая инициализация компонентов. Думаю после релиза Koin ждет большая жизнь в Android/Kotlin разработке. А если вам не понравился Koin потому, что это Service Locator и Dagger тоже душу не греет, то тогда смотрите в сторону Kodein и Toothpick. | https://habr.com/ru/post/352352/ | null | ru | null |
# Триггерные рассылки
Последнее время в Email-маркетинге все чаще используются автоматические рассылки определенным группам потребителей. Типичные задачи: * поздравить с днем рожденья
* позвать на сайт, если потребитель на него долго не заходил
* сделать персонализированное предложение (делим потребителей на сегменты и рассылаем каждому сегменту свое письмо)
В этой статье мы расскажем, как мы решали эту задачу — от написания каждой отдельной рассылки разработчиком с нуля 3 года назад, до заведения рассылок менеджером через веб-интерфейс в настоящее время. Рассказ может быть интересен не только тем, кто занимается Email-маркетингом но и вообще всем, кому приходится реализовывать периодическое выполнение сложных операций над определенными выборками потребителей (знаю, что звучит очень абстрактно, но в итоге именно такую абстрактную задачу нам и пришлось решить).
#### **Первые реализации**
3 года назад подобные задачи возникали крайне редко и мы каждый раз реализовывали их с нуля. При этом возникали одни и те же вопросы:1. Как помечать потребителей, которым мы уже отправили это письмо?
2. Как максимально быстро обработать всех потребителей и при этом не тормозить работу сайтов (которые обращаются к тем же записям в БД)?
На первый вопрос ответ для нас был очевиден: в нашей системе сохраняется информации о всех значимых действиях, выполняемых потребителем (вход на сайт, изменение персональных данных) или над ним (розыгрыш приза, отправка уведомления). Кроме того, мы используем действия для разнообразных технических пометок потребителей. Так что при отправке автоматической рассылки, мы также решили выдавать потребителю особое **действие-маркер**, в качестве пометки, что эта автоматическая рассылка ему уже была отправлена. Чтобы повторно не отправлять рассылку, к условию рассылки всегда добавляется условие “у потребителя нет действия-маркера”.
На втором вопросе мы набили множество шишек, связанных с блокировками в БД, и в итоге пришли к следующему шаблону:1. Отправка рассылок идет из windows-сервиса, который периодически проверяет не появилось ли новых потребителей, подходящих под условия.
2. В сервисе первым шагом делается один запрос к БД с уровнем изоляции **Read Uncommitted**. Этот запрос вытаскивает Id всех потребителей, которым надо отправить письмо. Из-за низкого уровня изоляции такой запрос не накладывает блокировок на записи в БД и, как следствие, крайне слабо влияет на работу сайта. Однако он не гарантирует чистоту данных и их надо повторно проверить с более высоким уровнем изоляции.
3. После того, как мы вытащили Id потребителей, для каждого потребителя мы выполняем отдельную транзакцию с уровнем изоляции **Serializable**. В этой транзакции мы заново проверяем подходит ли потребитель под условия и если да, отправляем ему письмо и выдаем действие-маркер. Так как мы обрабатываем каждого потребителя в отдельной транзакции, блокировки накладываются только на данные одного потребителя и на работу остальных потребителей не влияют. Так как такая транзакция очень короткая, у потребителя, которому отправляют письмо, также не будет особых проблем, если он в это время ходит по сайту. Уровень изоляции транзакции должен быть именно Serializable, чтобы ненароком не отправить одно письмо дважды, или не отправить письмо тому потребителю, который внезапно перестал подходить под условия. Хотя, если мы гарантируем, что отправка одной и той же рассылки может идти только из одного потока и с одного сервера, а также забьем на небольшую вероятность того, что одному потребителю могут отправится две рассылки с взаимоисключающими условиями, то можно использовать и **Read Committed** транзакцию.
Само собой после реализации нескольких рассылок по этому шаблону, мы решили вынести шаблонный код. Для этого был создан класс **BatchMailing**, и для каждой новой рассылки мы создавали и регистрировали в специальном реестре его наследника. В наследнике необходимо было перегрузить следующие свойства и методы:* **шаблон действия-маркера** (раньше мы называли шаблон типом действия: думаю, для разработчиков это более понятный термин), которое выдается при отправке письма
* метод, отправляющий письмо
* метод, выполняющий дополнительные действия (например, вместе с отправкой поздравления с днем рожденья, мы можем выдавать потребителю баллы на счет)
* метод, который формирует **Expression>**, проверяющий, что потребитель подходит под условие
Свойство и первые два метода никогда никаких проблем не вызывали, но вот составить **Expression** было довольно таки не просто. Этот Expression использовался два раза — сначала в Read Uncommitted запросе, чтобы вытащить Id потребителей, а затем в Serializable транзакции, чтобы повторно проверить подходит ли потребитель под условие. Его было нужно написать так, чтобы **Linq to SQL** смог его транслировать в T-SQL. Условия могли быть довольно сложными и в них всегда возникали проблемы. Ни одну рассылку нельзя было завести не написав на нее кучку тестов. Кроме того, для отправки СМС и email мы завели разных промежуточных наследников от BatchMailing. Когда же нам надо было отправить и email и СМС, приходилось копипастить. У меня были идеи как это исправить, но так как автоматические рассылки клиенты просили не так уж и часто, это была низкоприоритетная задача.
#### **Замена наследования композицией**
2 года назад при разработке очередной рекламной кампании клиент попросил сделать ему сразу 8 разных автоматических рассылок. При этом частично условия в рассылках повторялись. Тут уже не оставалось сомнений, что больше так жить нельзя, и я взялся за переписывание нашей архитектуры. Для того чтобы справится со всеми описанными выше проблемами достаточно было применить наш любимый прием: замену наследования композицией. Этот прием настолько много раз нам помогал, что я советую использовать композицию вместо наследования везде, где это возможно (ну или как минимум рассматривать такой вариант). Если вы создаете базовый абстрактный класс с мыслью “для каждой конкретной задачи у меня будет наследник перегружающий методы и свойства”, сразу спрашивайте себя “а почему бы мне вместо этого не регистрировать для каждой задачи экземпляр класса, передавая ему разные настройки”. И только если вы уверены, что композиция здесь не подходит, используйте наследование. Если подходит и то и то, всегда склоняйтесь к композиции — так получается гораздо более гибкая и понятная архитектура.
В нашей ситуации:* вместо перегрузки свойства, возвращающего шаблон действия-маркера, это свойство проставляется экземпляру класса
* вместо перегрузки методов отправляющих письма/смс и выполняющих дополнительную логику, у экземпляра класса проставляется произвольная операция, которую нужно совершить над потребителем. При этом операция может быть комбинацией из других операций
* вместо перегрузки метода формирующего Expression, экземпляру класса проставляется условие. При этом условия можно комбинировать через И/ИЛИ
Так как кроме отправки рассылок эта сущность теперь может выполнять любые произвольные операции над потребителем, рассылкой ее называть некорректно. Фактически это класс который делает какую-то абстрактную работу над заданной выборкой потребителей. Не придумав ничего лучше, мы стали называть это **триггерами** (в маркетинге их примерно так и называют, так что название неплохое). Меня, честно говоря, немного пугало то, что я ввел в систему крайне абстрактную сущность, которую можно назвать **DoSomeWorkOnSomeCustomers**. Но никакого смысла в специализации триггеров не было, так что я решил над этим не заморачиваться, и в принципе больших проблем с пониманием, что такое триггер, у клиентов не возникает.
Регистрация триггера выглядела примерно следующим образом:
```
Add(new Trigger(“Приглашение на сайт для пришедших через канал one-to-one”)
{
MarkerActionTemplateSystemName = “InvitationMarker”,
TriggerAction = new TriggerActionCombination(
new GeneratePasswordForCustomerTriggerAction(),
new SendEmailTriggerAction(“InvitationMailing”)),
TriggerCondition = new AndTriggerConditionSet(
new CustomerHasSubscripionCondition(),
new CustomerHasEmailTriggerCondition(),
new CustomerHadFirstActionOverChannelCondition(“OneToOne”)),
});
```
Интерфейс **TriggerAction**’а крайне прост:
```
public interface ITriggerAction
{
void Execute(
ModelContext modelContext, // класс для работы с БД
Customer customer);
}
```
Базовый класс для условий триггера выглядит следующим образом:
```
public class TriggerCondition
{
private readonly Func>> triggerExpressionBuilder;
public TriggerCondition(Func>> triggerExpressionBuilder)
{
if (triggerExpressionBuilder == null)
throw new ArgumentNullException("triggerExpressionBuilder");
this.triggerExpressionBuilder = triggerExpressionBuilder;
}
public Expression> GetExpression(ModelContext modelContext)
{
return triggerExpressionBuilder(modelContext, brand);
}
// Используется в Read Uncommitted транзакции для получения спиcка Id потребителей, подходящих под условие
public IQueryable ChooseCustomers(ModelContext modelContext, IQueryable customers)
{
if (modelContext == null)
throw new ArgumentNullException("modelContext");
if (customers == null)
throw new ArgumentNullException("customers");
var expression = GetExpression(modelContext);
return customers.Where(expression).ExpandExpressions();
}
// Используется в Serializable транзакции, для проверки, что потребитель все еще подходит под условие
public bool ShouldTrigger(ModelContext modelContext, Customer customer)
{
if (modelContext == null)
throw new ArgumentNullException("modelContext");
if (customer == null)
throw new ArgumentNullException("customer");
var expression = GetExpression(modelContext);
// Можно бы было просто вызывать expression.Evaluate(customer),
// но тогда для сложных условий выполнилось бы несколько запросов в БД вместо одного
return modelContext.Repositories.Get().Items
.Where(aCustomer => aCustomer == customer)
.Where(aCustomer => expression.Evaluate(aCustomer))
.ExpandExpressions()
.Any();
}
}
```
Для часто используемых условий мы создавали наследников от **TriggerCondition**, в которых строился конкретный Expression в зависимости от переданных в конструктор параметров.
#### **Все, надоело, сами заводите свои триггеры**
С использованием архитектуры, описанной выше, мы заводили триггер менее чем за пол часа, за счет комбинирования уже написанных условий и TriggerAction’ов. Однако и этого нам было мало. Следующим шагом мы захотели полностью исключить разработчиков из процесса заведения триггеров. Причем как это делать в общих чертах я понял уже через пару месяцев после реализации предыдущей версии архитектуры. Условия триггеров были один в один похожи на **фильтры**, которые мы используем в админке. Наша система фильтров позволяет описывать сложные условия, включая запросы к связанным сущностям, а также позволяет комбинировать их через И/ИЛИ. Фильтр формирует Expression, с помощью которого уже можно отфильтровывать сущности в БД. И для всего этого уже был написан UI и сериализация. Оставалось лишь добавить пару фильтров, которые часто нужны для триггеров, но не имели смысла при обычной работе со списком потребителей (например: “с действия прошло N дней”). Для TriggerAction’ов надо было написать UI и структуру для хранения их в БД, но тут тоже в общем все было понятно. Однако оставались еще небольшие вопросы, над которым пришлось поломать голову:* отсылку любого письма мы к этому времени стали регистрировать как действие, и действие-маркер стало лишним — мы и так могли определить, кому мы отправляли письмо, и вообще хотелось бы избавиться от выдачи лишних действий везде, где это было возможно
* кроме простых триггеров, которые выполняли определенный набор операций один раз над каждым потребителем, у нас появились **периодические триггеры**. Надо было придумать как это все перенести в БД и при этом позволить использовать **произвольные маркеры**
* маркетологи придумывают триггеры не отдельно друг от друга, а в качестве **цепочек**, в которых есть как триггеры так и операции, выполняемые потребителем на сайте (письмо с предложением зайти на сайт и что-то сделать → потребитель выполняет несколько операций на сайте → начисляются бонусные баллы и посылается письмо об этом). Хотелось бы если и не реализовать это сразу, то оставить задел на будущее, чтобы было не сложно описывать зависимости между триггерами и операциями
Все эти три проблемы связаны с тем, как мы определяем выполнился ли триггер над потребителем или нет. Если заводить для каждого триггера и операции на сайте свой маркер, задача сильно упрощается, но плодить лишние действия в системе очень не хотелось. Была даже идея заставлять менеджеров составлять фильтр таким образом, чтобы он полностью отвечал за то, можно ли сейчас выполнить действие над потребителем (и соответственно частота повторения триггера описывалась бы условием в фильтре), однако данный подход слишком уж располагает к ошибкам. После долгих мучительных размышлений мне все-таки пришла идея, как отслеживать выполнение триггеров без дополнительных сущностей и без усложнения работы менеджера.
#### **Нужно больше Expression’ов**
Так как триггер выполняет абстрактный **шаг операции** (бывший TriggerAction) над потребителем, причем почти всегда этот шаг операции уникален (например, определенное письмо отсылается или определенный приз выдается только из этого триггера), то в этот шаг можно вынести логику проверяющую выполнился ли он. Так как в триггере может быть несколько шагов операции, то менеджеру надо будет выбрать какой из них является **маркером** (проверять выполнение каждого шага не имеет смысла). Однако просто, реализовать в шаге операции метод, возвращающий **Expression>** нельзя, так как пришлось бы в каждом шаге операции формировать один Expression для одноразовых триггеров, другой для периодических. Тут нас спасает то, что практически любая операция над пользователем в нашей системе выдает ему действие. Соответственно шаг операции может отфильтровать те действия, которые были выдан им. Большинство шагов операции выдают конкретное действие и для них метод, формирующий Expression для фильтрации действий, выглядит вот так:
```
public sealed override Expression> GetIsMarkerExpression(ModelContext modelContext)
{
return action => action.ActionTemplateId == ActionTemplateId;
}
```
Но, например, у шага, выдающего приз, он выглядит следующим образом:
```
public override Expression> GetIsMarkerExpression(ModelContext modelContext)
{
IQueryablehabracut customerPrizes = modelContext.Repositories.Get().GetByPrizes(Prize);
// отфильтровываем действия, связанные с выдачей заданного приза
return action => customerPrizes.Any(prize => prize.CustomerActionId == action.Id);
}
```
Также, я опять применил свою любимую замену наследования композицией и вместо отдельных наследников для периодических и одноразовых триггеров сделал стратегию, которая проверяет нужно ли повторять выполнение триггера над текущим потребителем. Эта стратегия берет **Expression>** из маркерного шага триггера и с помощью него формирует **Expression>**, для дополнительной проверки нужно ли выполнять триггер над потребителем. Вот реализация для одноразового триггера:
```
public override Expression> BuildShouldRepeatExpression(ModelContext modelContext,
Expression> isMarkerExpression)
{
var markerActions = modelContext.Repositories.Get().Items
.Where(isMarkerExpression.ExpandExpressions());
return customer => !markerActions.Any(action => action.Customer == customer);
}
```
А вот для периодического:
```
public override Expression> BuildShouldRepeatExpression(
ModelContext modelContext, Expression> isMarkerExpression)
{
var isInPeriodExpression = PeriodType.BuildIsInPeriodExpression(modelContext, PeriodValue);
var markerActions = modelContext.Repositories.Get().Items
.Where(isMarkerExpression.ExpandExpressions());
var markerActionsInPeriod = markerActions.Where(isInPeriodExpression.ExpandExpressions());
if (MaxRepeatCount == null)
{
return customer => !markerActionsInPeriod.Any(action => action.Customer == customer);
}
else
{
return customer =>
!markerActionsInPeriod.Any(action => action.Customer == customer) &&
markerActions.Count() < MaxRepeatCount.Value;
}
}
```
Тут поддерживается не только повторение раз в N дней, но и раз в календарный месяц/год, поэтому Expression, проверяющий находится ли действие в заданном периоде, вынесен в специальный класс PeriodType. Так же поддерживается ограничение количества повторений.
Схема хранения всего этого добра в БД выглядит примерно так:
Сущность OperationStepGroup с одним полем выглядит довольно таки странно, но это позволяет разным сущностям (триггерам, операциям на сайте и др.) ссылаться на группу записей в реляционной БД. К тому же позже в этой сущности появились дополнительные поля, так что все не так уж и страшно.
Кроме того, что мы избавились от лишних маркерных шаблонов действий, мы можем использовать **IsMarkerExpression**, полученный из **маркерного шага** триггера, для того, чтобы отобразить статистику по количеству срабатываний триггера. Также мы можем добавить цепочки триггеров и операций (в операциях также используются шаги, один из которых помечается как маркерный).
В итоге менеджер может заводить триггер прямо в админке без участия разработчика, хотя подсказывать им частенько приходится: заведение нового триггера — эта задача не из легких, но такая уж цена за гибкость этого решения. Более простое решение было бы и менее гибким, хотя нам, конечно, придется еще много поработать, чтобы упростить UI при этом не потеряв текущей гибкости нашей архитектуры (можно, например, сделать Wizard’ы для заведения простых триггеров).
Как все это выглядит в UI, можно посмотреть [здесь](http://blog.directcrm.ru/?go=all/zavedenie-triggerov-dlya-kampaniy-v-sisteme-administrirovaniya/). | https://habr.com/ru/post/251915/ | null | ru | null |
# 42 строки кода для выхода из лимба
Вы ведь знаете, как это бывает: большой проект долго проектируется, долго пишется, порой вымучивается и в конце концов сдается. Проходит месяц другой «горячей отладки», и после наступает благоговейная тишина. От заказчика ничего не слышно. И не потому что он разорился благодаря вашим трудам; счета за телефон у него не оплачены, а интернет давно отключен, нет) Просто у него все работает в штатном режиме.
Но в один прекрасный день… Правильно! Прилетает мыло «[ваша программа не работает](http://bash.im/quote/268537)» ((С) bash), телефоны разогреваются до красна, а юристы нервно перечитывают, что они там накидали в раздел «гарантийное обслуживание».
Ровно такая ситуация была и у нас. Делали мы довольно увесистый проект, суть которого можно было бы описать так (кратко, конечно): есть разный контент (клиентская база, маркетинговая база, база связей и прочее, прочее, прочее) и различные способы его представления (widget, popup, modal etc.). Иными словами, с нашей стороны была подготовлена платформа (API доступа к данным, визуализация, вся, как это модно говорить, экосистема (хотя я не знаю, что это значит, но звучит уж очень круто)), чтобы разработчики заказчика могли писать свои контролеры данных и просто файликом их «класть» в указанное место, после чего счастливо лицезреть, как появляется новенький виджет со списком текущих котировок по какому-нибудь мудрёному индексу.
И как я уже сказал, все складывалось хорошо. Провели несколько «мастер» классов, все показали, все рассказали, выпили пива и завертелось. Уже без нас.
Пока все не сломалось. Именно так: «все» и «сломалось». В какие-то моменты приложение просто стало намертво виснуть. Да так, что вкладку браузера не закроешь. Мало-мальски опытный web-developer тут же скажет – у вас цикл где-то заклинило ребятишки. И будет прав, что уж там.
Но прежде чем перейти к тем самым 42 строкам кода, я лишь напомню, что когда имеется приложение с кучей всяких вкусняшек внутри, то лучший способ организации коммуникации между ними – это внутренние события. И у нашего в момент сдачи проекта их было под сотню, а когда начались проблемы их число приросло еще на пару десятков.
И, как вы уже догадались, «клинило» как раз контроллер событий. На пальцах: событие A, вызывает событие B, а событие B – событие C, а оно, в свою очередь, вновь вызывает событие A. Та-да-м, встречайте цикл!
Наш обработчик событий был до безобразия простой и ютился в файлике на 44 строках кода. Однако он не умел делать весьма актуальную вещицу – проверять не в цикле ли он.
Много ~~пить~~ думать не пришлось и решение нашли довольно быстро. Хорошее оно или плохое – это все на ваш суд. Опишу лишь основную идею.
Единственный способ проверить «кто» вызвал цепочку событий (в нашем примере найти A, B и C) – это проверить stack. Чтобы получить stack нужно просто «выбросить» ошибку.
Остается проблема – как «пометить» место вызова события, ведь в стеке должно быть что-то, что помогло бы распознать всю цепочку ранее запущенных событий? Одно из решений этой проблемы – поименованные функции-обертки, в имени которых как раз и хранится вся информация о предыдущих событиях. Ничего не поняли? Я вот написал, перечитал и тоже не понял. Проще посмотреть [код](https://github.com/DmitryAstafyev/safeevents).
В общем теперь, если выполнить это (событие A вызывает B, B вызывает С, а C вновь вызывает A):
```
var safeevents = new SafeEvents();
safeevents.bind('A', function () {
safeevents.trigger('B');
});
safeevents.bind('B', function () {
safeevents.trigger('C');
});
safeevents.bind('C', function () {
safeevents.trigger('A');
});
safeevents.trigger('A');
```
То на этот раз приложение не уйдет в лимб, а выбросит в консоль исключение «Uncaught Error: Event [A] called itself. Full chain: A, B, C». Profit. Теперь разработчику не нужно уходить на три дополнительных перекура, чтобы сообразить в чем собственно дело – все видно из сообщения в консоли.
С асинхронными вызовами немного сложнее. Для них, увы, нужно выполнять дополнительное действие. Но оно настолько крохотное, что вряд ли будет большой проблемой.
```
var safeevents = new SafeEvents();
safeevents.bind('A', function () {
safeevents.trigger('B');
});
safeevents.bind('B', function () {
safeevents.trigger('C');
});
safeevents.bind('C', function () {
/*
* Use method "safely" to wrap your async methods and create safe callback.
*/
setTimeout(safeevents.safely(function () {
safeevents.trigger('A');
}), 10);
});
safeevents.trigger('A');
```
Обратите внимание на функцию обратного вызова в таймере. Мы добавляем «обертку», чтобы передать данные о предыдущих событиях в асинхронных вызовах. И вновь в консоли мы увидим: «Uncaught Error: Event [A] called itself. Full chain: A, B, C».
Конечно, не всегда нужно брать так и нагло выбрасывать исключение. Значительно лучше тихонечко ~~сообщить куда следует~~ записать данные в лог или отправить уведомление админу. Для чего можно поставить свой обработчик на случай «зацикливания» и получить все необходимые данные.
```
var safeevents = new SafeEvents();
safeevents.bind('A', function () {
safeevents.trigger('B');
});
safeevents.bind('B', function () {
safeevents.trigger('C');
});
safeevents.bind('C', function () {
safeevents.trigger('A');
});
safeevents.bind(safeevents.onloop, function (e, chain, last_event, stack) {
console.log('Error message: ' + e);
console.log('Full chain of events: ' + chain.join(', '));
console.log('Last event (generated loop): ' + last_event);
console.log('Error stack: ' + stack);
});
safeevents.trigger('A');
```
Теперь наше приложение вовсе не прерывается, но цикл при этом будет успешно предотвращен.
В общем переписав наш наипростейший обработчик событий и получив дополнительно 42 строки кода, мы решили весьма редкую, но довольно пакостную проблему с зацикливанием событий. Кто знает (я вот не знаю), может и вам оно пригодится. Все [тут](https://github.com/DmitryAstafyev/safeevents).
Счастья, добра и электричества в ваши дома. | https://habr.com/ru/post/313422/ | null | ru | null |
# Last.Backend открывает свои двери первым посетителям
Всем привет!
Праздники пролетели незаметно и пришла пора и поработать. А что бы работать вам было в радость, мы решили запустить Last.Backend в бету. Правда решили делать это не сразу а постепенно. Как нынче модно — идём путём agile со итерациями в 2 недели.
Итак, добро пожаловать в бету!
Прошло довольно много времени с момента первой статьи об этом проекте. И хотя большая часть этого времени пролетела в бесконечных выходных, работа нашей команды не останавливалась ни на день, о чем свидетельствует пиктограмма гитхаба. Так как для нас выход в бету является очень важным этапом в жизни проекта, то мы отнеслись к нему самым должным образом.
Как я упоминал ранее, мы разбиваем бету на 3 этапа. Данный этап — бета конструктора! Да, мы открываем вам наш конструктор, что бы вы могли уже начинать собирать ваш backend как можно быстрее. Следующим этапом будет сразу настройка с деплоем, но об этом чуть позже.
### Что же было сделано, что будет дальше?
Итак, по порядку: 4 недели — 4 основных улучшения системы.
Я опущу много маленьких улучшений, дабы сэкономить немного времени, приведу лишь значимые — полезные.
#### Процесс создания
Вы можете спросить при чем тут процесс, а ведь это очень важная часть. Ведь до анонса как было? Есть сервер, подняты там nginx, node, mongo… Сделал какую нибудь занятную вещицу, закоммитил, запушил, заапрувил пул реквест, обновил на севере — здорово! Сразу видно результат. Так обычно бывает в самом начале создания чего-либо. А ведь с выходом в бету, так больше не побаловаться. Да и на сервера желательно вообще не заходить. Поэтому сейчас всё по другому. В качестве системы управления серверами и их конфигурациями, мы используем ansible. С помощью него мы и деплоим релизы. Сам процесс выглядит следующим образом:
1. Есть список задач к определённой версии, к примеру к **α version**
2. Есть тестовый сервер с настроенным автодеплоем по ветке test
3. Как только задачи в версии закончены, делается релиз и его версия указывается в настройках ansible
4. Далее система сама всё обновляет
Довольно удобно и красиво, но потребовало определённых временных затрат. Итого: github + ansible наше всё.
#### Интерфейс
Наша команда придерживается следующего мнения:
> Должно не только работать! Должно быть красиво и удобно!
И это очень важно. Удобство при работе с системой должно быть интуитивным. По этому мы переработали панели со списком элементов, настроек. Переработали отрисовку всей схемы и само её построение. А получилось у нас или нет — оценивать вам.
#### Экспорт схемы в png
Да, это было не очень тривиально, но у нас получилось. SVG довольно просто сохранить в png. Но если используются css правила, а так же используются ссылки на изображения, тогда и начинаются все проблемы. К сожалению, на просторах интернета довольно скудная информация о том, как быть с картинками и стилями, но вот что мы для себя вывели:
**Порядок экспорта svg:**
1. Заменить все css классы на inline стили. Это можно сделать автоматически уже при экспорте.
2. Удалить всю анимацию
3. Используя замечательную библиотеку canvg — перегнать svg в canvas (даже с картинками)
4. Сохранить в любом нужном формате
```
// Что бы не по портить исходный объект - мы его клонируем
var svg = $("").append($("#svg").clone());
// Далее удаляем всю анимацию
var elements = $(svg).find('.animation_status').get();
for (var i = 0; i < elements.length; i++) {
elements[i].remove()
}
// Описываем функцию скачивания
function download(c) {
/// create an "off-screen" anchor tag
var lnk = document.getElementById('schema_img'),
e;
/// the key here is to set the download attribute of the a tag
lnk.download = ($scope.schema.title || $scope.schema.uuid) + '.png';
/// convert canvas content to data-uri for link. When download
/// attribute is set the content pointed to by link will be
/// pushed as "download" in HTML5 capable browsers
lnk.href = c.toDataURL("image/png;base64;");
/// create a "fake" click-event to trigger the download
if (document.createEvent) {
e = document.createEvent("MouseEvents");
e.initMouseEvent("click", true, true, window,
0, 0, 0, 0, 0, false, false, false,
false, 0, null);
lnk.dispatchEvent(e);
} else if (lnk.fireEvent) {
lnk.fireEvent("onclick");
}
return true;
}
// Получаем элемент canvas-а
var screen = document.getElementById('screen');
canvg('screen', svg.html(), {useCORS: true, ignoreAnimation: true, log: true, renderCallback: function () {
var image = screen.toDataURL("image/png");
var context = screen.getContext("2d");
context.globalCompositeOperation = "destination-over";
var img = new Image();
img.src = '/images/grid.png'; // Добавляем на фон сетку
img.onload = function () {
context.fillStyle = context.createPattern(img, 'repeat'); // Создаем паттерн и тип заполнения
context.fillRect(0, 0, screen.width, screen.height); // Устанавливаем ширину и высоту изображения
context.fillStyle = "#ffffff";
context.fillRect(0, 0, screen.width, screen.height);
download(screen); // Скачиваем
};
}});
}
```
Используйте на здоровье.
#### Наполнение системы
Вроде бы всё сделав для начала работы, мы поняли что большую схему то нам и не построить. Нет необходимых элементов. Так вот насобирав с просторов технологии, мы добавили самые основные в работе элементы:
###### Базы данных
###### Приложения
###### Планировщики
Мы прекрасно понимаем что это не финальный набор элементов, поэтому были бы вам признательны, если бы вы нам подсказали каких элементов вам не хватает. Для этого можно использовать комментарии, либо форму обратной связи на сайте.
### Теперь немного о планах
В ближайшие 2 недели нам предстоит открыть для вас деплой системы. Что бы у нас получилось это дело как можно продуктивнее, было бы здорово, если бы вы оставляли как можно больше полезных отзывов об использовании системой, через обратную связь. Это поможет нам не только учесть наши хотелки, но и понять что же необходимо вам.
#### Адреса, пароли и явки
Сайт наш остался там же: [lastbackend.com](http://lastbackend.com)
IDE конструктор находится по адресу: [ide.lastbackend.com](http://ide.lastbackend.com)
Доступ к регистрации имеют все пользователи, что подписались на открытую версию.
Пока доступ только через систему инвайтов. Со следующей беты планируем ввести нормальный.
Дополнительная информация будет указана в email рассылке.
Всем хорошей трудовой недели! Спасибо! | https://habr.com/ru/post/222477/ | null | ru | null |
# Очередные уязвимости нулевого дня в различных роутерах
Похоже, начало года не задалось для производителей роутеров. Буквально сегодня я сообщал о [критических уязвимостях в роутерах различных производителей](http://habrahabr.ru/post/168613/), связанных с небезопасной обработкой протокола UPnP. И вот ещё одна новость на эту же тему. На сей раз уязвимости совершенно разные. Затронуто оборудование:
* D-Link DIR-615, DIR-600 и DIR-300 (rev B)
* Netgear DGN1000B
* Cisco Linksys E1500/E2500
* Netgear SPH200D
Уязвимости довольно различны, но их объединяет несколько фактов: один автор и нежелание вендора выпускать патч (если верить автору).
**D'Link DIR-615**Утверждается что проблема в ревизии H1, прошивки версии 8.04 от 4 сентября 2012 и 8.04 от 18 января 2013. Правда, я не смог найти эти версии на [официальном сайте вендора](http://www.dlink.com/us/en/support/product/dir-615-wireless-n-300-router?revision=us_reve).
##### Выполнение произвольных команд ОС роутера
Авторизованный пользователь может выполнить произвольную команду на устройстве, отправив GET-запрос, в котором команды будут переданы в параметре ping\_ipaddr
Пример:
```
http:///tools\_vct.htm?page=tools\_vct&hping=0&ping\_ipaddr=1.1.1.1%60COMMAND%60&ping6\_ipaddr=
http:///tools\_vct.htm?page=tools\_vct&hping=0&ping\_ipaddr=1.1.1.1%60uname%20-a%60&ping6\_ipaddr=
```
ответ на команду приходит в теле HTTP-ответа:
```
HTTP/1.0 200 OK
Pragma: no-cache
Content-Type: text/html
``` | https://habr.com/ru/post/168683/ | null | ru | null |
# Пробел в знаниях основ веб-разработки
Вчера я разговаривал с другом, который ищет разработчика на открытую вакансию. Он выразил некоторое разочарование, которое я тоже испытываю в последнее время:
> У меня проблемы с поиском фронтенд-разработчика, в основном, по WP, Foundation, CSS, JS, на низкоуровневую позицию. Не могу понять, в чём дело. Ни у кого из кандидатов нет «базовых знаний» ничего из перечисленного. Но они могут делать сайты на React или других JS-фреймворках, или на базе WP-шаблонов. Но если я говорю, что нужно сделать простые изменения в CSS, смотрят пустыми глазами… Или какую-нибудь мелочь на чистом JS, ничего.
Нет недостатка в учебных лагерях, курсах, полно ресурсов для изучения фронтенд-разработки. Но я собеседовал кучу ребят из этих учебных лагерей и думаю, что там серьёзно недооценивают важность CSS и основ JavaScript.
Конечно, есть ограничения на то, сколько можно усвоить за 12 недель обучения. Но огромная часть проблемы в том, что наша индустрия восхищается новым, одержима самыми последними и прекрасными SPA-фреймворками, в то же время обесценив CSS и «старые» имплементации.
Восхищение новым
================
Наша индустрия восхищается новыми подходами к разработке. Чем ещё можно объяснить непрерывное стремление выбросить все наработки и «переделать с нуля» каждый раз, когда появляется новый, лучший и более сложный фреймворк? Каждый раз мы утверждаем, что это приведёт к более чистой, простой, идеально абстрагируемой архитектуре, и каждый раз всё заканчивается изобретением велосипедов, воссозданием багов и открытием заново всех пограничных ситуаций, которые снова приводят к такому же безобразному коду.
Это не означает, что никогда ничего не стоит переписывать или что новое никогда не бывает лучшим. Просто мы пали жертвами культа бесплатных вещичек и идеи идеальной абстракции. Каждая новая архитектура идеальна до тех пор, пока не сталкивается с жёсткими условиями реального мира. К сожалению, люди — довольно хаотичные существа, и весь наш софт создан для решения человеческих проблем. Поэтому каждая программа в реальном мире заканчивает дырявыми абстракциями, неуклюжими пограничными ситуациями и новыми компромиссами.
Эта гонка по бесконечной переделке и концентрации только на последнем и самом лучшем часто приводит к отказу от прежних решений тех проблем, которые в итоге появляются заново. Также она приводит к тому, что мы применяем новые инструменты в абсолютно неподходящих областях, просто потому что они новые.
### Одержимость самыми последними и прекрасными SPA-фреймворками
Публикуя список рассылки по фронтенд-разработке, я каждый день вижу эту проблему во время текущего бума SPA. Читаю огромное множество статей, где авторы пишут о разных технологиях, и поверьте, почти все в мире JavaScript пишут об одном или другом из этих фреймворков как будто это абсолютно новая и уникальная инновация. Хотя это отличные инструменты, но каждый из них создан для решения конкретной проблемы. Они основаны на схожем базисе и делают разный выбор в зависимости от задач, для которых оптимизированы.
Можно взять React для примера, потому что он так сильно продвигается в последние несколько лет…
Не поймите меня неправильно, я люблю React. Это феноменально мощный инструмент. Он делает не только возможным, но и простым создание интерфейсов, которые казались нереальными, когда я начинал веб-разработку. Однако новички в индустрии приходят и видят всю эту шумиху вокруг React и предполагают, что это единственная истина, как следует писать на JavaScript. Сделать новое веб-приложение? Используй React! Нестандартный шаблон для блога? React! Переделать старый сайт? Переходи на React!
Это катастрофический подход к использованию технологии! И не слушайте меня, послушайте одного из самых видных разработчиков в сообществе React, Дэна Абрамова! Когда Кори Хаус попросил высказаться о недостатках React, Дэн дал наиболее подробное описание:
> Its performance is worse than templates if many things update extremely fast at the same time. For example stock trading apps.
>
> — Dan Abramov (@dan\_abramov) [September 16, 2017](https://twitter.com/dan_abramov/status/909181242167431170?ref_src=twsrc%5Etfw)
> «Его производительность хуже шаблонов, если много вещей исключительно быстро обновляются одновременно. Например, приложения для биржевой торговли»
> It trades memory pressure for expressiveness. React apps typically do more short-lived allocations under heavy load.
>
> — Dan Abramov (@dan\_abramov) [September 16, 2017](https://twitter.com/dan_abramov/status/909181948844748800?ref_src=twsrc%5Etfw)
> «Ради выразительных возможностей языка приносится в жертву память. Приложения React обычно делают больше краткосрочных размещений в памяти под большой нагрузкой»
> It’s mostly driven by the needs of Facebook. So if your apps are very different from what FB is building, may not satisfy your use case.
>
> — Dan Abramov (@dan\_abramov) [September 16, 2017](https://twitter.com/dan_abramov/status/909185225288241152?ref_src=twsrc%5Etfw)
> «Он в основном спроектирован исходя из потребностей Facebook. Так что если ваши приложения сильно отличаются от того, что делает Facebook, то React может не подойти для ваших нужд»
Это только часть, но открытость Дэна подтолкнула Кори к ответу:
> Gotta say, I'm floored that the best input I've gotten on why "not\* to use React is from you Dan. Really admire such candor and nuance.
>
> — Cory House (@housecor) [September 17, 2017](https://twitter.com/housecor/status/909240876651745280?ref_src=twsrc%5Etfw)
> «Должен сказать, я поражён, что лучший список причин **не** использовать React пришёл именно от вас, Дэн. Действительно восхищаюсь столь откровенным и подробным ответом»
Очевидно, у Дэна нет иллюзий о том, что React идеален для всего; он хорошо знаком с компромиссами, на которые пошли разработчики! Но такая большая часть сообщества спешит перейти на SPA-фреймворки для всего подряд и полностью игнорируют факт, что эти инструменты решают конкретные области задач. Да, это феноменальные инструменты и огромное удовольствие с ними работать… но часто они абсолютно не подходят для решения задач в других областях.
Превознося фреймворки над всем остальным, мы не замечаем решений, которые гораздо более подходят для этих областей.
Обесценивание CSS
=================
В индустрии появилась тенденция унижать HTML и CSS как «не настоящую разработку» и нечто низшего уровня. Думаю, это идёт от того, что логику стали превозносить над графическим/пространственным мышлением… CSS и HTML воплощают иерархические, графические и пространственные отношения, в то время как JavaScript фокусируется в первую очередь на логике.
Но замечательная особенность логических языков/выражений состоит в том, что часто они могут *включать* другие типы отношений… что позволяет выражать пространственные отношения на логическом языке. Однако мы в индустрии часто неправильно интерпретируем такую большую широту возможного выражения как то, что выражение на этом языке строго превосходно.
**Это НЕ так!**
На самом деле, если посмотреть на примеры из математики и физики, то часто наоборот! В этих областях, если вы начинаете с логической модели, то часто отчаянно пытаетесь найти пространственную или графическую модель, которую можно здесь применить.
Причина в том, что эти пространственные модели зачастую раскрывают гораздо более интуитивные или лаконичные способы представления проблем — и они приводят к важным озарениям и выводам, которые мы затем кропотливо пытаемся перевести обратно в логическую форму.
CSS представляет невероятно мощный фреймворк для выражения графических и пространственных отношений, иногда исключительно сложных!
Сохранение сложности
====================
Это приводит меня к моему ключевому тезису о разработке ПО — **сохранение сложности**.
В любой решаемой проблеме есть некий присущий уровень сложности, и эта сложность должна быть где-то учтена.
Это всплывает во многих случаях, но в данном примере речь идёт о сложности выражения графических и пространственных отношений. Различные элементы на странице пространственно взаимосвязаны друг с другом *невероятно* сложным образом на разных уровнях, особенно с учётом манипуляций и перемещений этих элементов. Эта сложность должна быть где-то учтена, а в случае CSS браузер делает почти всю работу за вас!
Существует \*невероятно много\* кода JavaScript, написанного просто потому что разработчик недостаточно хорошо знает CSS.
> Truth. I worked on a project that had 2000 lines of JS to do what position: absolute already does because they didn't understand it
>
> — Sarah Drasner (@sarah\_edo) [September 16, 2017](https://twitter.com/sarah_edo/status/908995987598798849?ref_src=twsrc%5Etfw)
> «Это правда. Я работала над проектом, где 2000 строк JS делали то, что уже реализовано в `position: absolute`, просто потому что разработчики не понимали этого»
Что делать?
===========
Я не пытаюсь сказать, что нам не следует использовать или учить людей новейшим и самым лучшим инструментам. SPA-фреймворки вроде React, Angular, Vue и Ember позволяют создавать в вебе невероятно мощные интерфейсы, которые просто были невозможны всего несколько лет назад. Эти инструменты действительно изменили представление о том, что возможно сделать в онлайне.
Но я считаю, что следует искоренить элитизм SPA и вновь подчеркнуть важность фундаментальных знаний и выбора правильного инструментария.
Создатели этих фреймворков редко заявляют, что они хороши для всего подряд, но мы в индустрии настолько их возвысили, что новички полностью пропускают изучение базовых основ и предполагают, что только этот сложный инструментарий — единственный «правильный» способ решения их проблем.
Если все новые разработчики будут с презрением смотреть на CSS, то мы придём к тому, что 2000 строчек JavaScript будут пытаться заново реализовать `position: absolute;`.
Если все новые разработчики решат, что новый код HTML и JavaScript можно писать только через SPA, то мы придём к исключительно перепроектированным, глючным и тормозным блогам, маркетинговым сайтам и всему остальному, что сейчас хорошо реализовано на старых технологиях.
Нам следует серьёзно поговорить о том, какие навыки мы ожидаем от разработчиков в нашей отрасли и чему мы их обучаем. Вполне нормально начать обучение новичка в каком-нибудь учебном лагере, но есть серьёзный разрыв между современными выпускниками этих лагерей и тем, что требует индустрия. Может быть нереально ожидать соответствие этим требованиям после 8-12 недель обучения, но нужно хотя бы направить их по правильному пути.
### К учебному плану основ
Я не составлял учебник основ веб-разработки, но несколько вещей определённо включил бы туда. Они перечислены ниже со ссылками на бесплатные и платные ресурсы для более глубокого изучения, но что бы ВЫ включили в список? Напишите в комментариях.
### CSS
1. **Базовая блочная модель в CSS** (box model). Это главная из основ, которую вы ОБЯЗАНЫ понять. В качестве бесплатного ресурса можно порекомендовать [отличную статью](https://learn.shayhowe.com/html-css/opening-the-box-model/) Шея Хоу из его бесплатного курса [Learn to code HTML & CSS](https://learn.shayhowe.com/html-css/). С платной стороны, особенно если вы легче воспринимаете аудиовизуальный контент, у моего друга Джеймса Стоуна есть неплохой [видеокурс по блочной модели в CSS](https://www.jamesstone.com/products/box-model/).
2. **Специфичность CSS**. Это ещё одна важная основа, которую нужно понять, если собираетесь заняться веб-разработкой. Без прочного понимания специфичности вы непрерывно будете пытаться заставить свой код CSS работать так, как нужно. В Smashing Magazine есть [отличный обзор для начала](https://www.smashingmagazine.com/2007/07/css-specificity-things-you-should-know/).
3. **Flexbox**. Спецификации Flexbox произвели революцию в методах вёрстки, и вам непременно нужно воспользоваться преимуществами этой технологии. Лучший ресурс по Flexbox, который я видел, — [этот справочник от CSS Tricks](https://css-tricks.com/snippets/css/a-guide-to-flexbox/). Если ищете видеокурс по Flexbox, посмотрите [этот на Treehouse](https://treehouse.7eer.net/c/469710/228915/3944?u=https%3A%2F%2Fteamtreehouse.com%2Flibrary%2Fcss-flexbox-layout) или [этот на Udemy](https://www.udemy.com/flexbox-tutorial/).
4. **Сетка в CSS**. Хотя это новый стандарт и он не поддерживается старыми браузерами, но CSS Grid — исключительно мощная технология и определённо шаг вперёд в создании макетов. Среди отличных бесплатных ресурсов — [руководство по трюкам CSS](https://css-tricks.com/snippets/css/complete-guide-grid/) и [Сетка CSS на примерах](https://gridbyexample.com/) от Рэйчел Эндрю. С платной стороны, Рэйчел Эндрю — гуру, и определённо стоит [посмотреть её курс](https://thecssworkshop.com/), а если ищете менее дорогой вариант, то [Treehouse предлагает хороший вводный курс](https://treehouse.7eer.net/c/469710/228915/3944?u=https%3A%2F%2Fteamtreehouse.com%2Flibrary%2Fcss-grid-layout).
5. **Базовая архитектура CSS**. Это по-настоящему глубокая тема, и я не хочу слишком в неё углубляться, но для начала я бы прочитал бесплатную [книгу SMACSS](https://smacss.com/book/). Она даст отличное понимание некоторых фундаментальных принципов организации CSS и концепций — оттуда можно перейти к другим подходам и конвенциям вроде [BEM](http://getbem.com/introduction/), [ITCSS](https://www.xfive.co/blog/itcss-scalable-maintainable-css-architecture/) и т.д.
### JavaScript
1. **Типы и приведения типов**. В JavaScript странные типы. Всё сводится к этому. Они обеспечивают как бы «слабую типизацию» и довольно причудливое поведение. Если хотите углубиться в JavaScript, то их нужно понять. Лучший ресурс, который мне встречался — это первые четыре главы «[Вы не знаете JS: типы и грамматика](https://github.com/getify/You-Dont-Know-JS/tree/master/types%20%26%20grammar)».
2. **Контексты и `this`**. Понять `this` фундаментально важно для более глубокого понимания, что происходит в коде JavaScript. Непонимание `this` — причина путаницы № 1 у начинающих программистов JavaScript, частично потому что многие библиотеки используют и злоупотребляют ею (я смотрю на тебя, jQuery!). Для создания фундамента в понимании рекомендую великолепную статью Зелла «[*Это* в JavaScript](https://zellwk.com/blog/this/)».
3. **Замыкания**. Замыкания откроют вам все типы концепций и покажут, почему практически одинаковый код настолько разно работает, и вы начнёте понемногу представлять функции как объекты первого класса. Вот хорошо написанное введение от Free Code Camp: «[Изучим замыкания в JavaScript](https://medium.freecodecamp.org/lets-learn-javascript-closures-66feb44f6a44)».
4. **События и цикл событий**. Модель цикла событий отличает JavaScript от многих других парадигм программирования, и без хорошего понимания у вас могут быть серьёзные неприятности, когда впервые начнёте работать с нетривиальными взаимодействиями между асинхронными событиями. Я не нашёл ресурс, который был бы мне абсолютно по душе на эту тему (дайте знать, если вам известен такой), но эта статья Carbon Five неплоха: «[Объяснение цикла событий JavaScript](https://blog.carbonfive.com/2013/10/27/the-javascript-event-loop-explained/)». | https://habr.com/ru/post/341626/ | null | ru | null |
# ExtJS 7 и Spring Boot 2. Как построить SPA, взаимодействующее с вашим API и внешними ReactJS плагинами?
Последние версии Ext JS, особенно Modern Toolkit снизили порог вхождения во фреймворк (примеры Kitchen Sink), упростили создание нужного интерфейса (привет Sencha Architect) и добились минимального размера веб-приложений (Sencha Cmd).
Пожалуй, Хабр нужно разбавить примером реализации «ситуационного центра», где в реальном времени можно наблюдать камеры и события с них (все данные фейковые).
Начнем. Создадим Spring Boot проект с 2 контроллерами, которые будут отдавать список камер, существующие события, а также возможность подписки на новые события (через WebSocket).
Далее добавим необходимые модели, хранилища, вьюшки и внешние зависимости:
**Более детально вьюшка карты, взаимодействующая с React компонентом карты.**
```
Ext.define('Cameras.view.override.Map', {
override: 'Cameras.view.Map',
config: {
cameras: {},
react: null
},
initialize: function() {
let that = this;
let e = React.createElement;
this.setReact(ReactDOM.render(e(createReactClass({
getInitialState: function() {
return { items: [], center: [55.751574, 37.573856]};
},
render: function() {
let placemarks = [];
for(let i=0; i < this.state.items.length; i++) {
let location = this.state.items[i].get("location");
placemarks.push(e(window.ReactYandexMaps.Placemark, {
geometry: [location.latitude, location.longitude],
options: {
preset: 'islands#blueCircleDotIconWithCaption',
iconCaptionMaxWidth: '50'
}
}));
}
let map = e(window.ReactYandexMaps.Map, {
state: { center: this.state.center, zoom: 10 },
width: '100%',
height: '100%'
}, placemarks);
return e(window.ReactYandexMaps.YMaps, null, map);
}
})), this.mapContainer.dom));
},
getElementConfig: function() {
return {
reference: 'element',
className: 'x-container',
children: [{
reference: 'bodyElement',
style: 'width: 100%; height: 100%',
className: 'x-inner',
children: [{
style: 'width: 100%; height: 100%',
reference: 'mapContainer',
className: Ext.baseCSSPrefix + 'map-container'
}]
}]
};
},
addCamera: function(cameraModel) {
if(!this.containsCamera(cameraModel)) {
this.getCameras()[cameraModel.get("id")] = cameraModel;
this.getReact().setState({
items: Object.values(this.getCameras())
});
this.fitCamera(cameraModel);
}
},
removeCamera: function(cameraModel) {
if(this.containsCamera(cameraModel)) {
delete this.getCameras()[cameraModel.get("id")];
this.getReact().setState({
items: Object.values(this.getCameras())
});
}
},
fitCamera: function(cameraModel) {
if(this.containsCamera(cameraModel)) {
let location = this.getCameras()[cameraModel.get("id")].get("location");
this.getReact().setState({
center: [location.latitude, location.longitude]
});
}
},
privates: {
containsCamera: function(cameraModel) {
cameraId = "" + cameraModel.get("id");
return Object.keys(this.getCameras()).includes(cameraId);
}
}
});
```
Также условимся, что события будут исходить от компонента CamerasGrid, т.к. именно этот компонент отвечает за добавление/удаление камер с карты.
**Контроллер компонента CamerasGrid, добавляющий компоненту генерацию событий**
```
Ext.define('Cameras.view.CamerasGridViewController', {
extend: 'Ext.app.ViewController',
alias: 'controller.camerasgrid',
init: function() {
let socket = new WebSocket("ws://localhost:8080/events/sub");
socket.onopen = function(e) {
console.log('onopen');
};
socket.onmessage = this.onMessage.bind(this);
},
onMessage: function(event) {
let data = Ext.decode(event.data);
let gridData = this.getView().getStore().getData();
for(let i=0; i < gridData.length; i++) {
let checked = gridData.getAt(i).get("checked");
if(checked !== undefined && checked) {
if(gridData.getAt(i).get("id") == data.camera.id) {
this.fireViewEvent("cameraRecognition", data);
}
}
}
}
});
```
В итоге получается довольно занятный интерфейс. Замечу, что при правильном проектировании архитектуры приложения (даже такого маленького), время на создание оного совсем невелико, до пары часов.
Код примера доступен на [github.com](https://github.com/lampaa/SituationCenter). | https://habr.com/ru/post/479676/ | null | ru | null |
# Исследуем активность кибергруппировки Donot Team
APT-группа Donot Team (также известная как APT-C-35, SectorE02) активна по крайней мере с 2012 года. Интерес злоумышленников направлен на получение конфиденциальной информации и интеллектуальной собственности. Среди целей преступников — страны Южной Азии, в частности государственный сектор Пакистана. В 2019 году мы наблюдаем их деятельность в Бангладеш, Таиланде, Индии, на Шри-Ланке и Филиппинах, а также за пределами азиатского региона — в Аргентине, ОАЭ, Великобритании.
В течение нескольких месяцев мы следили за изменениями в коде вредоносных загрузчиков группы. В этой статье мы рассмотрим один из векторов атак, подробнее остановимся на упомянутых загрузчиках и коснемся особенностей сетевой инфраструктуры.
Цепочка атаки
-------------
В начале заражения жертва получает документ MS Word в формате Office Open XML. Несмотря на отсутствие явных подтверждений, мы с уверенностью полагаем, что изначальный вектор проникновения — целенаправленное фишинговое письмо с офисным вложением. Документ сам по себе не является вредоносным, но злоупотребляет возможностью автозагрузки внешних элементов для запуска документа следующей стадии.
*Обращение к связанному внешнему объекту*
Загружаемый файл представляет собой RTF-документ, эксплуатирующий уязвимость CVE-2018-0802 в Microsoft Equation. Работе основного шеллкода предшествует цепочка промежуточных, расшифровывающих следующий слой однобайтовым XOR с ключами 0x90 и 0xCE:
*Расшифровка первым шеллкодом второго*
*Расшифровка вторым шеллкодом третьего*
*Расшифровка третьим шеллкодом основного*
Основной шеллкод выполняет следующие действия:
* Однобайтовым XOR с ключом 0x79 расшифровывает бинарные данные из файла **%TEMP%\one**.
* Создает исполняемые файлы **C:\Windows\Tasks\Serviceflow.exe** и **C:\Windows\Tasks\sinter.exe**. Это вредоносные загрузчики группы, о которых мы еще поговорим.
* Создает файл **C:\Windows\Tasks\S\_An.dll**, в котором записаны два байта 0x90.
* Создает файл **C:\Windows\Tasks\A64.dll**. В зависимости от разрядности системы это модифицированная x64- или x86-версия утилиты [UACMe](https://github.com/hfiref0x/UACME) для повышения привилегий в системе. Помимо обхода контроля UAC библиотека создает и запускает BAT-сценарий **%TEMP%\v.bat**, который зарегистрирует один из созданных ранее загрузчиков как службу при помощи следующих команд:
```
sc create ServiceTool displayname= "ServiceFill" binpath= "C:\Windows\Tasks\Serviceflow.exe" start= "auto"
sc start ServiceTool
```
*Расшифровка строк BAT-сценария в модифицированных библиотеках UACMe*
* Создает и запускает JScript-сценарий **C:\Windows\Tasks\bin.js**. Его задача — запустить библиотеку **A64.dll** через экспорт **RnMod** средствами rundll32.
* Создает ярлык **WORDICON.lnk** в каталоге автозагрузки. Его задача — запустить загрузчик **sinter.exe** после перезагрузки системы.
* Создает ярлык **Support.lnk** в каталоге автозагрузки. Его задача — запустить JScript-сценарий **bin.js** после перезагрузки системы.
*Декомпилированный код основного шеллкода*
Таким образом, на данном этапе в системе надежно закреплены два загрузчика, о работе которых мы поговорим подробнее.
Загрузчики Lo2
--------------
Несмотря на классификацию, задачи у троянов различаются. Так, файл **Serviceflow.exe** выполняет сторожевую роль (watchdog). Он собирает информацию о системе:
* имя пользователя,
* имя компьютера,
* содержимое каталогов \Program Files\ и \Program Files (x86)\,
* версию ОС,
* данные о процессоре —
и записывает результаты в файл log.txt. Проверяет существование файлов **A64.dll** и **sinter.exe** в каталоге \Windows\Tasks\ и в случае необходимости догружает их с управляющего сервера skillsnew[.]top и запускает от имени текущего пользователя, извлекая соответствующий токен из процесса winlogon.exe. Троян **sinter.exe** сигнализирует атакующим о заражении обращением к `hxxps://mystrylust.pw/confirm.php` и отправляет предварительно собранную информацию о системе по адресу skillsnew[.]top. Затем, если компьютер жертвы представляет дальнейший интерес, получает содержимое файла customer.txt по адресу `hxxp://docs.google.com/uc?id=1wUaESzjGT2fSuP_hOJMpqidyzqwu15sz&export=download`. В файле содержится имя управляющего сервера car[.]drivethrough.top, с которым происходит дальнейшее взаимодействие. Загружаемые компоненты располагаются в каталоге \AppData\Roaming\InStore\, а их запуск обеспечивается с помощью планировщика задач.
*Расшифрованные строки фрагментов команд и шаблона задачи*
Результат работы вредоносных загрузчиков — встраивание в систему компонентов фреймворка [yty](https://attack.mitre.org/software/S0248/), которые позволяют извлекать более полную информацию о жертве, включая файлы с заданными расширениями, перехваченные строки ввода, список процессов, скриншоты. Мы оставим рассмотрение работы плагинов за рамками этой статьи.
Исследуя другие аналогичные образцы, мы обнаружили оставленные пути и имена проектов в отладочной информации:
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\New\_Single\_File\Lo2\SingleV2\Release\BinWork.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\New\_Single\_File\Lo2
\SingleV2\_Task\_Layout\_NewICON\Release\BinWork.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\New\_Single\_File\Lo2
\SingleV2\_Task\_Layout\_NewICON\_N\_Lnk\Release\BinWork.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\New\_Single\_File\Lo2\SingleV3\Release\WorkFile.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\Off\Off\_New\_Api\Release\C++\ConnectLink.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\Off\Off\_New\_Api\Release\C++\TerBin.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\m0\yty 2.0 *-* With AES Chunks LOC FOR XP Just Bit-Change\_Name\Release\TaskTool.pdb
* D:\Soft\DevelopedCode\_Last\BitDefenderTest\yty 2.0 *-* With AES Chunks OFFS Just Bit\Release\C++\MsBuild.pdb
* D:\Soft\DevelopedCode\_Last\yty 2.0\Release\C++\Setup.pdb
Кроме подстроки «yty 2.0», связывающей трояны с вышеупомянутым фреймворком, мы отметили подстроку «Lo2», которая может быть сокращением «Loader 2».
В версиях загрузчиков до середины 2018 года все используемые строки хранились в файле в открытом виде. В следующих сборках злоумышленники стали использовать шифрование строк. От версии к версии алгоритм менялся следующим образом:
* С мая 2018 года: перевернуть строку и закодировать Base64.
* С апреля 2019 года: выполнить предыдущие действия дважды.
* С января 2019 года: зашифровать строку алгоритмом AES в режиме CBC и закодировать Base64. Пример кода на Python для расшифровки:
```
import base64
from Cryptodome.Cipher import AES
aeskey = (0x23, 0xd4, 0x67, 0xad, 0x96, 0xc3, 0xd1, 0xa5, 0x23, 0x76, 0xae, 0x4e, 0xdd, 0xca, 0x13, 0x55)
def aes_decrypt(data, aeskey):
iv = bytes(list(range(0, 16)))
key = bytes(aeskey)
aes = AES.new(key, AES.MODE_CBC, iv)
return aes.decrypt(data).decode().strip('\x00')
def base64_aes_decrypt(data, aeskey):
data = base64.b64decode(data)
data = aes_decrypt(data, aeskey)
return data
```
* С июня 2019 года: выполнить посимвольное цикличное вычитание с заданным массивом байтов, закодировать с помощью UTF-8 и закодировать Base64. Пример кода на Python для расшифровки:
```
subgamma = (0x2d, 0x55, 0xf, 0x59, 0xf, 0xb, 0x60, 0x33, 0x29, 0x4e, 0x19, 0x3e, 0x57, 0x4d, 0x56, 0xf)
def sub_decrypt(data, subgamma):
o = ''
length = len(data)
subgamma_length = len(subgamma)
for i in range(length):
o += chr((0x100 + ord(data[i]) - subgamma[i%subgamma_length]) & 0xff)
return o
def base64_utf8_sub_decrypt(data, subgamma):
data = base64.b64decode(data)
data = data.decode('utf-8')
data = sub_decrypt(data, subgamma)
return data
```
* С октября 2019 года: выполнить посимвольный цикличный модифицированный XOR с заданным массивом байтов и закодировать Base64 дважды. Особенность алгоритма XOR в том, что если значение символа строки совпадает со значением символа в заданном массиве байтов — XOR выполнять не нужно. Пример кода на Python для расшифровки:
```
xorgamma = (0x56, 0x2d, 0x61, 0x21, 0x16)
def modxor_decrypt(data, xorgamma):
o = ''
length = len(data)
xorgamma_length = len(xorgamma)
for i in range(length):
c = data[i]
if c != xorgamma[i%xorgamma_length]:
c = data[i] ^ xorgamma[i%xorgamma_length]
o += chr(c)
return o
def base64_modxor_decrypt(data, xorgamma):
data = base64.b64decode(data)
data = modxor_decrypt(data, xorgamma)
return data
```
В процессе написания скрипта для расшифровки мы обнаружили, что некоторые отдельные строки расшифровать не удается. Но затем оказывалось, что для таких строк подходит какой-либо из других описанных выше способов расшифровки. Убедившись, что в каждом образце реализован лишь один способ декодирования данных, мы пришли к выводу, что злоумышленники попросту забывали удалить неиспользуемые строки или заменить их на правильно зашифрованные для следующей версии вредоноса.
*Строки в одном из образцов загрузчика были зашифрованы различными способами, в то время как в исполняемом файле реализован лишь один*
Такие ошибки всегда на руку исследователям: например, неоднократно среди забытых строк попадались контрольные серверы злоумышленников, ранее нам неизвестные.
Особенности сетевой инфраструктуры
----------------------------------
Для полноты картины отметим некоторые характерные черты, которые помогут связать между собой будущие атаки группировки:
* Бóльшая часть управляющих серверов арендована у провайдера DigitalOcean, LLC (ASN 14061) и расположена в Амстердаме.
* Атакующие не используют одни и те же серверы для разных DNS-имен: для каждого нового доменного имени предпочитают резервировать новый выделенный хост.
* В большинстве случаев регистрационные данные владельцев доменов скрыты услугами приватности. Для этого используются следующие сервисы: WhoisGuard, Inc.; Whois Privacy Protection Service, Inc.; Domains By Proxy, LLC; Whois Privacy Protection Foundation. В некоторых случаях данные доступны, и можно проследить общий подход к заполнению полей.
*WHOIS-информация о домене burningforests[.]com*
*WHOIS-информация о домене cloud-storage-service[.]com*
* Используются преимущественно .top, .pw, .space, .live и .icu TLD.
Заключение
----------
Donot Team отличается использованием своих собственных инструментов на каждой стадии атаки. Применяемые техники для усложнения анализа кода — с одной стороны, отсутствие попыток тщательно скрыть или замаскировать свои действия в системе — с другой. [Многократные](https://www.netscout.com/blog/asert/donot-team-leverages-new-modular-malware-framework-south-asia) [атаки](https://threatrecon.nshc.net/2019/08/02/sectore02-updates-yty-framework-in-new-targeted-campaign-against-pakistan-government/) на одни и те же цели могут не только свидетельствовать об особом интересе к выбранному кругу жертв, но и подтверждать невысокую эффективность используемых тактик и техник.
**Автор**: Алексей Вишняков, Positive Technologies
**IOCs**6ce1855cf027d76463bb8d5954fcc7bb — загрузчик в формате MS Word
hxxp://plug.msplugin.icu/MicrosoftSecurityScan/DOCSDOC
21b7fc61448af8938c09007871486f58 — дроппер в формате MS Word
71ab0946b6a72622aef6cdd7907479ec — загрузчик Lo2 в C:\Windows\Tasks\Serviceflow.exe
22f41b6238290913fc4d196b8423724d — загрузчик Lo2 в C:\Windows\Tasks\sinter.exe
330a4678fae2662975e850200081a1b1 — x86-модифицированная версия UACMe
22e7ef7c3c7911b4c08ce82fde76ec72 — x64-модифицированная версия UACMe
skillsnew[.]top
hxxps://mystrylust.pw/confirm.php
hxxp://docs.google.com/uc?id=1wUaESzjGT2fSuP\_hOJMpqidyzqwu15sz&export=download
car[.]drivethrough.top
burningforests[.]com
cloud-storage-service[.]com | https://habr.com/ru/post/476740/ | null | ru | null |
# Автоматическая проверка орфографии в EXCEL
Доброе время суток Хаброжители.
Буквально на днях, ко мне и моим коллегам обратились «опытные пользователи» Excel. По специфике работы «опытные пользователи» часто используют офисный пакет для оформления документации. Как ни странно, таблицы Excel так же часто встречаются. Как и на Хабре, не допустимо выпускать документы с орфографическими ошибками. Стандартной возможности excel, по подсветке орфографических ошибок нет. В связи с этим я разработал Add-ins для Excel который бы реализовывал такой функционал.
Проверить наличие ошибок не так и сложно, есть стандартный SpellCheck, которым я и воспользовался. Реализовывать предполагается 2 части:
1) проверка уже заполненных ячеек
2) проверка в реальном времени при вводе.
Сама логики работы простая, В первом случае проверяем все ячейки, если есть ошибка, выделяем лексемы и проверяем каждую лексему отдельно, для ошибочных лексем, создаем примечание и выделяем ошибочную лексему красным цветом. Во втором случае просто подписываемся на событие изменения ячейки и делаем все как в 1 случае только с меньшим диапазоном.
Приступим:
Запускаем VisualStudio, создаем расширение для Excel 2007.
При регистрации плагина, подпишемся на событие Cell-Changed и вызовем нашу функцию (функция будет описана чуть позже).
```
private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
//Подпишемся на событие изменения ячейки
Globals.ThisAddIn.Application.Cells.Worksheet.Change += new Excel.DocEvents_ChangeEventHandler(Worksheet_Change);
}
void Worksheet_Change(Excel.Range Target)
{
SpellCheck.SpellChecker(Target);
}
```
Больше при регистрации ничего делать не будем. Проверку всей книги оставим пользователю по вызову.
Создаем свою вкладку в Ribbon. Добавляем новый Item Ribbon (Visual Designer)/
Создадим новую вкладку, первую не трогаем, т.к. она зарезервирована.
Так же, добавим 2 кнопки проверки: проверка всей книги, и проверку текущего листа.
Пропишем в событиях кнопок следующий код
**Для всей книги**
```
private void OrfoCheckAll_Click(object sender, RibbonControlEventArgs e)
{
var excel = Globals.ThisAddIn.Application;
var wss = excel.Worksheets;
var app = excel.Application;
foreach (var ws in wss)
{
var sheet = ws as Excel.Worksheet;
if (sheet != null)
{
var range = sheet.UsedRange;
foreach (var cll in range)
{
var cell = cll as Excel.Range;
SpellCheck.SpellChecker(cell);
}
}
}
}
```
**Для листа**
```
private void OrfoCheckCurrentSheet_Click(object sender, RibbonControlEventArgs e)
{
var excel = Globals.ThisAddIn.Application;
var app = excel.Application;
var sheet = app.ActiveSheet as Excel.Worksheet;
if (sheet != null)
{
var range = sheet.UsedRange;
foreach (var cll in range)
{
var cell = cll as Excel.Range;
SpellCheck.SpellChecker(cell);
}
}
}
```
Ну и самое главное, создадим статичный класс SpellCheck в котором и опишем нашу функцию проверки
```
public static class SpellCheck
{
public static void SpellChecker(Excel.Range Target)
{
var app = Globals.ThisAddIn.Application.Application;
string str = Target.Text.ToString();
if (app.CheckSpelling(str, Type.Missing, true) == false)
{
foreach (string tmp in ((string)str).Split(' '))
{
if (app.CheckSpelling(tmp, Type.Missing, Type.Missing) == false)
{
if (Target.Comment == null)
{
Target.AddComment("Ошибка в слове " + tmp);
Target.Characters[str.IndexOf(tmp) + 1, tmp.Length].Font.ColorIndex = 3;
}
else
{
Excel.Characters c = Target.Comment.Shape.TextFrame.Characters(Type.Missing, Type.Missing);
if (!c.Caption.Contains(tmp))
{
c.Caption = c.Caption + " " + tmp;
}
Target.Characters[str.IndexOf(tmp) + 1, tmp.Length].Font.ColorIndex = 3;
}
}
else
{
Target.Characters[str.IndexOf(tmp) + 1, tmp.Length].Font.ColorIndex = 0;
}
}
}
else
{
if (Target.Comment != null)
{
if (Target.Comment.Shape.AlternativeText.Contains("Ошибка в слове "))
{
Target.Characters[str.IndexOf(str), str.Length].Font.ColorIndex = 0;
Target.Comment.Delete();
}
}
}
}
```
После компиляции и загрузки плагина проверяем работу
Это всё чего не хватало Excel для автоматической проверки.
Как всегда, если у вас есть более интересные методы реализации, делитесь опытом
UPD: По просьбам хаброжителей, выложил готовый Плагин [тут](http://depositfiles.com/files/ejg37ip3n) | https://habr.com/ru/post/136520/ | null | ru | null |
# Мега-Учебник Flask, Часть XIX: Развертывание на основе Docker-контейнеров
(издание 2018)
--------------
### *Miguel Grinberg*
---
 [Туда](https://habrahabr.ru/post/352830/) [Сюда](https://habrahabr.ru/post/353804/) 
Это девятнадцатая часть серии мега-учебника Flask, в которой я собираюсь развернуть Microblog на платформе Docker.
Под спойлером приведен список всех статей этой серии 2018 года.
**Оглавление*** [**Глава 1: Привет, мир!**](https://habrahabr.ru/post/346306/)
* [**Глава 2: Шаблоны**](https://habrahabr.ru/post/346340/)
* [**Глава 3: Веб-формы**](https://habrahabr.ru/post/346342/)
* [**Глава 4: База данных**](https://habrahabr.ru/post/346344/)
* [**Глава 5: Пользовательские логины**](https://habrahabr.ru/post/346346/)
* [**Глава 6: Страница профиля и аватары**](https://habrahabr.ru/post/346348/)
* [**Глава 7: Обработка ошибок**](https://habrahabr.ru/post/346880/)
* [**Глава 8: Подписчики, контакты и друзья**](https://habrahabr.ru/post/347450/)
* [**Глава 9: Разбивка на страницы**](https://habrahabr.ru/post/347926/)
* [**Глава 10: Поддержка электронной почты**](https://habrahabr.ru/post/348566/)
* [**Глава 11: Реконструкция**](https://habrahabr.ru/post/349060/)
* [**Глава 12: Дата и время**](https://habrahabr.ru/post/349604/)
* [**Глава 13: I18n и L10n**](https://habrahabr.ru/post/350148/)
* [**Глава 14: Ajax**](https://habrahabr.ru/post/350626/)
* [**Глава 15: Улучшение структуры приложения**](https://habrahabr.ru/post/351218/)
* [**Глава 16: Полнотекстовый поиск**](https://habrahabr.ru/post/351900/)
* [**Глава 17: Развертывание в Linux**](https://habrahabr.ru/post/352266/)
* [**Глава 18: Развертывание на Heroku**](https://habrahabr.ru/post/352830/)
* [**Глава 19: Развертывание на Docker контейнерах**](https://habrahabr.ru/post/353234/)(Эта статья)
* [**Глава 20: Магия JavaScript**](https://habrahabr.ru/post/353804/)
* [**Глава 21: Уведомления пользователей**](https://habrahabr.ru/post/354322/)
* [**Глава 22: Фоновые задачи**](https://habrahabr.ru/post/354752/)
* [**Глава 23: Интерфейсы прикладного программирования (API)**](https://habr.com/ru/post/358152/)
*Примечание 1: Если вы ищете старые версии данного курса, это [здесь](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world-legacy "здесь").*
*Примечание 2: Если вдруг Вы захотели бы выступить в поддержку моей(Мигеля) работы, или просто не имеете терпения дожидаться статьи неделю, я (Мигель Гринберг)предлагаю полную версию данного руководства(на английском языке) в виде электронной книги или видео. Для получения более подробной информации посетите [learn.miguelgrinberg.com](http://learn.miguelgrinberg.com "learn.miguelgrinberg.com").*
В [главе 17](https://habrahabr.ru/post/352266/) Вы узнали о традиционных развертывании, в котором следует заботиться о каждом маленьком аспекте конфигурации сервера. После чего в [главе 18](https://habrahabr.ru/topic/edit/352830/) я привел вас к другой крайности, когда познакомил Вас с Heroku, сервисом, который полностью контролирует задачи настройки и развертывания. В этой главе пришло время узнать о стратегии развертывания сторонних приложений на основе контейнеров, в частности на платформе контейнеров [Docker](https://www.docker.com/). Этот третий вариант — "золотая середина", между двумя другими.
Контейнеры построены на основе упрощенной технологии виртуализации, которая позволяет приложению вместе с его зависимостями и конфигурацией работать в полной изоляции, но без необходимости использования полнофункционального решения виртуализации, такого как виртуальные машины, которые нуждаются в значительно большем объеме ресурсов и могут иногда иметь значительное снижение производительности по сравнению с хостом. Система, настроенная в качестве узла контейнера, может выполнять множество контейнеров, все из которых делят ядро хоста и имеют прямой доступ к оборудованию хоста. Это в отличие от виртуальных машин, которые должны эмулировать полную систему, включая процессор, диск, другое оборудование, ядро и т.д.
Несмотря на то, что мы не разделяем ядро, уровень изоляции в контейнере довольно высок. Контейнер имеет свою собственную файловую систему и может основываться на операционной системе, отличной от той, которая используется узлом контейнера. Например, можно запускать контейнеры на основе Ubuntu Linux на узле Fedora или наоборот. Не смотря на то, что контейнеры являются технологией, которая является родной для операционной системы Linux, благодаря виртуализации можно запускать Linux контейнеры на Windows и Mac OS X хостах. Это позволяет тестировать развертывания в системе разработки, а также включать контейнеры в рабочий процесс разработки, если только оно вам надо.
*Ссылки GitHub для этой главы:* [Browse](https://github.com/miguelgrinberg/microblog/tree/v0.19), [Zip](https://github.com/miguelgrinberg/microblog/archive/v0.19.zip), [Diff](https://github.com/miguelgrinberg/microblog/compare/v0.18...v0.19).
Установка Docker CE
-------------------
Хотя Docker не единственная контейнерная Платформа, она на сегодняшний день является самой популярной, так что это будет мой выбор. Существует два выпуска Docker, выпуск Free community edition (CE) и выпуск Enterprise edition (EE) на основе подписки. Для целей этого учебника Docker CE вполне адекватен.
Чтобы работать с Docker CE, вам сначала нужно установить его в свою систему. Есть инсталляторы для Windows, Mac OS X и нескольких дистрибутивов Linux, доступных на [веб-сайте Docker](https://www.docker.com/community-edition). Если вы работаете в системе Microsoft Windows, важно отметить, что Docker CE требует Hyper-V. Установщик включит это для вас, если это необходимо, но имейте в виду, что включение Hyper-V предотвращает работу других технологий виртуализации, таких как VirtualBox.
После установки Docker CE в системе проверить успешность установки можно, введя следующую команду в окне терминала или командной строке:
```
$ docker version
Client:
Version: 17.09.0-ce
API version: 1.32
Go version: go1.8.3
Git commit: afdb6d4
Built: Tue Sep 26 22:40:09 2017
OS/Arch: darwin/amd64
Server:
Version: 17.09.0-ce
API version: 1.32 (minimum version 1.12)
Go version: go1.8.3
Git commit: afdb6d4
Built: Tue Sep 26 22:45:38 2017
OS/Arch: linux/amd64
Experimental: true
```
Построение образа контейнера
----------------------------
Первым шагом в создании контейнера для микроблога является создание для него *образа*. Образ контейнера — это шаблон, который используется для создания контейнера. Он содержит полное представление файловой системы контейнера, а также различные настройки, относящиеся к сети, запуск вариантов и т.д.
Самый простой способ создать образ контейнера для приложения-запустить контейнер для базовой операционной системы, которую вы хотите использовать (Ubuntu, Fedora и т. д.).), подключитесь к запущенному в нем процессу оболочки bash, а затем вручную установите приложение, возможно, следуя рекомендациям, которые я представил в [главе 17](https://habrahabr.ru/post/352266/) для традиционного развертывания. После установки всего можно сделать снимок контейнера, который станет образом. Этот тип рабочего процесса поддерживается командой `docker`, но я не собираюсь обсуждать его, потому что не удобно вручную устанавливать приложение каждый раз, когда вам нужно создать новый образ.
Лучшим подходом является создание образа контейнера с помощью сценария. Команда, создающая образы контейнеров со сценариями, — это `docker build`. Эта команда считывает и выполняет инструкции сборки из файла *Dockerfile*, который мне ещё предстоит создать. Dockerfile-это фактически сценарий установки, который выполняет шаги установки для развертывания приложения, а также некоторые параметры контейнера.
Вот базовый *Dockerfile* для Микроблога:
> Dockerfile: Dockerfile for Microblog.
```
FROM python:3.6-alpine
RUN adduser -D microblog
WORKDIR /home/microblog
COPY requirements.txt requirements.txt
RUN python -m venv venv
RUN venv/bin/pip install -r requirements.txt
RUN venv/bin/pip install gunicorn
COPY app app
COPY migrations migrations
COPY microblog.py config.py boot.sh ./
RUN chmod +x boot.sh
ENV FLASK_APP microblog.py
RUN chown -R microblog:microblog ./
USER microblog
EXPOSE 5000
ENTRYPOINT ["./boot.sh"]
```
Каждая строка в Dockerfile является командой. Команда `FROM` указывает базовый образ контейнера, на основе которого будет построен новый образ. Идея состоит в том, что вы начинаете с существующего образа, добавляете или изменяете некоторые особенности, и в конечном итоге получаете производный образ. На образ ссылаются именем и тегом, разделенными двоеточием. Тег используется в качестве механизма управления версиями, позволяя образу контейнера предоставлять несколько вариантов. Имя выбранного образа-`python`, который является официальным образом Docker для Python. Теги для этого образа позволяют указать версию интерпретатора и базовую операционную систему. Тег `3.6-alpine` выбирает интерпретатор Python 3.6, установленный в Alpine Linux. Дистрибутив Alpine Linux часто используется вместо более популярных, таких как Ubuntu из-за его небольшого размера. Вы можете увидеть, какие теги доступны для образа Python в [Python image repository](https://hub.docker.com/r/library/python/tags/).
Команда `RUN` выполняет произвольную команду в контексте контейнера. Это похоже на ввод команды в командной строке оболочки. Команда `adduser-D microblog` создает нового пользователя с именем `microblog`. Большинство образов контейнеров имеют `root` в качестве пользователя по умолчанию, однако не рекомендуется запускать приложение от имени root, поэтому я создаю собственного пользователя.
Команда `WORKDIR` задает каталог по умолчанию, в котором будет установлено приложение. Когда я создал пользователя `microblog` выше, был создан домашний каталог, поэтому теперь я делаю этот каталог по умолчанию. Новый каталог по умолчанию будет применяться ко всем оставшимся командам в Dockerfile, а также позже при выполнении контейнера.
Команда `COPY` передает файлы с компьютера в файловую систему контейнера. Эта команда принимает два или более аргументов, исходный и конечный файлы или каталоги. Исходный файл(ы) должен быть относительно каталога, в котором находится Dockerfile. Назначение может быть абсолютным путем или путем относительно каталога, заданного в предыдущей команде `WORKDIR`. В этой первой команде копирования я копирую файл *requirements.txt* в домашний каталог пользователя `microblog` в файловой системе контейнера.
Теперь у меня есть файл *requirements.txt* в контейнере и я могу создать виртуальную среду, используя команду `RUN`. Сначала я создаю его, а затем устанавливаю все требования. Поскольку файл требований содержит только общие зависимости, я затем явно устанавливаю *gunicorn*, который я собираюсь использовать в качестве веб-сервера. В качестве альтернативы, я мог бы добавить *gunicorn* к моим файлам в *requirements.txt*.
Три команды `COPY`, которые следуют за установкой приложения в контейнер, копируя пакет *app*, каталог *migrations* с миграциями базы данных и скрипты *microblog.py* и *config.py* из каталога верхнего уровня. Кроме того, я копирую новый файл *boot.sh*, о котором я расскажу ниже.
Команда `RUN chmod` гарантирует, что этот неизвестный доселе файл *boot.sh* установлен правильно, как исполняемый файл. Если вы находитесь в файловой системе на основе Unix, и ваш исходный файл уже имеет признак исполняемого файла, то в скопированном файле также будет установлен исполняемый бит. Я добавил явную установку, потому что в Windows сложнее присвоить исполняемые биты. Если вы работаете в Mac OS X или Linux, вероятно это все не нужно, но не помешает в любом случае.
Команда `ENV` задает переменную среды внутри контейнера. Мне нужно установить `FLASK_APP`, который необходим для использования команды `flask`.
Следующая команда `RUN chown` задает владельца всех каталогов и файлов, которые были сохранены в */home/microblog*, как нового пользователя `microblog`. Несмотря на то, что я создал этого пользователя в корне Dockerfile, Пользователь по умолчанию для всех команд остался `root`, поэтому все эти файлы должны быть переключены на пользователя `microblog`, чтобы этот пользователь мог работать с ними при запуске контейнера.
Команда `USER` в следующей строке делает этого нового пользователя `microblog` по умолчанию для любых последующих инструкций, а также при запуске контейнера.
Команда `EXPOSE` настраивает порт для своего сервера. Это необходимо, чтобы Docker мог нужным образом настроить Сеть в контейнере. Я выбрал стандартный порт 5000, но это может быть любой порт.
Наконец, команда `ENTRYPOINT` определяет умолчание, для команды которая должна выполняться при запуске контейнера. Это команда, которая запустит веб-сервер приложений. Чтобы все было хорошо организовано, я решил создать для этого отдельный скрипт, и это *boot.sh* файл, который я скопировал в контейнер ранее. Вот содержимое этого скрипта:
> boot.sh: Docker container start-up script.
```
#!/bin/sh
source venv/bin/activate
flask db upgrade
flask translate compile
exec gunicorn -b :5000 --access-logfile - --error-logfile - microblog:app
```
Это довольно стандартный сценарий запуска, который довольно похож на то, как были запущены развертывания в [главе 17](https://habrahabr.ru/post/352266/) и [главе 18](https://habrahabr.ru/topic/edit/352830/). Я активирую виртуальную среду, Обновляю базу данных через платформу миграции, компилирую переводы языков и, наконец, запускаю сервер с *gunicorn*.
Обратите внимание на `exec`, который предшествует команде gunicorn. В сценарии оболочки `exec` запускает процесс, выполняющий сценарий, который должен быть заменен заданной командой, вместо того, чтобы запускать его как новый процесс. Это важно, потому что Docker связывает жизнь контейнера с первым процессом, который выполняется на нем. В случаях, подобных этому, когда процесс запуска не является основным процессом контейнера, необходимо убедиться, что основной процесс занимает место этого первого процесса, чтобы убедиться, что контейнер не завершается рано Docker.
Интересным аспектом Docker является то, что все выводимые данные контейнера, которые пишутся в `stdout` или `stderr`, будут захвачены и сохранены как журналы контейнера. По этой причине ключи `--access-logfile` и `--error-logfile` имеют в конце символ `-`, который направляет журнал в стандартный вывод и хранит в виде журнала Docker.
С помощью созданного Dockerfile теперь можно создать образ контейнера:
```
$ docker build -t microblog:latest .
```
Аргумент `-t`, передаваемый команде `docker build`, задает имя и тег для нового образа контейнера. `.` указывает базовый каталог, в котором должен быть создан контейнер. Это каталог, в котором находится файл Docker. Процесс сборки будет оценивать все команды в файле Docker и создавать образ, который будет храниться на вашей собственной машине.
Вы можете получить список образов, которые вы локально используете с помощью команды `docker images`:
```
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
microblog latest 54a47d0c27cf About a minute ago 216MB
python 3.6-alpine a6beab4fa70b 3 months ago 88.7MB
```
Этот список включает ваш новый образ, а также базовый, на котором он был построен. При внесении изменений в приложение можно обновить образ контейнера, выполнив команду build еще раз.
Запуск контейнера
-----------------
С уже созданным образом теперь можно запустить версию контейнера приложения. Это делается с помощью команды `docker run`, которая обычно принимает большое количество аргументов. Для начала я покажу вам простой пример:
```
$ docker run --name microblog -d -p 8000:5000 --rm microblog:latest
021da2e1e0d390320248abf97dfbbe7b27c70fefed113d5a41bb67a68522e91c
```
Параметр `--name` предоставляет имя для нового контейнера. Параметр `-d` указывает Docker запускать контейнер в фоновом режиме. Без ключа `-d` контейнер выполняется как приложение переднего плана, блокируя командную строку. Параметр `-p` сопоставляет порты контейнера с портами хоста. Первый порт-это порт на хост-компьютере, а порт справа-это порт внутри контейнера. Приведенный выше пример предоставляет порт 5000 в контейнере на порту 8000 в узле, таким образом, вы будете обращаться к приложению на 8000, даже при том, что внутренне контейнер использует 5000. Параметр `--rm` удаляет контейнер после его завершения. Хотя это не требуется, контейнеры, которые заканчиваются или прерываются, обычно больше не нужны, поэтому их можно автоматически удалить. Последним аргументом является имя образа контейнера и тег, используемый для контейнера. После выполнения приведенной выше команды, вы можете получить доступ к приложению на *<http://localhost:8000>*.
Результатом `docker run` является идентификатор (ID), назначенный новому контейнеру. Это длинная шестнадцатеричная строка, которую вы можете использовать, когда вам нужно ссылаться на контейнер в последующих командах. Фактически, только первые несколько символов необходимы, чтобы сделать идентификатор уникальным.
Если вы хотите увидеть, какие контейнеры запущены, вы можете использовать команду `docker ps`:
```
$ docker ps
CONTAINER ID IMAGE COMMAND PORTS NAMES
021da2e1e0d3 microblog:latest "./boot.sh" 0.0.0.0:8000->5000/tcp microblog
```
Как видите, даже команда `docker ps` сокращает идентификаторы контейнеров. Если теперь необходимо остановить контейнер, используйте `docker stop`:
```
$ docker stop 021da2e1e0d3
021da2e1e0d3
```
Напомню вам что, в конфигурации приложения есть несколько параметров, которые получены из переменных среды. Например, параметры секретного ключа Flask, URL базы данных и сервера электронной почты импортируются из переменных среды. В примере `docker run` выше я не беспокоился о них, поэтому все эти параметры конфигурации будут использовать значения по умолчанию.
В более реалистичном примере эти переменные среды будут устанавливаться внутри контейнера. Вы видели в предыдущем разделе, что установку переменных среды в *Dockerfile* выполняет команда `ENV`, и это удобная опция для переменных, которые будут статическими. Тем не менее, для переменных, зависящих от установки, не представляется возможным использовать их как часть процесса сборки, потому что хотелось бы иметь образ контейнера, который легко переносить. Если вы хотите передать свое приложение другому пользователю в качестве образа контейнера, вы хотите, чтобы этот человек мог использовать его как есть, а не перестраивать его с помощью других переменных.
Таким образом, переменные среды build-time могут быть полезны, но также необходимо иметь переменные среды run-time, которые можно задать с помощью команды `docker run`, и для этих переменных используется ключ `-e`. Следующий пример задает secret-key и электронную почту для аккаунта Gmail:
```
$ docker run --name microblog -d -p 8000:5000 --rm -e SECRET_KEY=my-secret-key \
-e MAIL_SERVER=smtp.googlemail.com -e MAIL_PORT=587 -e MAIL_USE_TLS=true \
-e MAIL_USERNAME= -e MAIL\_PASSWORD= \
microblog:latest
```
Такая длина для `docker run` в командной строке не редкость из-за наличия множества определений переменных среды.
Использование сторонних «Контейнерных» сервисов
-----------------------------------------------
Контейнерная версия Microblog выглядит неплохо, но я пока еще не очень много думал о хранении. Проблема в том, что я не задал переменную среды `DATABASE_URL`, и приложение использует базу данных SQLite по умолчанию, которая поддерживается файлом на диске. Как вы думаете, что произойдет с этим SQLite-файлом, когда вы остановите и удалите контейнер? Файл исчезнет!
Файловая система в контейнере является эфемерной, то есть она исчезает вместе с остановкой контейнера. Вы можете записывать данные в файловую систему, и данные будут доступны, если контейнер должен ее прочитать, но если по какой-либо причине вам нужно переработать контейнер и заменить его новым, любые данные, сохраненные приложением на диск будет потеряны навсегда.
Хорошей стратегией проектирования для приложения-контейнера является создание контейнеров приложения не зависящих от состояния (*stateless*). Если у вас есть контейнер, который имеет код приложения и не имеет данных, вы можете выбросить его и заменить новым без каких-либо проблем, контейнер становится действительно одноразовым, что является большим достижением с точки зрения упрощения развертывания обновлений.
Но, конечно, это означает, что данные должны быть помещены где-то за пределами контейнера приложения. Именно здесь вступает в игру фантастическая экосистема Docker. Реестр контейнеров Docker содержит большое разнообразие образов контейнеров. Я уже рассказал вам об образе контейнера Python, который я использую в качестве базового образа для своего контейнера Микроблога. Кроме того, Docker поддерживает образы для многих других языков, баз данных и других служб в реестре Docker, и если этого недостаточно, реестр также позволяет компаниям публиковать образы контейнеров для своих продуктов, а также обычным пользователям, таким как вы или я, публиковать свои собственные образы. Это означает, что усилия по установке сторонних служб сводятся к поиску соответствующего образа в реестре и запуску его с помощью команды `docker run` с соответствующими аргументами.
Итак, теперь я создам два дополнительных контейнера: один для базы данных MySQL и еще один для службы Elasticsearch, а затем я выполню длиннющую командную строку, которая запустит контейнер Microblog с кучей параметров, которые разрешат мне доступ к этим двум новым контейнерам.
Добавление контейнера MySQL
---------------------------
Как и многие другие продукты и услуги, MySQL имеет общедоступные образы контейнеров, доступные в реестре Docker. Как и мой собственный контейнер Микроблог, MySQL полагается на переменные среды, которые должны быть переданы в `docker run`. Это настройки типа пароля, имени базы данных и т.д. Не смотря на то, что есть много образов MySQL в реестре, я решил использовать тот, который официально поддерживается командой MySQL. Вы можете найти подробную информацию об образе контейнера MySQL на его странице реестра: *<https://hub.docker.com/r/mysql/mysql-server/>*.
Если вы помните трудоемкий процесс настройки MySQL в [главе 17](https://habrahabr.ru/post/352266/), то вы оцените Docker, увидев, как легко развернуть MySQL. Вот команда `docker run`, которая запускает сервер MySQL:
```
$ docker run --name mysql -d -e MYSQL_RANDOM_ROOT_PASSWORD=yes \
-e MYSQL_DATABASE=microblog -e MYSQL_USER=microblog \
-e MYSQL_PASSWORD= \
mysql/mysql-server:5.7
```
Вот и все! На любой машине, на которой установлен Docker, вы можете выполнить приведенную выше команду и получить полностью установленный сервер MySQL со случайно сгенерированным паролем root, совершенно новую базу данных под названием `microblog` и пользователя с тем же именем и настройками полного доступа к базе данных. Обратите внимание, что вам нужно будет ввести правильный пароль в качестве значения для переменной среды `MYSQL_PASSWORD`.
Теперь на стороне приложения, как и для традиционного развертывания на Ubuntu, мне нужно добавить клиентский пакет MySQL. Я снова буду использовать `pymysql`, который я могу добавить в *Dockerfile*:
> Dockerfile: Add pymysql to Dockerfile.
```
# ...
RUN venv/bin/pip install gunicorn pymysql
# ...
```
При каждом изменении приложения или файла Dockerfile образ контейнера необходимо перестроить:
```
$ docker build -t microblog:latest .
```
Теперь я могу снова запустить Microblog, но на этот раз со ссылкой на контейнер базы данных, чтобы обе могли общаться через сеть:
```
$ docker run --name microblog -d -p 8000:5000 --rm -e SECRET_KEY=my-secret-key \
-e MAIL_SERVER=smtp.googlemail.com -e MAIL_PORT=587 -e MAIL_USE_TLS=true \
-e MAIL_USERNAME= -e MAIL\_PASSWORD= \
--link mysql:dbserver \
-e DATABASE\_URL=mysql+pymysql://microblog:@dbserver/microblog \
microblog:latest
```
Параметр `--link` указывает Docker сделать еще один контейнер доступным. Аргумент содержит два имени, разделенных двоеточием. Первая часть-это имя или идентификатор контейнера для связи, в данном случае `mysql`, который я создал выше. Вторая часть определяет имя хоста, которое может использоваться в этом контейнере для ссылок (link-ов). Здесь я использую `dbserver` в качестве универсального имени, которое представляет сервер баз данных.
Когда связь между двумя контейнерами установлена, я могу установить переменную окружения `DATABASE_URL`, для направления SQLAlchemy на использование базы данных MySQL в другом контейнере. URL-адрес базы данных будет использовать `dbserver`-в качестве имени хоста базы данных, `microblog`-как имена базы данных и пользователя, и `пароль`-который вы выбрали при запуске MySQL.
Я заметил одну особенность, когда экспериментировал с контейнером MySQL, которая заключается в том, что запуск этого контейнера занимает несколько секунд до готовности принять соединения с базой данных. Если вы запустите подряд контейнер MySQL и контейнер приложения сразу после попытки скрипта *boot.sh* запустить `flask db migrate` может произойти сбой из-за того, что база данных не готова принимать подключения. Чтобы сделать мое решение более надежным, я решил добавить цикл повтора в *boot.sh*:
> *boot.sh*: Повтор попыток подключения к базе данных.
```
#!/bin/sh
source venv/bin/activate
while true; do
flask db upgrade
if [[ "$?" == "0" ]]; then
break
fi
echo Upgrade command failed, retrying in 5 secs...
sleep 5
done
flask translate compile
exec gunicorn -b :5000 --access-logfile - --error-logfile - microblog:app
```
Этот цикл проверки кода выхода команды `flask db upgrade`, и если он не равен нулю, значит, что что-то пошло не так, поэтому он делает паузу пять секунд, а затем повторяет попытку.
Добавление контейнера Elasticsearch
-----------------------------------
В документации [Elasticsearch для Docker](https://www.elastic.co/guide/en/elasticsearch/reference/current/docker.html) представлен вариант запуска службы единым узлом для разработки и развертывания, готовый к работе с двумя узлами (two-node). Сейчас я собираюсь запустить docker с опцией single-node и использовать образ "oss", который имеет только движок с открытым исходным кодом. Контейнер запускается следующей командой:
```
$ docker run --name elasticsearch -d -p 9200:9200 -p 9300:9300 --rm \
-e "discovery.type=single-node" \
docker.elastic.co/elasticsearch/elasticsearch-oss:6.1.1
```
Эта команда `docker run` имеет много общего с теми, которые я использовал для Microblog и MySQL, но есть несколько интересных различий. Во-первых, здесь два варианта `-p`, а это означает, что этот контейнер будет прослушивать два порта вместо одного. Оба порта 9200 и 9300 сопоставляются с теми же портами на хост-компьютере.
Следующее различие заключается в синтаксисе ссылки на образ контейнера. Для образов, которые я создавал локально, синтаксис был `:`. Контейнер MySQL использует несколько более полный синтаксис с форматом `/:`, который подходит для ссылки на образы контейнеров в реестре Docker. Образ Elasticsearch, который я использую, соответствует шаблону `/:`, который включает ещё и адрес реестра в качестве первого компонента. Этот синтаксис используется для образов, не размещенных в реестре Docker. В этом случае Elasticsearch запускает собственную службу реестра контейнеров в *docker.elastic.co* вместо использования основного реестра, поддерживаемого Docker.
Теперь, когда у меня работает служба Elasticsearch, я могу изменить команду запуска для моего контейнера Microblog, чтобы создать ссылку на неё и установить URL службы Elasticsearch:
```
$ docker run --name microblog -d -p 8000:5000 --rm -e SECRET_KEY=my-secret-key \
-e MAIL_SERVER=smtp.googlemail.com -e MAIL_PORT=587 -e MAIL_USE_TLS=true \
-e MAIL_USERNAME= -e MAIL\_PASSWORD= \
--link mysql:dbserver \
-e DATABASE\_URL=mysql+pymysql://microblog:@dbserver/microblog \
--link elasticsearch:elasticsearch \
-e ELASTICSEARCH\_URL=http://elasticsearch:9200 \
microblog:latest
```
Перед выполнением этой команды не забудьте остановить предыдущий контейнер Микроблога, если он все еще запущен. И, пожалуйста, будьте внимательны при настройке правильных паролей для базы данных и службы Elasticsearch в соответствующих местах команды.
Теперь у вас должна появиться возможность посетить *<http://localhost:8000>* и использовать функцию поиска. При возникновении ошибок их можно устранить, просмотрев журналы контейнеров. Скорее всего, вы захотите увидеть журналы для контейнера микроблога, где будут отображаться любые трассировки стека Python:
```
$ docker logs microblog
```
Реестр контейнеров Docker
-------------------------
Итак, теперь у меня есть полное приложение, работающее на Docker, используя три контейнера, два из которых общедоступные сторонние образы. Если вы хотите сделать свои собственные образы контейнеров доступными для других пользователей, то вы должны отправить их в реестр Docker, откуда любой может их заполучить.
Чтобы получить доступ к реестру Docker, перейдите по ссылке *<https://hub.docker.com>* и создайте учетную запись для себя. Убедитесь, что вы выбираете имя пользователя, которое вам нравится, потому что это будет использоваться во всех образах, которые вы публикуете.
Для доступа к учетной записи из командной строки необходимо войти в систему с помощью команды `docker login`:
```
$ docker login
```
Если вы следовали моим инструкциям, теперь у вас есть образ под названием `microblog:latest`, хранящийся локально на вашем компьютере. Чтобы быть в состоянии добавить этот образ к реестру Docker, он должен быть переименован, чтобы использовать учетную запись, как образ от MySQL. Это делается с помощью команды `docker tag`:
```
$ docker tag microblog:latest /microblog:latest
```
Если вы снова заглянете в реестр образов с помощью `docker images`, вы не найдете там две нужные записи для Микроблога, исходную с именем `microblog:latest` и новую, которая также включает имя Вашей учетной записи. Это два псевдонима для одного и того же образа.
Чтобы опубликовать образ в реестре Docker, используйте команду `docker push`:
```
$ docker push /microblog:latest
```
Теперь ваш образ является общедоступным, и вам следует добавить документацию, как его установить и запустить из реестра Docker так же, как это делают MySQL и другие.
Развертывание контейнерных приложений
-------------------------------------
Одна из лучших особенностей работы приложения в контейнерах Docker заключается в том, что после локального тестирования контейнеров их можно перенести на любую платформу, предлагающую поддержку Docker. Например, вы можете использовать те же серверы, которые я рекомендовал в [главе 17](https://habrahabr.ru/post/352266/) из Digital Ocean, Linode или Amazon Lightsail. Даже самое дешевое предложение от этих поставщиков достаточно для запуска Docker с несколькими контейнерами.
[Amazon Container Service (ECS)](https://aws.amazon.com/ecs/) позволяет создать кластер узлов контейнеров, на которых будут работать контейнеры, в полностью интегрированной среде AWS с поддержкой масштабирования и балансировки нагрузки, а также использовать частный реестр контейнеров для образов контейнеров.
Наконец, платформа для комбинирования контейнеров, такая как [Kubernetes](https://kubernetes.io/), обеспечивает еще больший уровень автоматизации и удобства, позволяя вам описывать развертывания нескольких контейнеров в простых текстовых файлах в формате YAML с балансировкой нагрузки, масштабированием, управлением безопасности и последовательными обновлениями с возможностью отката в исходное состояние.
 [Туда](https://habrahabr.ru/post/352830/) [Сюда](https://habrahabr.ru/post/353804/)  | https://habr.com/ru/post/353234/ | null | ru | null |
# Визуализация данных Московской Биржи с помощью InterSystems DeepSee
Введение
--------
В стеке технологий InterSystems есть технология для разработки аналитических решений [DeepSee](http://www.intersystems.com/ru/our-products/embedded-technologies/deepsee/). Это встраиваемая аналитическая технология и набор инструментов для создания систем поддержки принятия эффективных решений, в том числе, и с применением прогнозных моделей. DeepSee работает со структурированными и неструктурированными данными. Она предназначена для создания OLAP-решений для баз данных Caché и любых реляционных СУБД. InterSystems DeepSee предоставляет разработчикам средства для внедрения в свои приложения аналитической OLAP-функциональности, которая способна работать на оперативных базах данных приложений без создания отдельной инфраструктуры для решения аналитических задач.
В статье рассматривается пример создания в OLAP-куба, работа со средствами аналитики и построение пользовательского интерфейса на примере анализа котировок акций торгуемых на Московской Бирже.
Этапы
-----
* Получение данных
* ETL
* Построение куба
* Построение сводной таблицы
* Построение дашборда
* Визуализация
Получение данных
----------------
Для визуализации данных о котировках акций необходимо их сначала загрузить. У Московской Биржи есть публичное задокументированное [API](http://www.moex.com/a2193), которое предоставляет информацию о торговле акциями в форматах HTML, XML, JSON, CSV.
Вот, к примеру, [XML данные](http://iss.moex.com/iss/history/engines/stock/markets/shares/boards/tqbr/securities.xml?date=2013-05-27) за 27 мая 2013 года. Создадим [XML-Enabled](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GXML_import) класс `Ticker.Data` в платформе InterSystems:
**Ticker.Data**
```
Class Ticker.Data Extends (%Persistent, %XML.Adaptor)
{
/// Дата торгов
Property Date As %Date(FORMAT = 3, XMLNAME = "TRADEDATE", XMLPROJECTION = "attribute");
/// Краткое название компании
Property Name As %String(XMLNAME = "SHORTNAME", XMLPROJECTION = "attribute");
/// Тикер
Property Ticker As %String(XMLNAME = "SECID", XMLPROJECTION = "attribute");
/// Количество сделок
Property Trades As %Integer(XMLNAME = "NUMTRADES", XMLPROJECTION = "attribute");
/// Общая сумма сделок
Property Value As %Decimal(XMLNAME = "VALUE", XMLPROJECTION = "attribute");
/// Цена открытия
Property Open As %Decimal(XMLNAME = "OPEN", XMLPROJECTION = "attribute");
/// Цена закрытия
Property Close As %Decimal(XMLNAME = "CLOSE", XMLPROJECTION = "attribute");
/// Цена закрытия официальная
Property CloseLegal As %Decimal(XMLNAME = "LEGALCLOSEPRICE", XMLPROJECTION = "attribute");
/// Минимальная цена акции
Property Low As %Decimal(XMLNAME = "LOW", XMLPROJECTION = "attribute");
/// Максимальная цена акции
Property High As %Decimal(XMLNAME = "HIGH", XMLPROJECTION = "attribute");
/// Средневзвешенная цена акции http://www.moex.com/s1194
/// Может считаться как за день так и не за период.
Property Average As %Decimal(XMLNAME = "WAPRICE", XMLPROJECTION = "attribute");
/// Количество акций участвовавших в сделках
Property Volume As %Integer(XMLNAME = "VOLUME", XMLPROJECTION = "attribute");
}
```
И напишем загрузчик данных в формате XML. Так как класс у нас XML-Enabled то конвертация из XML в объекты класса Ticker.Data происходит автоматически. Аналогичного поведения можно достичь для данных в форматах JSON (через [динамические объекты](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GJSON_create)) и CSV (используя [%SQL.Util.Procedures](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SQL.Util.Procedures#METHOD_CSVTOCLASS)). Так как API отдаёт данные за определённую дату (день) то нам надо итерировать по дням и сохранять поступающие данные. Кроме того данные о котировках акций приходят страницами по 100 записей. Загрузчик может выглядеть так:
**Загрузчик данных**
```
/// Загрузить информацию об акциях начиная с From и заканчивая To. Purge - удалить все записи перед началом загрузки
/// Формат From, To - YYYY-MM-DD
/// Write $System.Status.GetErrorText(##class(Ticker.Loader).Populate())
ClassMethod Populate(From As %Date(DISPLAY=3) = "2013-03-25", To As %Date(DISPLAY=3) = {$ZDate($Horolog,3)}, Purge As %Boolean = {$$$YES})
{
#Dim Status As %Status = $$$OK
// Переводим даты во внутренний формат для простоты итерации
Set FromH = $ZDateH(From, 3)
Set ToH = $ZDateH(To, 3)
Do:Purge ..Purge()
For DateH = FromH:1:ToH {
Write $c(13), "Populating ", $ZDate(DateH, 3)
Set Status = ..PopulateDay(DateH)
Quit:$$$ISERR(Status)
}
Quit Status
}
/// Загрузить данные за день. Данные загружаются страницами по 100 записей.
/// Write $System.Status.GetErrorText(##class(Ticker.Loader).PopulateDay($Horolog))
ClassMethod PopulateDay(DateH As %Date) As %Status
{
#Dim Status As %Status = $$$OK
Set Reader = ##class(%XML.Reader).%New()
Set Date = $ZDate(DateH, 3) // Преобразовать дату из внутреннего формата в YYYY-MM-DD
Set Count = 0 // Число загруженных записей
While Count '= $G(CountOld) {
Set CountOld = Count
Set Status = Reader.OpenURL(..GetURL(Date, Count)) // Получаем следующую страницу данных
Quit:$$$ISERR(Status)
// Устанавливаем соответствие нода row == объект класса Ticker.Data
Do Reader.Correlate("row", "Ticker.Data")
// Десериализуем каждую ноду row в объект класса Ticker.Data
While Reader.Next(.Object, .Status) {
#Dim Object As Ticker.Data
// Сохраняем объект
If Object.Ticker '="" {
Set Status = Object.%Save()
Quit:$$$ISERR(Status)
Set Count = Count + 1
}
}
Quit:(Count-CountOld)<100 // На текущей странице меньше 100 записей => эта страница - последняя
}
Quit Status
}
/// Получить URL с информацией о котировках акций за дату Date, пропустить первые Start записей
ClassMethod GetURL(Date, Start As %Integer = 0) [ CodeMode = expression ]
{
$$$FormatText("http://iss.moex.com/iss/history/engines/stock/markets/shares/boards/tqbr/securities.xml?date=%1&start=%2", Date, Start)
}
```
Теперь загрузим данные командой: `Write $System.Status.GetErrorText(##class(Ticker.Loader).Populate())`
Весь код доступен в [репозитории](https://github.com/intersystems-ru/Ticker/).
ETL
---
Как известно, для построения OLAP-куба в первую очередь необходимо сформировать [таблицу фактов](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D1%84%D0%B0%D0%BA%D1%82%D0%BE%D0%B2): таблицу операций, записи которой требуется группировать и фильтровать. Таблица фактов может быть связана с другими таблицами по схеме [звезда](https://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%B7%D0%B2%D0%B5%D0%B7%D0%B4%D1%8B) или [снежинка](https://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D1%81%D0%BD%D0%B5%D0%B6%D0%B8%D0%BD%D0%BA%D0%B8).
Таблица фактов для куба обычно является результатом работы аналитиков и разработчиков по процессу, который называется [ETL](https://ru.wikipedia.org/wiki/ETL) (extract, transform, load). Т.е. из данных предметной области делается “выжимка” необходимых для анализа данных, и переносится в удобную для хранилища структуру "звезда"/"снежинка": факты и справочники фактов.
В нашем случае этап ETL пропустим т.к. наш класс `Ticker.Data` уже находятся во вполне удобном для создания куба состоянии.
Построение куба
---------------
[DeepSee Architect](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2DT_ch_cube) — это веб-приложение для создания OLAP-куба. Для перехода к DeepSee Architect откроем Портал Управления Системой → DeepSee → Выбор области → Architect. Открывается рабочее окно Архитектора.
Возможно нужно будет выбрать область, которая поддерживает DeepSee. В том случае если вы не видите вашей области в списке областей DeepSee перейдите в Портал Управления Системой → Меню → Управление веб-приложениями → /csp/область, и там в поле Включен поставьте галочку DeepSee и нажмите кнопку сохранить. После этого выбранная область должна появиться в списке областей DeepSee.
### Создаем новый куб.
Нажав на кнопку "Создать" попадаем на экран создания нового куба, там необходимо установить следующие параметры:
* Имя куба — название куба используемое в запросах к нему
* Отображаемое Имя — локализуемое название куба (перевод осуществляется [стандартными механизмами](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2IMP_ch_localization) InterSystems)
* Источник Cube — использовать таблицу фактов или другой куб в качестве источника данных
* Исходный класс — если на предыдущем шаге был выбран класс, то указываем в качестве таблицы фактов класс Ticker.Data.
* Имя класса для куба — имя класса, в котором будет храниться определение куба. Создаётся автоматически
* Описание класса — произвольное описание
Вот как выглядит наш новый куб:
### Определяем свойства куба
После нажатия кнопки OK будет создан новый куб:
Слева выводятся свойства базового и связанных с ним по “снежинке” классов, которые можно использовать при построении куба.
Центральная часть экрана — это скелет куба. Его можно наполнить свойствами класса с помощью drag-n-drop из области базового класса, либо добавляя элементы вручную. Основными элементами куба являются измерения, показатели и списки.
#### Измерения (Dimensions)
[Измерения](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2MODEL_ch_concepts) — это элементы куба, которые группируют записи таблицы фактов. В измерения обычно относят “качественные” атрибуты базового класса, которые разбивают все записи таблицы фактов по тем или иным срезам. Например нам бы хотелось группировать все факты по названиям инструментов и по датам.
Для разбиения фактов по тикерам прекрасно подойдет свойство Ticker. Перетянем Ticker на область измерений — в результате Архитектор добавит в куб измерение Ticker с одной иерархией H1 и одним уровнем Ticker. Укажем отображаемые названия в подписях к измерению и уровню.
Измерения помимо группировки позволяют строить иерархии вложенности фактов от общего к частному. Типичным примером является измерение по дате, которое обычно часто требуется представить в виде иерархии Год-Месяц-День.
Для свойств типа дата (например как у свойства Date тип %Date) в DeepSee есть специальный тип измерения time, в котором уже предусмотрены часто используемые функции для создания иерархий по дате. Воспользуемся этим и построим трехуровневую иерархию Год-месяц-день с помощью свойства Date.
Заметим, что в измерении есть элементы: собственно измерение, иерархия и уровни этой иерархии (Level). Любое измерение куба состоит как минимум из одной иерархии в котором в простейшем случае всего один уровень.
#### Показатели (Measures)
[Показатели](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2MODEL_ch_concepts#D2MODEL_concepts_measure) или метрики это такие элементы куба, куда относят какие-либо "количественные" данные, которые необходимо посчитать для "качественных" измерений куба (Dimensions).
Например в таблице фактов такими показателями могут быть свойства Volume (количество акций) и Average (Средняя цена). Перетянем свойство Volume на область показателей и создадим показатель "Количество" с функцией SUM, которая будет считать общее количество акций в текущем срезе.
Добавим также в показатели свойство Average и укажем в качестве функции расчета MAX — расчет максимального значения. С целью использования цены для визуализации изменения максимальной цены акции во времени.
#### Списки (Listings)
[Списки](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2MODEL_ch_concepts#D2MODEL_concepts_listing) — это элементы куба, описывающие способ доступа к исходным данным куба, позволяя перейти от агрегированных к исходным данным куба. Как правило при работе с кубом, аналитик просматривает агрегированную информацию в различных срезах. Однако, часто возникает необходимость посмотреть на исходные факты, которые вошли в текущий срез. Для этого и создаются листинги — они перечисляют набор полей таблицы фактов, который нужно отобразить при переходе к просмотру фактов [Drillthrough](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2ANLY_ch_adhoc). Создадим простой листинг нажав кнопку "Добавить элемент":
Теперь зададим поля таблицы фактов, которые надо выводить. Например выведем информацию о тикерах и колебаних их цены за день (Name, Ticker, "Open", CloseLegal, Low, Average, High):
#### Компиляция куба
Итак мы добавили в куб два показателя, два измерения и один листинг — этого вполне достаточно и уже можно посмотреть, что получилось.
Скомпилируем класс куба (Кнопка "Компилировать"). Если ошибок компиляции нет, значит куб создан правильно и можно наполнить его данными.
Для этого нужно нажать "Построить куб" — в результате DeepSee загрузит данные из таблицы фактов в хранилище данных куба.
Для работы с данными куба нам пригодится другое веб-приложение — DeepSee Analyzer.
Построение сводной таблицы (Pivot)
----------------------------------
[DeepSee Analyzer](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2ANLY_ch_intro) — визуальное средство для непосредственного анализа данных кубов и подготовки источников данных для дальнейшей визуализации. Для перехода к DeepSee Analyzer откроем Портал Управления Системой → DeepSee → Выбор области → Analyzer. Открывается рабочее окно Аналайзера.
В рабочем окне Аналайзера слева мы видим элементы созданного куба: показатели и измерения. Комбинируя их мы строим запросы к кубу на языке [MDX](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2GMDX_ch_intro#D2GMDX_intro_mdx) — аналоге языка SQL для многомерных OLAP кубов.
Рассмотрим интерфейс Аналайзера. Справа — поле сводной таблицы. В поле сводной таблицы Аналайзера всегда показывается результат выполнения MDX-запроса. Посмотреть текущий MDX-запрос можно если нажать кнопку . При первом открытии куба в поле сводной таблицы по умолчанию показывается количество записей в таблице фактов — в нашем случае это количество записей в классе Ticker.Data. Этому соответствует MDX: `SELECT FROM [TICKER]`.
Чтобы создать сводную таблицу перетянем в поле колонок измерение “Год”. Показателем выберем "Объём". В результате получим таблицу количества проданных акций по годам.
Далее перетянем измерение “Тикер” в поле колонок и получим уже сводную таблицу количества акций по инструментам, с разбиением по годам:
Сейчас для каждой ячейки полученной таблицы рассчитывается одна величина — суммарное количество акций участвовавших в сделках (в случае если не выбран ни один показатель, считается количество фактов — в данном случае это можно интерпретировать как количество дней торговли инструмента). Это можно изменить. Добавим показатель "Средняя цена". В результате можно видеть уже более интересную картину: сводная таблица отображает среднюю максимум цены по каждому инструменту за год.
Как мы помним, в определении куба у нас заложена иерархия по датам. Это значит что по измерению Дата возможна операция DrillDown (переход по иерархии измерения от общего к частному). В Аналайзере двойной щелчок по заголовку измерения приводит переходу к следующему по иерархии измерению (DrillDown). В данном случае двойной клик по году приведет к переходу к месяцам этого года, а двойной клик на месяце — к переходу на уровень дней. В итоге можно посмотреть как менялась средняя цена акции для дней или месяцев.
На предыдущем этапе мы создали листинг — инструмент перехода от агрегированных данных к исходным фактам. Выберем любую строку сводной таблицы и нажмём кнопку  для перехода к листингу:
Следующий этап — визуализация. Перед сохранением упростим сводную таблицу и сохраним её под именем TickersByYears.
Построение дашборда (Dashboard)
-------------------------------
Портал Пользователя — это веб-приложение для создания и использования дашбордов ([панелей индикаторов](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D0%BD%D0%B5%D0%BB%D1%8C_%D0%B8%D0%BD%D0%B4%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80%D0%BE%D0%B2)). Дашборды содержат виждеты: таблицы, графики и карты на основе сводных таблиц, созданных аналитиками в Аналайзере.
Для перехода к Порталу Пользователя DeepSee откроем Портал Управления Системой → DeepSee → Выбор области → Портал Пользователя.
Создадим новый дашборд нажав на стрелку справа → добавить → Добавить индикаторную панель
Создадим виджет нажав на стрелку справа → Виджеты → "+" → Линейная диаграмма с маркерами. В качестве источника данных выберем TickersByYears:
Однако читатель возразит — это же средняя температура по больнице. И будет прав. Добавим фильтрацию по инструменту. Для этого нажмём стрелку справа → Виджеты → Виджет 1 → Элементы управления → "+". Форма создания нового фильтра выглядит следующим образом:
А вот так выглядит наш виджет с фильтром. Пользователь может изменить значение фильтра на любое другое.
После этого сохраним дашборд.
Установка MDX2JSON и DeepSeeWeb
-------------------------------
Для визуализации созданного дашборда можно использовать следующие OpenSource решения:
* [MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON) — REST API предоставляет информацию о кубах, пивотах, дашбордах и многих других элементах DeepSee, в частности — результатах исполнения MDX запросов, что позволяет встраивать пользовательский интерфейс аналитического решения на DeepSee в любое современное Web или мобильное приложение.
* [DeepSeeWeb](https://github.com/intersystems-ru/DeepSeeWeb) — AngularJS приложение, предоставляющее альтернативную реализацию портала пользователя DeepSee. Может быть легко кастомизирован. Использует MDX2JSON в качестве бэкэнда. Вот пример дашборда визуализированного в DeepSeeWeb:
### Установка MDX2JSON
Для установки MDX2JSON надо:
1. Загрузить [Installer.xml](https://raw.githubusercontent.com/intersystems-ru/Cache-MDX2JSON/master/MDX2JSON/Installer.cls.xml) и импортировать его в любую область с помощью Studio, Портала Управления Системой или `Do $System.OBJ.Load(file)`.
2. Выполнить в терминале (пользователем с ролью %ALL): `Do ##class(MDX2JSON.Installer).setup()`
Для проверки установки надо открыть в браузере страницу `http://server:port/MDX2JSON/Test?Debug`. Возможно потребуется ввести логин и пароль (в зависимости от настроек безопасности сервера). Должна открыться страница с информацией о сервере. В случае получения ошибки, можно почитать на [Readme](https://github.com/intersystems-ru/Cache-MDX2JSON) и [Wiki](https://github.com/intersystems-ru/Cache-MDX2JSON/wiki/Installation-Guide---RU).
### Установка DeepSeeWeb
Для установки DeepSeeWeb надо:
1. Загрузить [установщик](https://github.com/intersystems-ru/DeepSeeWeb/releases) и импортировать его в любую область с помощью Studio, Портала Управления Системой или `Do $System.OBJ.Load(file)`.
2. Выполнить в терминале (пользователем с ролью %ALL): `Do ##class(DSW.Installer).setup()`
Для проверки установки надо открыть в браузере страницу `http://server:port/dsw/index.html`. Должна открыться станица авторизации. В области SAMPLES представлено множество уже готовых дашбордов и все они автоматически отображаются в DeepSeeWeb.
Визуализация
------------
Откроем `http://server:port/dsw/index.html` и авторизируемся, также нужно указать область с кубом. Откроется список дашбордов, в нашем случае есть только один созданный дашборд "Акции". Откроем его:
Отображается наш созданный виджет. Для него поддерживается Drilldown и фильтр созданный в Портале Пользователя DeepSee:
Выводы
------
InterSystems DeepSee является мощным инструментом создания OLAP-решений, предоставляя разработчикам средства для создания и внедрения в свои приложения аналитической OLAP-функциональности, которая способна работать на оперативных базах данных приложений без создания отдельной инфраструктуры для решения аналитических задач.
Ссылки
------
* [DeepSee](http://www.intersystems.com/ru/our-products/embedded-technologies/deepsee/)
* [Вводный вебинар по DeepSee](https://www.youtube.com/watch?v=nlmVE3CzHaM)
* [Документация](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2MODEL_ch_concepts)
* [Репозиторий](https://github.com/intersystems-ru/Ticker)
* [MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON)
* [DeepSeeWeb](https://github.com/intersystems-ru/DeepSeeWeb)
* [API Московской Биржи](http://www.moex.com/a2193) | https://habr.com/ru/post/335586/ | null | ru | null |
# Как добавить Isar в проект на Flutter
Первое время при работе с Flutter мне хватало Hive. Быстро, удобно, но возможностей Hive мне стало не хватать. На странице <https://pub.dev/packages/hive> разработчики посоветовали попробовать Isar и я решила рискнуть. Много звездочек, но он совсем свежий, ошибки не гуглятся, а документация оставляет большие белые пятна.
Я не хочу дублировать тут все шаги, [вот тут](https://isar.dev/tutorials/quickstart.html) можно все посмотреть. Скачали -> Создали схему -> Запустили генератор. Четвертый шаг тоже простой, только схему (`schemas`) нужно взять из сгенерированного файла. У меня это activity.g.dart. Сразу в этом файле можно посмотреть как называется список ваших объектов.
Я немного затормозила тут и долго не могла понять почему у меня ничего не работает. Оказывается я по правилам английского языка искала activities, а вот генератор создал activitys. Наверное можно как-то его настроить, но я не успела пока так глубоко копнуть, если знаете как его заставить правильно писать автоматически, расскажите мне)
Ну вот и все что есть в быстром старте. Но мне же нужно следить за изменениями, закрыть потом все и конечно следить за уже открытыми экземплярами и не открывать повторно. Вот об этом я и хотела Вам рассказать)
Для того что бы контролировать все из одно места я создам IzarManager, в единственном экземпляре`static final IzarManager instance = IzarManager._(); IzarManager._();`
Теперь мне нужно посчитать, сколько раз я его открыла и закрыла. В дальнейшем у меня будут еще сущности для хранения, поэтому я буду считать каждую отдельно, по имени `final Map \_izarCounter = {};`
Создадим дженерик функцию для открытия базы данных. Сначала проверяем открыта ли она, если да добавляем в счетчик, если нет открываем.
```
Future \_openIsar(String name, CollectionSchema schema) async {
final dir = await getApplicationSupportDirectory();
final izar = Isar.getInstance(name);
if (izar != null && izar.isOpen) {
final count = \_izarCounter[name] ?? 1;
\_izarCounter[name] = count + 1;
return izar;
}
\_izarCounter[name] = 1;
return Isar.open(
schemas: [schema],
directory: dir.path,
name: name,
inspector: true,
);
}
```
При закрытии точно так же проверяем нужно ли закрыть или обновить счет.
```
Future closeIsar(Isar izar) async {
if (!izar.isOpen) {
\_izarCounter.remove(izar.name);
return;
}
var count = \_izarCounter[izar.name] ?? 1;
count -= 1;
\_izarCounter[izar.name] = count;
if (count > 0) return;
await izar.close();
}
```
ну и сам вызов открытия выглядит так
```
Future openActivityDB() async {
return \_openIsar('activities', ActivitySchema);
}
```
Вот так выглядит код для записи в базу данных. Открыли, записали, закрыли.
```
Future saveInDatabase(activity) async {
final isar = await IzarManager.instance.openActivityDB();
await isar.writeTxn((isar) async {
await isar.activities.put(activity); // insert & update
});
await IzarManager.instance.closeIsar(isar);
}
```
Но вот с чтением все немного сложнее, потому что у меня данные могут обновиться без перерисовки. Мне нужно открыть базу данных и подписаться на изменения и только потом закрыть.
```
class ActivitiesWidgetModel extends ChangeNotifier {
var _activities = [];
StreamSubscription? streamSubscription;
Future \_readActivitiesFromIsar() async {
\_activities = await (await \_isar).activities.where().findAll();
notifyListeners();
}
void \_setup() async {
\_isar = IzarManager.instance.openActivityDB();
await \_readActivitiesFromIsar();
Stream userChanged = (await \_isar).activities.watchLazy();
streamSubscription = userChanged.listen((newResult) {
\_readActivitiesFromIsar();
});
}
}
```
watchLazy помогает нам следить за изменениями и подписаться на стрим. Ну и конечно при уходе со страницы мы должны закрыть все и отписаться от прослушки.
```
@override
void dispose() async {
streamSubscription?.cancel();
await IzarManager.instance.closeIsar((await _isar));
super.dispose();
}
```
Пока мне кажется что Isar это действительно просто, работает быстро, много фильтров и легко искать данные. Пока столкнулась только с проблемой параллельного использования нескольких баз данных, но все решаемо. Если возникнут вопросы по коду то рекомендую посетить канал [LazyLoad Dart & Flutter](https://www.youtube.com/c/LearnDartFlutter) на ютубе. Очень детальный и полезный курс, мне очень помог стартовать во flutter. Надеюсь Вам пригодится мой туториал, спасибо за внимание! | https://habr.com/ru/post/673068/ | null | ru | null |
# С++23 — feature freeze близко
Прошло четыре месяца с [прошлой онлайн-встречи](https://habr.com/ru/company/yandex/blog/561104/) ISO-комитета, а значит, настало время собраться опять.
В этот раз в черновик нового стандарта C++23 добавили весьма полезные и вкусные новинки:
* `operator[](int, int, int)`
* монадические интерфейсы для `std::optional`
* `std::move_only_function`
* `std::basic_string::resize_and_overwrite`
* больше гетерогенных перегрузок для ассоциативных контейнеров
* `std::views::zip` и `zip_transform`, `adjacent`, `adjacent_transform`
Подробности об этих и других (даже более интересных!) вещах, а также о том, что за диаграмма стоит в шапке, ждут вас под катом.
### Многомерный operator[]
При разработке класса многомерного спана `std::mdspan` комитет столкнулся с проблемой многомерного индексирования. На примере массива с пятью измерениями:
```
auto raw = std::make_unique(3\*4\*5\*6\*7);
std::mdspan array{raw.get()};
array(1, 2, 3, 4, 5) = 42; // выглядит ужасно
array[{1, 2, 3, 4, 5}] = 42; // очень непонятно и неприятно писать
array[1][2][3][4][5] = 42; // чуть лучше, но под капотом творится просто жуть
```
Чтобы не делать таких безобразий (и по просьбам разработчиков математических библиотек) в C++ был добавлен многомерный `operator[]` ([P2128](https://wg21.link/p2128)). Его можно перегружать для любых типов, что позволяет делать принципиально новые интерфейсы:
```
enum class Volume: std::size_t{};
class Library {
// ...
public
Book operator[](std::u8string_view book_name, Volume volume) const;
};
// ...
Library lenin_library{};
auto book = lenin_library[u8"Большая советская энциклопедия", Volume{14}];
Read(book);
```
### Монадические интерфейсы для std::optional
Если вы не знаете, что такое «монады» — не расстраивайтесь~~, я тоже не знаю~~. Это знание не нужно, чтобы пользоваться новыми интерфейсами `std::optional` ([P0798](https://wg21.link/p0798)):
```
auto MonadicOptional(std::optional value) {
return value
.transform([](std::size\_t value) { return value - 40uz; })
.or\_else([]() { return 7uz; })
.and\_then([](std::size\_t value) { return std::string(value, '-'); })
;
}
assert(MonadicOptional(42) == '--');
assert(MonadicOptional(std::nullopt) == '-------');
```
Функция `auto optional::transform(F&& f)` возвращает `std::optional{f(*this)}` при непустом `this`; иначе вернёт `std::nullopt`. Функция `optional optional::or_else(F&& f)` возвращает `f()` при пустом `this`; иначе вернёт `this->value()`. Функция `auto optional::and_then(F&& f)` возвращает `f(this->value())` при непустом `this`; иначе вернёт дефолтно сконструированную переменную типа `decltype(f(*this))`.
Итого: с новыми функциями нет необходимости писать проверки на пустоту `std::optional`, чтобы выполнить преобразования хранящихся в нём данных.
### std::move\_only\_function
Со времён C++11, когда move-семантика только появилась, прошло уже 10 лет. За это время многие библиотеки стали требовать C++11, в них появились классы без поддержки копирования (только перемещения, только `std::move`!), а порой и без поддержки перемещения.
И тут заметили проблему: type-erased-контейнеры `std::function` и `std::any` требуют копируемости хранимого типа. Иначе получаем ошибку компиляции.
Фикс подоспел к С++23, приняли `std::move_only_function` ([P0288](https://wg21.link/p0288)), который не требует конструкторов копирования и перемещения. Теперь, если ваш алгоритм не требует, чтобы функтор копировался, просто принимайте на вход новый тип данных:
```
void example_usage(std::move_only_function f);
// Передавать только перемещаемые функции — ОК
example\_usage([ptr = std::make\_unique(42)](){ /\*...\*/ });
// Неперемещаемые — тоже ОК
struct non\_movable {
mutable std::mutex mtx;
void operator()() noexcept { std::unique\_lock lock{mtx}; /\*...\*/ }
};
example\_usage(std::in\_place);
```
Кстати, `std::move_only_function` работает и с явным указанием `noexcept`, так что можно требовать не кидающие функторы от вызывающего кода, просто написав `std::move_only_function`.
Что же касается требования копируемости в `std::any`, мы в РГ21 планируем заняться этой проблемой, [присоединяйтесь к обсуждениям](https://github.com/cpp-ru/ideas/issues/441), благо такой тип есть у нас в Яндекс Go, во фреймворке [userver](https://habr.com/ru/company/yandex/blog/474438/).
### basic\_string::resize\_and\_overwrite
Для любителей сильнее оптимизировать код в C++23 добавили возможность увеличить размер строки и сразу проинициализировать новые символы ([P1072](https://wg21.link/p1072)):
```
extern "C" {
int compress(void* out, size_t* out_size, const void* in, size_t in_size);
}
std::string CompressWrapper(std::string_view input) {
std::string compressed;
compressed.resize_and_overwrite(input.size(), [input](char* buf, std::size_t n) noexcept {
std::size_t compressed_size = n;
auto is_ok = compress(buf, &compressed_size, input.data(), input.size());
assert(is_ok);
return compressed_size;
});
return compressed;
}
```
Результат будет аналогичен следующему коду:
```
extern "C" {
int compress(void* out, size_t* out_size, const void* in, size_t in_size);
}
std::string CompressWrapper(std::string_view input) {
std::string compressed(input.size(), '\0');
std::size_t compressed_size = compressed.size();
auto is_ok = compress(compressed.data(), &compressed_size, input.data(), input.size());
assert(is_ok);
compressed.resize(compressed_size);
return compressed;
}
```
**А в чём разница-то? Что соптимизировали?**
Во втором примере при конструировании строки все её символы будут проинициализированы в `'\0'`. Уже после этого произойдёт вызов `compress`. Ну а в первом примере лямбда работает с незанулённым буфером, мы фактически избегаем вызова `memset( compressed.data(), compressed.size(), '\0');`.
### Больше гетерогенных методов
Маленькая, но очень приятная новость: ассоциативные контейнеры в C++23 обзавелись гетерогенными перегрузками методов `erase` и `extract`. Теперь можно удалять и извлекать ноды, используя ключи, отличные от шаблонных параметров контейнера:
```
std::set> da\_set;
// ...
std::u8string\_view key{u8"Я не std::u8string!"};
da\_set.find(key); // OK начиная с C++14
da\_set.erase(key); // OK начиная с C++23
```
График, показывающий прирост производительности при использовании новых методов, как раз вынесен в шапку этого поста. Больше графиков и детали можно найти в самом предложении: [P2077](https://wg21.link/p2077). Большое спасибо нашим ребятам из Intel за отлично проделанную работу!
### zip, zip\_transform, adjacent, adjacent\_transform
Ranges обзавелись новыми view для «склеивания» элементов диапазона ([P2321](https://wg21.link/p2321)):
```
std::vector v1 = {1, 2};
std::vector v2 = {'a', 'b', 'c'};
std::vector v3 = {3, 4, 5, 6, 7, 8};
auto result0 = std::views::zip(v1, v2); // {(1, 'a'), (2, 'b')}
auto result1 = std::views::zip_transform(std::multiplies(), v1, v3); // {3, 8}
auto result2 = v2 | std::views::pairwise; // {('a', 'b'), ('b', 'c')}
auto result3 = v3 | std::views::pairwise_transform(std::plus()); // {7, 9, 11, 13, 15}
auto result4 = v3 | std::views::adjacent<3>; // {(3, 4, 5), (4, 5, 6), (5, 6, 7), (6, 7, 8)}
```
Не стоит забывать, что ranges — ленивые:
* Если вы, например, из `result3` запросите только первые два элемента, то оставшиеся элементы считываться не будут.
* Если переменная `v3` будет уничтожена, то нельзя пользоваться `result1`, `result3`, `result4` и всеми их копиями.
### Транзакционная память
Комитет уже делал подход к транзакционной памяти Transactional TS, и этот подход показал себя совершенно несостоятельным: в стандарт вносилось слишком много правок, приходилось переделывать стандартную библиотеку, порой дублируя функции.
Поэтому решили сделать новый подход! Простой и элегантный:
```
class TwoInts {
public:
TwoInts() = default;
TwoInts(const TwoInts&) = delete;
TwoInts& operator=(const TwoInts&) = delete;
void SetA(int value) const { atomic do { a_ = value; } }
int GetA() const { atomic do { return a_; } }
void SetB(int value) const { atomic do { b_ = value; } }
int GetB() const { atomic do { return b_; } }
int Max() {
atomic do {
return a_ < b_ ? b_ : a_;
}
}
private:
int a_{0};
int b_{0};
};
```
Новый подход всё ещё экспериментальный, в ближайшее время он будет выпущен в виде TS, основанного на [P2066](https://wg21.link/p2066).
**Ложка дёгтя**
На мой взгляд, у подхода есть несколько больших недостатков:
* Нет способа понять, как будет соптимизирован атомарный блок (будет ли в нём мьютекс?).
* Если атомарный блок деградирует до мьютекса, то будет один мьютекс для всех атомарных блоков, а это быстро станет узким местом в коде.
* Добавляется множество новых не диагностируемых способов получить UB.
### Получение std::stacktrace из исключения
От [РГ21](https://stdcpp.ru/) есть замечательное предложение [Stacktrace from exception](https://github.com/cpp-ru/ideas/issues/435), которое позволяет получить стектрейс из любого исключения без модификации кода, который выкидывает это исключение:
```
void foo(std::string_view key);
void bar(std::string_view key);
int main() {
try {
foo("test1");
bar("test2");
} catch (const std::exception& exc) {
std::stacktrace trace = std::stacktrace::from_current_exception(); // <---
std::cerr << "Caught exception: " << exc.what() << ", trace:\n" << trace;
}
}
```
Такой пример может вывести следующее:
`Caught exception: map::at, trace:
0# get_data_from_config(std::string_view) at /home/axolm/basic.cpp:600
1# bar(std::string_view) at /home/axolm/basic.cpp:6
2# main at /home/axolm/basic.cpp:17`
Если честно, я не верил, что комитет успеет принять эту идею в C++23. Но внезапно предложение понравилось многим комитетским старожилам, и появился шанс успеть втащить его в стандарт на одном из заседаний 2021 года, которые будут последними перед feature freeze.
### Итоги и feature freeze
На дизайн новых идей до feature freeze у нас осталось около 16 двухчасовых собраний. Networking и Executors навряд ли успеют, как и примитивы для работы с корутинами. Но не надо расстраиваться, есть шансы увидеть pattern matching, `std::mdspan`, `std::flat_set`, `std::flat_map`, `std::static_vector`, constexpr cmath и некоторые другие полезные вещи.
Кстати, 15-18 ноября состоится конференция [C++ Russia](https://cppconf.ru/), где можно будет узнать новости о развитии C++ и пообщаться с многими представителями комитета. | https://habr.com/ru/post/580880/ | null | ru | null |
# Vuex: структурирование больших проектов и работа с модулями
Vuex — это официальная, отлично документированная библиотека для управления состоянием приложений, разработанная специально для фреймворка Vue.js. Автор материала, перевод которого мы сегодня публикуем, полагает, что пользоваться этой библиотекой гораздо приятнее, чем Redux, так как, во-первых, для работы с Vuex требуется меньше шаблонного кода, а во-вторых — из-за того, что для работы с асинхронными механизмами здесь не нужно дополнительных библиотек. Более того, так как библиотека Vuex создана той же командой, которая занимается работой над Vue, эта библиотека очень хорошо интегрируется с данным фреймворком. К сожалению, в работе с Vuex всё ещё можно столкнуться с одной сложностью, которая заключается в правильной подготовке структуры проектов, в которых планируется пользоваться этой библиотекой.
[](https://habr.com/company/ruvds/blog/420357/)
В этой статье вы найдёте описание методики структурирования больших проектов, использующих Vuex, и скрипта, предназначенного для автоматизации процесса создания модулей Vuex.
Шаблон vue-enterprise-boilerplate и проблема структуры проекта
--------------------------------------------------------------
Один из разработчиков Vue, Крис Фриц, создал отличный [шаблон](https://github.com/chrisvfritz/vue-enterprise-boilerplate) для Vue, структура проекта, представленная в котором, рассчитана на использование Vuex. В частности, этот шаблон позволяет Vuex автоматически регистрировать модули, основываясь на файлах, находящихся в папке `modules`. Структура папок проекта может выглядеть примерно так, как показано на следующем рисунке.
*Структура проекта и неудобное размещение кода*
При использовании этого шаблона нужно, чтобы состояние, геттеры, действия и мутации находились бы в одном файле. Лично я предпочитаю держать их в отдельных файлах, что позволяет, учитывая то, что модули Vuex иногда бывают довольно большими, удобно ориентироваться в программах, обходясь без необходимости прокручивать огромные куски кода. Следуя этой идее, изменим код из шаблона таким образом, чтобы то, что относится к отдельным модулям, можно было бы разложить по папкам, предназначенным для этих модулей. То есть, структура проекта изменится и будет похожа на ту, что показана ниже.
*Структура проекта с разбиением материалов модулей по отдельным файлам, которые находятся в папках модулей*
Разработка шаблона, поддерживающего удобную структуру проекта
-------------------------------------------------------------
Итак, мы собираемся организовать работу с Vuex так, чтобы можно было бы использовать в своих проектах структуры папок и файлов, подобные той, которая показана на предыдущем рисунке. Для того чтобы это сделать, сначала создадим новый проект с использованием [Vue CLI 3](https://cli.vuejs.org/).
После того, как у вас будет шаблон проекта, готовый к дальнейшей работе с ним, установите Vuex и Lodash, выполнив в терминале команду `npm install vuex lodash -save`. Для работы с модулями нам понадобится функция `camelCase` из Lodash, которая предназначена для преобразования строк к верблюжьему стилю.
Теперь создадим папку и структуру файлов, похожую на ту, которая показана на предыдущем рисунке.
Начнём работу с файла `store.js`. Вот его код:
```
import Vue from 'vue'
import Vuex from 'vuex'
import modules from './modules'
Vue.use(Vuex)
const store = new Vuex.Store({
modules,
strict: process.env.NODE_ENV !== 'production'
})
// Автоматически запустить действие `init` для каждого существующего модуля
for (const moduleName of Object.keys(modules)) {
if (modules[moduleName].actions.init) {
store.dispatch(`${moduleName}/init`)
}
}
export default store
```
Здесь импортируются Vue и Vuex, так как без них нам не обойтись. Кроме того, мы импортируем модули из `/modules/index.js`. Далее, мы инициализируем хранилище и проходимся в цикле по всем модулям. Если у модуля есть действие `init`, мы инициализируем модуль. Это оказывается очень кстати для тех модулей, которые нужно инициализировать при запуске приложения. В итоге, конечно, мы экспортируем `store`, после чего, обычно, это импортируется в файл `main.js` и добавляется к экземпляру Vue.
Теперь пришло время поработать с файлом `index.js`, который находится в папке `/store/modules`.
```
// Будем регистрировать модули Vuex с использованием имён их файлов, приведённых к верблюжьему стилю.
import camelCase from 'lodash/camelCase';
// Получаем все файлы
const requireModule = require.context(
// Ищем файлы в текущей директории
'.',
// Ищем файлы в поддиректориях
true,
// Исключаем файл index.js, равно как и файлы, в именах которых
// есть строки 'actions', 'mutations', или 'getters' .
// Кроме того, включаем только файлы с расширением .js
/^(?!.*(actions|mutations|getters|index)).*\.js$/
);
const modules = {};
requireModule.keys().forEach(fileName => {
// Игнорируем файлы модульных тестов
if (/\.unit\.js$/.test(fileName)) return;
// Избавляемся от расширений файлов для преобразования их имён к верблюжьему стилю
modules[camelCase(fileName.split('/')[1].replace(/(\.\/|\.js)/g, ''))] = {
namespaced: true,
...requireModule(fileName).default
};
});
export default modules;
```
В этом коде мы сначала импортируем функцию `camelCase` из Lodash. Затем используем метод `require.context` для подключения модулей. В качестве третьего параметра мы передаём туда регулярное выражение, которое отфильтрует файл `index.js`, а также файлы, в именах которых есть строки `actions`, `mutations` и `getters`. Они будут импортированы в файл состояния, например, в `auth.js`, а затем экспортированы. Например, вот как файл `auth.js` из папки `src/store/modules/auth/` может выглядеть в начале работы:
```
import actions from './actions';
import mutations from './mutations';
import getters from './getters';
const state = {
user: null
};
export default {
state,
mutations,
getters,
actions
};
```
Теперь осталось лишь пройтись по всем модулям и сформировать единственный объект со всеми ними. Тут нужно исключить все файлы, в имени которых есть строка `unit`, так как они нужны только для тестов, а не для разработки или для разворачивания проекта в продакшне. После этого мы добавляем к объекту `modules` новое свойство, у которого будет имя файла состояния, например — `auth` или `users`. Кроме того, мы используем функцию `camelCase` для того, чтобы имена свойств выглядели бы единообразно. Затем мы заполняем объект `modules`, перебирая `requireModule` и пользуясь конструкцией `...requireModule(fileName).default`, после чего экспортируем `modules`.
Собственно говоря, именно так и можно структурировать проект, в котором состояние, геттеры, действия и мутации хранятся раздельно и оказываются удобно организованными. Теперь поговорим о том, как написать скрипт для автоматического создания модулей Vuex.
Скрипт для автоматического создания модулей Vuex
------------------------------------------------
Создадим в папке проекта новую папку с именем `scripts`, в ней создадим файл `generateVuexModule.js`. Для этого проекта нам понадобится Node.js, поэтому, если у вас эта платформа не установлена — сейчас самое время это [исправить](https://nodejs.org/). У нашего скрипта есть лишь одна зависимость — пакет `chalk`, который используется для оформления материалов, выводимых в консоль. Установить этот пакет можно командой `npm install -save-dev chalk`.
### ▍Шаг 1
В файле `generateVuexModule.js` нужно подключить три модуля: `fs`, `path` и `chalk`. Также тут нужна константа с путём к папке с модулями (`src/store/modules`) и ещё одна константа — `args`, в которую попадут аргументы, переданные скрипту при его запуске.
```
const fs = require('fs');
const path = require('path');
const chalk = require('chalk');
const modulesPath = 'src/store/modules';
const args = process.argv.slice(2);
const error = (...args) => {
console.log(chalk.red(...args));
};
const success = (...args) => {
console.log(chalk.green(...args));
};
if (!args.length) {
error('You must provide a name for the module!');
return;
}
```
Как видите, мы записываем в `args` все аргументы кроме первых двух, так как они представляют собой путь к `node.exe` и к файлу скрипта, а эти сведения нам не нужны. Мы заинтересованы лишь в третьем параметре — имени нового модуля. Кроме того, тут есть пара функций, `error` и `success`, которые используют вышеупомянутый пакет `chalk` для вывода сообщений текстами разных цветов.
Здесь нужно проверить длину массива `args` для того, чтобы узнать, передано ли нашему скрипту имя модуля, и, если это не так — выдать сообщение об ошибке. Поэтому, если вы попытаетесь запустить этот скрипт с помощью команды `node generateVuexModule.js`, ничего больше ему не передавая, вы увидите в терминале сообщение об ошибке.
### ▍Шаг 2
К этому моменту у нас есть имя для модуля и путь, заданный константой `modulesPath`. Однако с этими данными ещё надо поработать. А именно, извлечь имя из массива `args` и собрать полный путь к модулю, не говоря уже о формировании его содержимого.
```
const moduleName = args[0];
const modulePath = path.join(__dirname, '../', modulesPath, moduleName);
if (fs.existsSync(modulePath)) {
error(`${moduleName} directory already exists!`);
return;
}
const stateContent = `import getters from './getters';
import actions from './actions';
import mutations from './mutations';
const state = {};
export default {
state,
getters,
actions,
mutations
};
`;
const exportFileContent = `import * as types from '@/store/types';
export default {
};
`;
```
Имя модуля будет находиться в элементе массива `args` с индексом 0. На данном этапе выполнения программы мы можем рассчитывать на наличие этого элемента, так как ранее мы сделали попытку извлечь его из `process.argv`, после чего проверили длину массива `args`. Кроме того, мы подготовили полный путь с использованием модуля `path` и метода `join`. Текущую директорию мы получили с помощью конструкции `__dirname`, перешли на один уровень вверх, так как файл `generateVuexModule.js` находится в папке проекта `scripts`. Затем мы просто добавляем к тому, что получилось, содержимое константы `modulesPath` и имя модуля. К этому моменту в константе `modulePath` должно содержаться нечто вроде `pathToYourProject/project/src/store/modules/moduleName`. Именно здесь и будет создан модуль. Теперь, так как у нас есть полный путь, мы можем проверить, существует ли данная директория. Нам не хотелось бы случайно перезаписать файлы существующего модуля. В результате, если директория, в которой планируется создать новый модуль, существует, мы выведем, красными буквами, благодаря `chalk`, сообщение об ошибке.
*Пример сообщения об ошибке*
Дальше надо создать константы, в которых будут данные для файлов. Как вы можете предположить, `stateContent` используется для файла состояния, то есть, например, для `auth.js`, а `exportFileContent` — для файлов `getters.js`, `actions.js`, и `mutations.js`. Если нужно, можете добавить в этот список всё, что требуется в вашем проекте.
### ▍Шаг 3
Теперь нам осталось лишь сформировать пути для файлов модуля и создать их.
```
const statePath = `${path.join(modulePath, `${moduleName}.js`)}`
const gettersPath = `${path.join(modulePath, 'getters.js')}`
const actionsPath = `${path.join(modulePath, 'actions.js')}`
const mutationsPath = `${path.join(modulePath, 'mutations.js')}`
fs.mkdirSync(modulePath);
fs.appendFileSync(statePath, stateContent);
fs.appendFileSync(gettersPath, exportFileContent);
fs.appendFileSync(actionsPath, exportFileContent);
fs.appendFileSync(mutationsPath, exportFileContent);
success('Module', moduleName, 'generated!');
```
Сначала мы объявляем четыре константы, каждая из которых содержит путь для соответствующего файла. Далее нам надо создать папку для модуля. Мы уже проверяли, существует ли такая папка и выдавали ошибку в том случае, если это так. Поэтому здесь с созданием папки проблем быть не должно. И, наконец, мы используем команды `fs.appendFileSync`, помещая новые файлы с заданным в процессе их создания содержимым в только что созданную директорию. В конце скрипт выводит сообщение об успешном завершении операции.
Для того чтобы воспользоваться этим скриптом, достаточно перейти в терминале в папку `scripts` вашего проекта и выполнить команду вида `node generateVuexModule.js yourModuleName`. После успешного завершения работы скрипта вы увидите сообщение о создании модуля.
Итоги
-----
Ознакомившись с этим материалом, вы узнали о шаблоне для структурирования больших проектов, в которых планируется использовать Vuex, и о скрипте, упрощающем создание модулей Vuex. Надеемся, эти знания вам пригодятся. Код проекта, примеры из которого мы рассматривали, можно найти [здесь](https://github.com/DeraIeS/vuex-enterprise-setup).
**Уважаемые читатели!** Как вы структурируете большие Vue-приложения, в которых используется Vuex?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/420357/ | null | ru | null |
# Скриптуем на WebAssembly, или WebAssembly без Web
Представлять WebAssembly не нужно — поддержка уже есть в современных браузерах. Но технология годится не только для них.
WebAssembly — кроссплатформенный байткод. Значит, этот байткод можно запустить на любой платформе, где есть его виртуальная машина. И для этого вовсе не нужен браузер и Javascript-движок.
Далее — проверка концепции на прочность, инструментарий и первый скриптовый модуль.
Зачем?
======
Wasm-модули можно использовать в тех же случаях, что и скриптовые языки: для исполнения динамически загружаемой логики. Там, где используется Lua и Javascript. Но затраты на интерпретацию wasm меньше, чем у скриптовых языков, и на wasm можно применить больше оптимизаций. Ибо оптимизации эти делаются во время компиляции на исходной машине, а не интерпретации или JIT-компиляции на клиенте.
WebAssembly потенциально независим от исходного языка. В перспективе, скриптёр (тот, кто будет писать скрипты) может делать это на удобном для него языке, не привязываться к конкретному языку.
Кроме скриптовых языков технологию можно сравнить с LLVM-байткодом и Java-машиной.
Сравнение с LLVM-IR [сделано](http://webassembly.org/docs/faq/) уже в ходе разработки WebAssembly. Авторы аргументируют свой отказ ещё на этапе MVP так:
* Портируемость: для различных архитектур целевой машины набор инструкций должен быть один. В общем случае для LLVM-IR это не так.
* Стабильность: набор инструкций должен изменяться со временем только при сохранении обратной совместимости. LLVM такой цели не ставит.
* Минимально возможный размер бинарного кода
* Максимально быстрое декодирования
* Быстрая компиляция: набор инструкций должен быть применим вместе с JIT-компиляцией, позволять достаточно быстрый процесс запуска приложения. LLVM-IR проектируется под ahead-of-time-компиляцию.
* Минимальная неопределенность: поведение программ должно быть максимально предсказуемым. LLVM-IR же проектируется для возможностей оптимизации, значит, содержит множество вариантов неопределённого поведения (undefined behavior, UB)
По сравнению с Java и её виртуальной машиной:
* wasm не привязан к конкретному языку (или группе языков, с учётом Scala и Kotlin)
* Java-машина неотделима от своей инфраструктуры и стандартных библиотек
* JVM достаточно массивна
* JVM требует вызова нативных функций поверх уже имеющейся инфраструктуры, что для низкоуровневых функций часто сложнее, чем разработка “с нуля”.
WebAssembly может занять в инфраструктуре портируемого кода собственную нишу, где ни скриптовые языки, ни LLVM-IR, ни JVM не решают задачи эффективно.
А какие это задачи?
===================
Идея использовать WebAssembly без web-окружения возникла из конкретной задачи. Необходимо создать модули с интерактивными графиками, которые бы работали на веб-сайте и в мобильном приложении. Первоначальный вариант решения: встроить Javascript-движок в мобильное приложение и передавать логику javascript-кодом. Но движки оказались достаточно массивными и сложными в устройстве (за исключением, пожалуй, [JerryScript](https://github.com/jerryscript-project/jerryscript)). Использование движка для одной небольшой задачи выглядело серьёзным оверинжинирингом. В этот момент мы пришли к выводу, что аналогичные модули на WebAssembly будут лучше из-за малого размера интерпретатора и более быстрой интерпретации.
Другой вариант использования: компилировать в WebAssembly шаблоны для веб-страниц. Для этого достаточно создать backend к любимому шаблонизатору. Такие шаблоны достаточно просто запускать как на сервере через интерпретатор, так и в браузере стандартными средствами. Создать backend к шаблонизатору проще, чем портировать любимый шаблонизатор на любимую систему. *Формально, backend проще сделать для кода на C, который после будет компилироваться в wasm.*
[На сайте WebAssembly](http://webassembly.org/docs/non-web/) [предлагаются](http://webassembly.org/docs/use-cases/) и другие варианты использования:
* Распространение игровых приложений в виде модулей (по аналогии с [cocos2d-js](https://github.com/cocos2d/cocos2d-js), вместе с его обновлениями кода на ходу)
* Исполнение ненадежного кода на стороне сервера (на самом деле, та же задача, что и с шаблонизаторами, но глобальнее)
* Гибридные приложения для мобильных устройств
* Запуск процессов сразу на нескольких вычислительных узлах
Как?
====
### Собираем инструменты для сборки WebAssembly
Для реализации задуманного нам нужен экспериментальный модуль WebAssembly из LLVM версии 5 (текущей стабильной) или старше.
Будем использовать цепочку LLVM Webassembly backend -> LLVM байткод -> текстовое представление LLVM-IR -> Binaryen s2wasm -> Binaryen wasm-as
**Собираем LLVM**Сборка занимает от 15 минут до часа и требует много памяти (особенно, при `make -j8`)
```
# download LLVM-5 sources
wget http://releases.llvm.org/5.0.0/llvm-5.0.0.src.tar.xz
tar -xJf llvm-5.0.0.src.tar.xz llvm-5.0.0.src
mv llvm-5.0.0.src llvm
rm llvm-5.0.0.src.tar.xz
cd llvm/tools
# download clang sources
wget http://releases.llvm.org/5.0.0/cfe-5.0.0.src.tar.xz
tar -xJf cfe-5.0.0.src.tar.xz cfe-5.0.0.src
mv cfe-5.0.0.src clang
rm cfe-5.0.0.src.tar.xz
cd -
WORKDIR=`pwd`
INSTALLDIR=`pwd`
rm -rf llvm-build
mkdir llvm-build
cd llvm-build
# For Debug build:
# cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=$INSTALLDIR -DLLVM_TARGETS_TO_BUILD= -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly -DCMAKE_BUILD_TYPE=Debug $WORKDIR/llvm
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=$INSTALLDIR -DLLVM_TARGETS_TO_BUILD= -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly $WORKDIR/llvm
make
```
**Собираем Binaryen**
```
git clone https://github.com/WebAssembly/binaryen.git
cd binaryen
cmake .
make
```
**Собираем WABT**
```
git clone https://github.com/WebAssembly/wabt.git
cd wabt
git submodule update --init
make
```
**Устанавливаем Rust**
```
curl https://sh.rustup.rs -sSf | sh
source $HOME/.cargo/env
rustup toolchain install nightly
rustup target add wasm32-unknown-unknown
rustup default nightly
```
[Пример сборки C/C++ с помощью makefile](https://github.com/strelok2012/WASMScript/blob/master/wasm/cpp/Makefile)
**Сборка Rust**
```
rustc --target=wasm32-unknown-unknown --crate-type=cdylib -C panic=abort -o
```
### Собираем интерпретатор
В качестве proof of concept можно использовать интерпретатор из WABT. Для подтверждения работы будем вызывать функцию из WebAssembly, которая вызывает функцию среды. Добавить импортируемые функции в WABT можно, например, [вот так](https://github.com/strelok2012/WASMScript/blob/master/interp/exec/ImportDelegate.cc).
**Код на C**
```
extern void import_function(int);
int export_function(int i_test) {
import_function(i_test * 3);
return ++i_test;
}
```
**Код на Rust**
```
#![no_std]
#![no_main]
#![feature(lang_items)]
#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
mod wasm {
pub fn _import_function(i: isize) -> isize {
unsafe { import_function(i) }
}
extern {
fn import_function(i: isize) -> isize;
}
}
#[no_mangle]
pub fn export_function(i_test: isize) -> isize {
wasm::_import_function(i_test*2);
let result = i_test+1;
result
}
```
Запустить модуль можно так:
```
-E export\_function
```
Эти же модули можно использовать и в вебе, если реализовать требуемые импортируемые функции. [Например, вот так](https://github.com/strelok2012/WASMScript/blob/master/index.html).
### Замечания к коду
* Rust добавляет в импортируемые функции `rust_begin_unwind` (хотя `-C panic=abort` гарантирует, что эта функция не будет вызвана). Потенциально проблему можно исправить на уровне rustc, на уровне оптимизации WebAssembly (через удаление неиспользуемых параметров). Как временное решение мы добавили `rust_begin_unwind` в список импорта в виде функции, которая не делает ничего.
* Функции, возвращающие структуры будут преобразованы таким образом: `Vec2 makeVec2(float x, float y) {...}` в `(func (; 2 ;) (param $0 i32) (param $1 f32) (param $2 f32)`. Возвращаемое значение было преобразовано в указатель (тип `i32`) на блок памяти, который будет хранить готовый объект. То есть, компилятор выполнил RVO. Для работы с такими функциями нужно предварительно распределить из памяти модуля требуемый блок, и вызывать функцию с указателем в качестве первого аргумента
* Если хотите компилировать код с виртуальными функциями через Binaryen, вам пригодится патч:
**Патч для weak-символов в Binaryen**
```
--- a/src/s2wasm.h
+++ b/src/s2wasm.h
@@ -1320,7 +1320,7 @@ class S2WasmBuilder {
}
skipWhitespace();
Address align = 4; // XXX default?
- if (match(".globl")) {
+ if (match(".globl") || match(".weak")) {
mustMatch(name.str);
skipWhitespace();
}
```
### Проектируем стандартную библиотеку
WebAssembly модули умеют импортировать и экспортировать функции, но создать библиотеку предстоит самостоятельно: стандарт не определяет никакой стандартной библиотеки.
Стандартная библиотека создается для интерпретатора и компилируется вместе с интерпретатором. Если задача требует исполнения wasm и нативно, и в браузере, вам нужно будет портировать вашу стандартную библиотеку на Javascript для совместимости. Например, для задачи интерактивных графиков написать cmath-совместимую обёртку и для интерпретатора, и для javascript.
Что включать в стандартную библиотеку — отдельный сложный вопрос. В случае со скриптовыми языками, вам дают уже готовую универсальную библиотеку. Из которой некоторые функции вы будете вынуждены выключить (например, прямой доступ к файловой системе). В случае с wasm вы можете создать строгий специальный API, которым скрипты будут ограничены в их песочнице.
Заключение
==========
WebAssembly — мощная технология, которую можно использовать и вне веб-окружения. Пока мы делаем только первые шаги и учимся использовать новые инструменты, проектировать системы по новым правилам. В будущем WebAssembly может стать одним из стандартов для портируемых исполняемых пакетов.
Текущее (на ноябрь 2017 года) состояние инструментов довольно слабое, но они уже пригодны для использования. Выявленные проблемы исправляются достаточно быстро. В этой статье мы хотели показать возможность отдельного применения WebAssembly. А куда копать дальше — в опросе.
В соавторстве с [strelok2010](https://habr.com/users/strelok2010/)
Весь код [здесь](https://github.com/strelok2012/WASMScript). | https://habr.com/ru/post/344246/ | null | ru | null |
# Воспроизведение звука на Intel Edison через Bluetooth с использованием Advanced Audio Distribution Profile (A2DP)
В ходе реализации проектов на плате Intel Edison иногда возникает необходимость воспроизвести звук. В последних версиях образа Yocto добавлена поддержка Alsa, и можно воспользоваться USB аудиокартой. Но большую мобильность даст использование встроенного Bluetooth модуля. Например, устройство на базе Intel Edison, которое получает аудиофайлы по сети, может находиться стационарно в одном месте в комнате. Слушать же музыку можно в любой точке помещения, используя обычные беспроводные наушники. Итак, начнём.
[](http://habrahabr.ru/company/intel/blog/258157/)
Вам понадобятся
===============
* Звуковое Bluetooth устройство, например, наушники или колонки.
* Подключенная к WiFi сети плата Intel Edison. (Смотрите [Step 3: Get your Board Online](https://software.intel.com/iot/getting-started#connect)).
* Компьютер с музыкальными wav файлами, расположенный в нашей сетке.
* Установленное терминальное соединение с платой через последовательный порт (Смотрите [Set Up WiFi – Intel Edison](https://software.intel.com/en-us/articles/intel-edison-getting-started-wifi)) или SSH.
Настройка
=========
Включите ваше Bluetooth устройство и сделайте его видимым. Введите следующие команды в терминале:
```
rfkill unblock bluetooth
bluetoothctl
```
Просканируйте доступные Bluetooth устройства:
```
scan on
```
Найдите ваше устройство и присоединитесь к нему (подставив его MAC адрес):
```
pair 00:25:DB:05:72:F2
```
Установите соединение, если необходимо:
```
connect 00:25:DB:05:72:F2
```
Закройте программу bluetoothctl:
```
quit
```
Проверьте, что ваше A2DP устройство (в нашем случае наушники LG) распознались в pulseaudio как sink-устройство и его имя начинается с bluez\_sink
```
pactl list sinks
```
Сконфигурируйте дефолтный sink для использования в pulseaudio следующими командами, подставив параметры вашего устройства:
```
pactl set-default-sink bluez_sink.00_25_DB_05_72_F2
```
Скопируйте аудио файл в формате wav на плату Intel Edison, используя scp (Linux) или pscp.exe (Windows) и проиграйте его через mplayer:
```
mplayer Intel_bong.wav2
```
Используйте wav файлы, так как могут быть некоторые сложности при проигрывании mp3 файлов.
Устранение проблем
==================
Если вы получили:
```
Failed to pair: org.bluez.Error.AlreadyExists
```
Проверьте, какое устройство у вас подключено:
```
paired-devices
```
Удалите устройство, к которому вы подключены (подставьте MAC-адрес вашего устройства):
```
remove 78:24:AF:13:58:B9
```
Другие полезные команды bluetoothctl можно получить так:
```
help
```
Дополнительная информация
=========================
* [Потоковое вещание по сети или через конвейер](http://www.mplayerhq.hu/DOCS/HTML/en/streaming.html)
От переводчика
==============
При проверке этой статьи у меня возникли некоторые проблемы. Устройство не получалось подсоединить командой connect, не было команды pactl. Плата Edison была прямо из коробки, поэтому всё это решилось перепрошивкой новой версией образа Yocto.
Чтобы перепрошить плату, можно воспользоваться [следующей рекомендацией](http://habrahabr.ru/company/intel/blog/249845/). Я сделал немного по-другому в Windows.
В папке с распакованным архивом Yocto на Windows компьютере запускаем flashall.bat. Возможно, еще понадобится программа dfu-util.exe, которую надо поместить в эту же распакованную папку. Сама программа доступна по [ссылке](https://dl.dropboxusercontent.com/u/54378433/dfu-util/dfu-util.exe).
Обсуждение dfu-util под Windows и перепрошивку Edison можно найти [тут](https://communities.intel.com/thread/56012) и [тут](https://community.spark.io/t/latest-2014-dfu-util-for-windows-compiled/5264).
Читайте также:
**»** [Практикум «Intel IoT». Edison — могучая «кроха»](http://habrahabr.ru/company/intel/blog/249845/) | https://habr.com/ru/post/258157/ | null | ru | null |
# Представляем Entity Framework Core 7 Preview 6: Улучшение производительности
Пакет Entity Framework 7 (EF7) Preview 6 опубликован и доступен для загрузки через [nuget.org](https://devblogs.microsoft.com/dotnet/announcing-ef7-preview6/#how-to-get-ef7-previews) (в конце поста есть ссылки на индивидуальные компоненты пакета). Этот пост блога раскрывает реализованные в пакете улучшения, направленные на увеличение производительности [запросов]; полный перечень изменений EF7 Preview 6 доступен на [этой странице](https://github.com/dotnet/efcore/issues?q=is%3Aissue+milestone%3A7.0.0-preview6+is%3Aclosed+label%3Atype-enhancement+).
От переводчикаФормат блога не характерен для статей Хабра, равно как и для переводов статей. Однако, содержание данного поста настолько интересно, что не смог удержаться. Изложенная информация относится к разряду "Надо знать" для использующих фреймворк, и останется актуальной на длительный срок. Текст, [выделенный квадратными скобками], добавлен мной.
Изменения для улучшения производительности
------------------------------------------
В EF7 значительно улучшена производительность команды SaveChanges, в основном благодаря удалению избыточных циклов обмена с базой данных по сети . В некоторых случаях мы сократили время запроса до 74% – т.е., получили четырехкратное увеличение производительности!
### Предпосылки
Производительность [работы] EF Core всегда находится у нас под высшим приоритетом. В пакете EF Core 6.0 мы сконцентрировались на улучшении производительности запросов, возвращающих сущности без отслеживания (non-tracking entities), достигнув значительного увеличения скорости и сделав EF Core сопоставимым по производительности с прямыми запросами в SQL с использованием Dapper (подробнее см. [этот блог](https://devblogs.microsoft.com/dotnet/announcing-entity-framework-core-6-0-preview-4-performance-edition)). Для EF Core 7.0, мы сконцентрировались на реализации фреймворком “конвейера [процедур] обновления”, конкретнее – [работе] компонента, реализующего SaveChanges и отвечающего за выполнение операций вставки, обновления и удаления записей в базе данных.
Оптимизация запросов в EF Core 6.0 была, по существу, улучшением производительности [фреймворка] в режиме выполнения: целью было уменьшить затраты самого кода EF Core, т.е. время выполнения кода EF Core при выполнении запроса. Оптимизация в реализации запросов на обновление в EF Core 7.0 несколько отличается; оказалось, что есть возможности для улучшения самого SQL запроса, который EF посылает в базу данных, и (что даже более существенно) в уменьшении количества циклов обмена по сети, производимых в процессе выполнения процедуры SaveChanges. Оптимизация обмена по сети особенно важна для улучшения производительности современных приложений:
* Издержки на обмен по сети обычно является ключевым фактором (типичное время составляет миллисекунды), так что устранение излишних циклов обмена может оказать гораздо большее влияние, чем множество микро оптимизаций в самом коде.
* Задержка [сетевого ответа] зависит от множества факторов, так что чем больше длительность цикла сетевого обмена, тем лучше эффект от оптимизации.
* Обычно в среде разработки сервер базы данных расположен локально по отношению к приложению. В облачной среде база данных находится значительно дальше, что увеличивает сетевые задержки.
Вне зависимости от описанных ниже оптимизаций производительности, я очень рекомендую помнить о циклах обмена по сети при взаимодействии с базой данных, и учитывать рекомендации статьи [Общие сведения о производительности EF](https://docs.microsoft.com/ef/core/performance) для оптимизации (например, [осуществляйте раннюю загрузку сущностей везде, где это возможно](https://docs.microsoft.com/ef/core/performance/efficient-querying#load-related-entities-eagerly-when-possible)).
### Транзакции и циклы сетевого обмена
Давайте рассмотрим очень простую программу EF, которая вставляет одну строку в базу данных:
```
var blog = new Blog { Name = "MyBlog" };
ctx.Blogs.Add(blog);
await ctx.SaveChangesAsync();
```
Выполнение под EF Core 6.0 покажет следующий лог обмена (отфильтрованы самые существенные события):
```
dbug: 2022-07-10 17:10:48.450 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 17:10:48.521 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (30ms) [Parameters=[@p0='Foo' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Name])
VALUES (@p0);
SELECT [Id]
FROM [Blogs]
WHERE @@ROWCOUNT = 1 AND [Id] = scope_identity();
dbug: 2022-07-10 17:10:48.549 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
Основная команда – которая занимает 30 миллисекунд – содержит два SQL оператора (за исключением оператора NOCOUNT, который несущественен): ожидаемого оператора INSERT, с последующим оператором SELECT для получения ID вставленной строки. В EF Core, когда ключ сущности является значением типа int, EF обычно настроена на получение генерируемого базой данных значения ключа; для SQL Server это столбец с признаком IDENTITY. Поскольку после вставки строки может потребоваться выполнить последующие операции с сущностью, EF должна вернуть значение ID и присвоить его экземпляру сущности blog.
Вроде всё хорошо; однако здесь выполняется ещё кое что: перед выполнением команды открывается транзакция, которая фиксируется после выполнения команд. При разборе исполнения в моём средстве анализа производительности, эта транзакция стоит нам двух дополнительных циклов обмена с базой данных – первый при её старте, и второй при фиксации. На данный момент [в Ef Core 6.0] транзакция применяется по следующей причине: SaveChanges может иметь необходимость в выполнении нескольких операций изменения, и мы бы хотели, чтобы эти операции были обернуты в транзакцию – так, чтобы в случае отказа база данных вернулась в консистентное состояние. Но что происходит, если требуется только одна операция, как в примере выше?
Оказывается, что база данных гарантирует атомарность для (большинства) единичных SQL операторов; если происходит ошибка, вы не должны беспокоиться о частично выполненном состоянии. Это замечательно – значит, мы можем полностью удалить транзакцию при выполнении единичного оператора. Учитывая это, вот что выдает тот же самый код с EF Core 7.0:
```
info: 2022-07-10 17:24:28.740 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (52ms) [Parameters=[@p0='Foo' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET IMPLICIT_TRANSACTIONS OFF;
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Name])
OUTPUT INSERTED.[Id]
VALUES (@p0);
```
Намного короче – и без транзакции! Посмотрите, что эта оптимизация дает при тестировании с помощью [BenchmarkDotNet](https://benchmarkdotnet.org) (вы же не выполняете тестирование вручную с помощью Stopwatch, не так ли?).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Method** | **EF Version** | **Server** | **Mean** | **Error** | **StdDev** |
| Insert\_one\_row | 6.0 | Localhost | 522.9 us | 5.76 us | 5.10 us |
| Insert\_one\_row | 7.0 | Localhost | 390.0 us | 6.78 us | 8.82 us |
Прекрасно, имеем улучшение на 133 микросекунды, или 25%! Но поскольку мы обсуждаем издержки на сетевой обмен, вы должны спросить себя: где расположена база данных, и каковы задержки при обмене с ней? В таблице выше SQL сервер выполняется на локальной машине (там же, где и само приложение). Однако, так вы никогда не должны делать при анализе производительности: размещение базы данных на одной машине с приложением может вызвать влияние на работу приложения и исказить результат; в конце концов, вы бы не сделали такую конфигурацию на производстве, не так ли? Но что для нас более важно, сетевые задержки при подключении на localhost гораздо, гораздо ниже [чем при подключении на удаленную машину]– мы увидели *нижний предел* улучшения производительности.
Выполним ещё один запуск, на удаленной машине. В этом тесте, я подключаюсь с моего ноутбука на мой десктоп, через соединение WiFi. Это также не совсем реалистично: WiFi не лучший транспорт для такого рода вещей, ведь точно так же как вы не запускаете в производстве приложение на одной машине с базой данных, так и вы не подключаетесь к базе данных по WiFi, не так ли? Не хочу дискуссий о том, насколько близко это имитирует подключение к базе данных в производстве, например, к базе данных в облаке – вы можете легко выполнить тесты в своем реальном окружении. Вот мои результаты:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Method** | **EF Version** | **Server** | **Mean** | **Error** | **StdDev** |
| Insert\_one\_row | 6.0 | Remote | 8.418 ms | 0.1668 ms | 0.4216 ms |
| Insert\_one\_row | 7.0 | Remote | 4.593 ms | 0.0913 ms | 0.2531 ms |
Здесь совсем другая картина: мы выполнение сократили на 3.8 миллисекунды, или 45%. Величина в 3.8 мс уже считается значительным сокращением времени для отзывчивых веб приложений или API, так что это весомое достижение.
Прежде чем мы двинемся дальше, вы могли заметить и другие изменения запроса SQL в примере выше, помимо устранения команд транзакции:
* Появилась новая команда SET IMPLICIT\_TRANSACTIONS OFF. Если вдруг параметр “IMPLICIT\_TRANSACTIONS” в SQL Server установлен в значение ON, система находится в неявном режиме транзакции; выполнение единичного оператора вне транзакции неявно начинает новую транзакцию и не завершается автоматической фиксацией. Мы отключаем такое поведения явно, чтобы быть уверенными в том, что изменения зафиксированы. Накладные расходы на это незначительны.
* Вместо вставки строки и последующей выборки сгенерированного базой значения ID, оператор SQL использует предложение OUTPUT, чтобы вернуть значение непосредственно из оператора INSERT. Кроме того, что эта команда SQL короче, это необходимо для получения транзакционной гарантии без необходимости явного включения транзакции, как это было рассмотрено выше. Это здорово, что по сравнению с EF Core 6 получается сократить 2 оператора в случаях, когда значение идентификатора последней вставленной строки является локальным по отношению к [сетевому] соединению (scope\_identity), и значение ID не изменяется из EF. Впрочем, может быть множество случаев, когда это условие не выполняется (например: если, помимо идентификатора, были другие сгенерированные базой значения).
### Вставка нескольких строк
Рассмотрим, что происходит, когда мы вставляем несколько строк:
```
for (var i = 0; i < 4; i++)
{
var blog = new Blog { Name = "Foo" + i };
ctx.Blogs.Add(blog);
}
await ctx.SaveChangesAsync();
```
Под EF Core 6.0 видим следующий лог выполнения:
```
dbug: 2022-07-10 18:46:39.583 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 18:46:39.677 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (52ms) [Parameters=[@p0='Foo0' (Size = 4000), @p1='Foo1' (Size = 4000), @p2='Foo2' (Size = 4000), @p3='Foo3' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
DECLARE @inserted0 TABLE ([Id] int, [_Position] [int]);
MERGE [Blogs] USING (
VALUES (@p0, 0),
(@p1, 1),
(@p2, 2),
(@p3, 3)) AS i ([Name], _Position) ON 1=0
WHEN NOT MATCHED THEN
INSERT ([Name])
VALUES (i.[Name])
OUTPUT INSERTED.[Id], i._Position
INTO @inserted0;
SELECT [i].[Id] FROM @inserted0 i
ORDER BY [i].[_Position];
dbug: 2022-07-10 18:46:39.705 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
Это немного… неожиданно (и не интуитивно). В SQL Server существует оператор MERGE, который обычно предназначен для объединения двух таблиц, однако может быть использован и для других целей. Оказывается, использование MERGE для вставки четырех строк значительно быстрее чем 4 отдельных оператора INSERT – даже в пакетном режиме. Так что, выше происходит следующее:
1. Создается вре́менная таблица (оператор DECLARE @inserted0).
2. Используется MERGE для вставки в таблицу четырёх строк, сформированных из посланных в теле запроса параметров. Предложение OUTPUT (помните о нём?) выводит сгенерированные базой ID во временную таблицу.
3. Оператор SELECT извлекает IDs из временной таблицы [в порядке, соответствующем порядку входных параметров].
Замечу, что такая продвинутая, специфичная для SQL Server техника является хорошим примером того, как ORM, такая как EF Core, может помочь вам создать более эффективный запрос, чем написанный вручную. Конечно, вы можете использовать рассмотренную технику самостоятельно без использования EF Core, но в реальности немногие пользователи погружаются настолько глубоко в процесс оптимизации; а вот в EF Core вам даже не обязательно знать об этом.
Теперь сравним с тем, что происходит в EF Core 7.0:
```
info: 2022-07-10 18:46:56.530 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (25ms) [Parameters=[@p0='Foo0' (Size = 4000), @p1='Foo1' (Size = 4000), @p2='Foo2' (Size = 4000), @p3='Foo3' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET IMPLICIT_TRANSACTIONS OFF;
SET NOCOUNT ON;
MERGE [Blogs] USING (
VALUES (@p0, 0),
(@p1, 1),
(@p2, 2),
(@p3, 3)) AS i ([Name], _Position) ON 1=0
WHEN NOT MATCHED THEN
INSERT ([Name])
VALUES (i.[Name])
OUTPUT INSERTED.[Id], i._Position;
```
Транзакции больше нет; как указано выше – MERGE также является единичным оператором, выполнение которого защищено неявной транзакцией. Заметьте, что если бы мы использовали 4 отдельных оператора INSERT, мы бы не могли бы опустить операции начала и завершения транзакции (вместе со всеми накладными расходами); так что здесь использовано ещё одно преимущество использования оператора MERGE, в сочетании с базовой лучшей производительностью [задействованной в EF Core 6.0].
Но и другие шаги изменились: нет временной таблицы, и теперь сгенерированные базой IDs посылаются на клиент непосредственно из предложения OUTPUT. Посмотрим на тесты производительности этих двух вариантов:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Method** | **EF Version** | **Server** | **Mean** | **Error** | **StdDev** |
| Insert\_four\_rows | 6.0 | Remote | 12.93 ms | 0.258 ms | 0.651 ms |
| Insert\_four\_rows | 7.0 | Remote | 4.985 ms | 0.0981 ms | 0.1981 ms |
| Insert\_four\_rows | 6.0 | Local | 1.679 ms | 0.0331 ms | 0.0368 ms |
| Insert\_four\_rows | 7.0 | Local | 435.8 us | 7.85 us | 6.96 us |
Сценарий с удаленной базой почти на 8 миллисекунд быстрее, или на 61% производительнее. Сценарий с локальной базой впечатляет ещё больше: ведь экономия в 1.243 миллисекунды означает улучшение производительности на 74%; операция выполняется на EF Core 7.0 в четыре раза быстрее!
Заметим, что результат получен за счет двух разных оптимизаций: отказа от явной транзакции, как это обсуждалось выше, и оптимизации запроса MERGE, заключающейся в исключении использования временной таблицы.
#### Небольшое отступление: [MS] SQL Server и предложение OUTPUT
На этом этапе вам может стать интересно, почему EF Core до сих пор [т.е., до EF Core 7.0] не использовал предложение OUTPUT – без использования временной таблицы. В конце концов, новая команда SQL и проще, и быстрее.
К сожалению, SQL Server имеет некоторые ограничения, которые не позволяют использование OUTPUT в определенных сценариях. Наиболее важно то, что использование классификатора OUTPUT на таблице, в которой определены триггеры, не поддерживается и вызывает ошибку ([см. документацию MS SQL Server](https://docs.microsoft.com/sql/t-sql/queries/output-clause-transact-sql?view=sql-server-ver16#triggers)); а вот OUTPUT совместно с INTO (как использовано в MERGE в пакете EF Core 6.0) поддерживается. Первоначально, когда мы впервые разрабатывали EF Core, у нас была цель — чтобы всё работало во всех сценариях, чтобы сделать взаимодействие с пользователем максимально удобным; также мы не подозревали, как много накладных расходов добавляет вре́менная таблица. При внесении изменений в EF Core 7.0, мы рассматривали следующие варианты:
1. По умолчанию сохранить имеющееся медленное поведение, дав возможность пользователям использовать новую, более эффективную технологию [там, где это возможно] как опцию.
2. Переключиться на более эффективную технику и дать возможность возврата к прежнему поведению при использовании в таблице триггеров.
Это непростое решение – при внесении улучшений мы всегда стараемся не сломать поведение на стороне пользователя. Однако, учитывая огромный прирост производительности, и тот факт, что [в варианте 1] пользователи [скорее всего] даже не будут знать о возможности улучшения производительности [включением какой-то там опции], мы остановились на варианте номер 2. Пользователи, использующие в таблице триггеры, при обновлении до EF Core 7.0 получат информативное исключение, которое укажет им на вариант исправления, а все остальные получат значительное улучшение производительности без необходимости что-либо знать дополнительно [т.е., без знаний о подводных камнях на быстром течении. Извините, не смог удержаться].
### Дальнейшие оптимизации операций обмена: родительские и дочерние сущности
Давайте рассмотрим ещё один сценарий. На этот раз мы вставляем сущность (Blog) совместно с дочерней сущностью (Post):
```
ctx.Blogs.Add(new Blog
{
Name = "MyBlog",
Posts = new()
{
new Post { Title = "My first post" }
}
});
await ctx.SaveChangesAsync();
```
Операция генерирует следующее:
```
dbug: 2022-07-10 19:39:32.826 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 19:39:32.890 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (22ms) [Parameters=[@p0='MyBlog' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Name])
VALUES (@p0);
SELECT [Id]
FROM [Blogs]
WHERE @@ROWCOUNT = 1 AND [Id] = scope_identity();
info: 2022-07-10 19:39:32.929 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (3ms) [Parameters=[@p1='1', @p2='My first post' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Post] ([BlogId], [Title])
VALUES (@p1, @p2);
SELECT [Id]
FROM [Post]
WHERE @@ROWCOUNT = 1 AND [Id] = scope_identity();
dbug: 2022-07-10 19:39:32.932 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
Мы имеем четыре операции обмена: две в связи с обслуживанием транзакции, одну при вставке сущности Blog, и одну при вставке сущности Post (обратите внимание, каждое выполнение DbCommand приводит к циклу [сетевого] обмена). На сегодня EF Core [6.0] в процедуре SaveChanges чаще всего формирует пакетную обработку, что означает что множественные изменения посылаются в одной команде – для лучшей эффективности. Однако, в данном случае это невозможно: поскольку ключ родительской сущности Blog является столбцом IDENTITY, значение которого генерируется базой данных, мы должны получить сформированный ключ обратно прежде, чем мы сможем отправить запрос на вставку дочерней сущности Post, поскольку она должна содержать значение ключа родительской сущности. Это нормальное состояние дел, и мы мало что можем с этим поделать.
Давайте изменим наши сущности Blog и Post и используем GUID ключ вместо Int. По умолчанию, EF Core выполняет генерацию ключа GUID на клиенте, что означает что новый GUID генерируется [в EF Core] самостоятельно, вместо того чтобы это сделать в базе данных, как в случае со столбцом IDENTITY. При использовании EF Core 6.0, мы получаем следующее:
```
dbug: 2022-07-10 19:47:51.176 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 19:47:51.273 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (36ms) [Parameters=[@p0='7c63f6ac-a69a-4365-d1c5-08da629c4f43', @p1='MyBlog' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Id], [Name])
VALUES (@p0, @p1);
info: 2022-07-10 19:47:51.284 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (2ms) [Parameters=[@p2='d0e30140-0f33-4435-e165-08da629c4f4d', @p3='0', @p4='7c63f6ac-a69a-4365-d1c5-08da629c4f43' (Nullable = true), @p5='My first post' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Post] ([Id], [BlogId], [BlogId1], [Title])
VALUES (@p2, @p3, @p4, @p5);
dbug: 2022-07-10 19:47:51.296 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
К сожалению, Blog и Post всё ещё вставляются посредством отдельных команд. EF Core 7.0 покончил с этим [расточительством] и выполняет следующее:
```
dbug: 2022-07-10 19:40:30.259 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 19:40:30.293 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (26ms) [Parameters=[@p0='ce67f663-221a-4a86-3d5b-08da629b4875', @p1='MyBlog' (Size = 4000), @p2='127329d1-5c31-4001-c6a6-08da629b487b', @p3='0', @p4='ce67f663-221a-4a86-3d5b-08da629b4875' (Nullable = true), @p5='My first post' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Id], [Name])
VALUES (@p0, @p1);
INSERT INTO [Post] ([Id], [BlogId], [BlogId1], [Title])
VALUES (@p2, @p3, @p4, @p5);
dbug: 2022-07-10 19:40:30.302 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
Поскольку ключ сущности Blog генерируется на клиенте, нет необходимости ждать каких-либо сгенерированных базой значений, и два оператора INSERT объединяются в одну команду, что уменьшает количество циклов обмена.
Я знаю, что вы думаете: “*для получения этой оптимизации, с учетом данных обстоятельств, потребуется переход от Int IDs с авто-приращением к GUIDs*”. Прежде, чем вы ушли делать это, вы должны узнать, что EF Core также имеет фишку под именем HiLo, которая предоставляет аналогичные результаты с ключом типа Int. Когда HiLo сконфигурирована, EF создает в базе [***последовательность***](https://docs.microsoft.com/ru-ru/sql/relational-databases/sequence-numbers/sequence-numbers) ([database sequence](https://docs.microsoft.com/en-us/sql/relational-databases/sequence-numbers/sequence-numbers)), и получает интервал номеров из неё (по умолчанию 10 значений); эти заблаговременно полученные значения кэшируются в недрах EF Core, и используются всякий раз, когда необходимо вставить новую строку. Эффект от этого равнозначен применению GUID в примере выше: поскольку значение ключа из последовательности уже кэшировано локально, нет необходимости получать сгенерированное базой значение при вставке. Когда EF исчерпает полученные значения, она выполнит один запрос для получения следующего интервала значений, и т.д.
HiLo может быть установлено для свойства следующим образом:
```
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity().Property(b => b.Id).UseHiLo();
}
```
После этого, наш SaveChanges формирует такой же эффективный сценарий работы с базой, как и в случае с GUID:
```
dbug: 2022-07-10 19:54:25.862 RelationalEventId.TransactionStarted[20200] (Microsoft.EntityFrameworkCore.Database.Transaction)
Began transaction with isolation level 'ReadCommitted'.
info: 2022-07-10 19:54:25.890 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
Executed DbCommand (20ms) [Parameters=[@p0='1', @p1='MyBlog' (Size = 4000), @p2='1', @p3='My first post' (Size = 4000)], CommandType='Text', CommandTimeout='30']
SET NOCOUNT ON;
INSERT INTO [Blogs] ([Id], [Name])
VALUES (@p0, @p1);
INSERT INTO [Post] ([BlogId], [Title])
OUTPUT INSERTED.[Id]
VALUES (@p2, @p3);
dbug: 2022-07-10 19:54:25.909 RelationalEventId.TransactionCommitted[20202] (Microsoft.EntityFrameworkCore.Database.Transaction)
Committed transaction.
```
Обратите внимание, что оптимизация с сокращением операций обмена также выполняется и в некоторых других сценариях, включая шаблон сопоставления «[таблица на тип](https://docs.microsoft.com/ru-ru/ef/core/modeling/inheritance#table-per-type-configuration)» (TPT), случай, когда в одном вызове SaveChanges производится удаление и вставка строк в одну таблицу, и некоторые другие.
### Заключение
В этом посте мы рассмотрели три оптимизации в конвейере обновления EF Core 7.0:
1. Исключение явного оператора транзакции, когда SaveChanges выполняет единичный оператор (уменьшение на две операции обмена).
2. Оптимизация операции вставки нескольких строк, исключающая использование временной таблицы.
3. Исключение лишних операций обмена при выполнении вставки родительской и дочерней сущности в одной операции SaveChanges и в некоторых других случаях.
Мы считаем, что это важные улучшения, и надеемся, что они принесут пользу вашему приложению. Поделитесь своим опытом [применения], хорошим или плохим!
### Требования
* EF7 требует .NET 6.
* EF7 не работает под .NET Framework.
EF7 является преемником EF Core 6.0, не путайте с [EF6](https://github.com/dotnet/ef6). Если вы собираетесь переходить с EF6, пожалуйста прочитайте наше руководство [Перенос приложений из EF6 в EF Core](https://docs.microsoft.com/ef/efcore-and-ef6/porting/).
### Как загрузить EF7 previews
EF7 распространяется исключительно в виде набора пакетов NuGet. Например, чтобы добавить SQL Server provider в проект, вы должны выполнить из консоли следующую команду dotnet:
```
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 7.0.0-preview.6.22329.4
```
В следующей таблице собраны ссылки на пакеты EF Core 7 версии preview 6 и объяснения, для чего они используются.
| | |
| --- | --- |
| **Пакет** | **Назначение** |
| [Microsoft.EntityFrameworkCore](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore/7.0.0-preview.6.22329.4) | Основной EF Core пакет, независимый от провайдеров базы данных |
| [Microsoft.EntityFrameworkCore.SqlServer](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.SqlServer/7.0.0-preview.6.22329.4) | Провайдер базы данных для Microsoft SQL Server и SQL Azure |
| [Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite/7.0.0-preview.6.22329.4) | Поддержка SQL Server пространственных (географических) данных |
| [Microsoft.EntityFrameworkCore.Sqlite](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Sqlite/7.0.0-preview.6.22329.4) | Провайдер базы данных SQLite, включая исполняемые компоненты самой БД |
| [Microsoft.EntityFrameworkCore.Sqlite.Core](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Sqlite.Core/7.0.0-preview.6.22329.4) | Провайдер базы данных SQLite *без* исполняемых компонентов самой БД |
| [Microsoft.EntityFrameworkCore.Sqlite.NetTopologySuite](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Sqlite.NetTopologySuite/7.0.0-preview.6.22329.4) | Поддержка пространственных данных в SQLite |
| [Microsoft.EntityFrameworkCore.Cosmos](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Cosmos/7.0.0-preview.6.22329.4) | Провайдер базы данных Azure Cosmos DB |
| [Microsoft.EntityFrameworkCore.InMemory](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.InMemory/7.0.0-preview.6.22329.4) | Провайдер резидентной БД (in-memory database) |
| [Microsoft.EntityFrameworkCore.Tools](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Tools/7.0.0-preview.6.22329.4) | Команды EF Core PowerShell для консоли диспетчера пакетов Visual Studio; используйте это для интеграции таких инструментов, как формирование шаблонов и миграция, с Visual Studio. |
| [Microsoft.EntityFrameworkCore.Design](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Design/7.0.0-preview.6.22329.4) | Общие компоненты времени разработки для инструментов EF Core |
| [Microsoft.EntityFrameworkCore.Proxies](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Proxies/7.0.0-preview.6.22329.4) | Прокси-серверы с отложенной загрузкой и отслеживанием изменений |
| [Microsoft.EntityFrameworkCore.Abstractions](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Abstractions/7.0.0-preview.6.22329.4) | Вынесенные в изолированный пакет абстракции EF Core. Используйте его для добавления своей функциональности, например для расширения аннотаций данных, определенных в EF Core. |
| [Microsoft.EntityFrameworkCore.Relational](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Relational/7.0.0-preview.6.22329.4) | Совместно используемые компоненты для провайдеров реляционных баз данных. |
| [Microsoft.EntityFrameworkCore.Analyzers](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Analyzers/7.0.0-preview.6.22329.4) | Анализаторы C# для EF Core |
Мы также опубликовали 7.0 preview 6 релиз провайдера [Microsoft.Data.Sqlite.Core](https://www.nuget.org/packages/Microsoft.Data.Sqlite.Core/7.0.0-preview.5.XXXXX.X) для [ADO.NET](https://docs.microsoft.com/dotnet/framework/data/adonet/ado-net-overview).
### Установка интерфейса командной строки EF7 (CLI)
Прежде чем вы сможете выполнить команды EF7 Core migration или scaffolding, необходимо установить пакет командной строки (CLI package) как локальный или глобальный инструмент.
Для установки EF7 CLI в качестве глобального инструмента, выполните:
```
dotnet tool install --global dotnet-ef --version 7.0.0-preview.6.22329.4
```
Если пакет уже имеется, можно выполнить обновление следующей командой:
```
dotnet tool update --global dotnet-ef --version 7.0.0-preview.6.22329.4
```
Пакет новой версии EF7 CLI можно использовать также при работе с существующими проектами, использующими старшие версии EF Core runtime.
### Ежедневные сборки
Предварительные версии EF7 согласованы с предварительными версиями .NET 7. Эти предварительные версии, как правило, отстают от последней работы над EF7. Рассмотрите возможность использования ежедневных сборок, чтобы получить самые последние функции EF7 и исправления ошибок.
Как и в случае с предварительными версиями, для ежедневных сборок требуется .NET 6.
### Полезные ссылки
* [EF Core Community Standup Playlist: https://aka.ms/efstandups](https://aka.ms/efstandups)
* [Main documentation: https://aka.ms/efdocs](https://aka.ms/efdocs)
* [Issues and feature requests for EF Core: https://aka.ms/efcorefeedback](https://aka.ms/efcorefeedback)
* [Entity Framework Roadmap: https://aka.ms/efroadmap](https://aka.ms/efroadmap)
* [Bi-weekly updates: https://github.com/dotnet/efcore/issues/27185](https://github.com/dotnet/efcore/issues/27185)
### Благодарности от команды
Большое спасибо от команды разработчиков EF всем, кто использовал EF и помогал проекту на протяжении многих лет.
**Welcome to EF7.**
Shay Rojansky[**Shay Rojansky**](https://devblogs.microsoft.com/dotnet/author/shrojans) | https://habr.com/ru/post/678738/ | null | ru | null |
# Как я Magento изменял, или Меняем базовый функционал на простом примере
При разработке интерфейса магазина передо мной стояла задача не просто привести все к нужному виду и логике, но и обеспечить обновление версий движка, поэтому редактирование основных програмных модулей я исключил сразу. В качестве платформы был выбран Magento, который, как оказалось, предоставляет отличные средства для разработки собственных расширений, в том числе возможность замены стандартного функционала собственным. Этим мы и займемся.
Давайте рассмотрим конкретный пример. В большинстве магазинов копейки сейчас никто не использует, но по умолчанию — благодаря локали — они отображаются. Встала задача их убрать. Как выяснилось, можно сделать это простым редактированием компонента библиотеки Zend, но, во-первых, это противоречит первому предложению данного поста, а, во-вторых, мы же не ищем легких путей. :)
Итак, нам необходимо сделать следующее:
— переопределить класс, отвечающий за вывод форматированной цены;
— создать модуль, который будет этот класс содержать;
— сконфигурировать модуль так, чтобы переопределенный класс вызывался в случаях, при которых ранее активировался оригинальный класс;
— активировать новый модуль в системе.
Все приведенные пути относительны директории, в которую установлен Magento.
Как я уже говорил, Magento представляет хорошие возможности для разработки собственных модулей и расширения базового функционала. Основная часть рабочего кода системы (за исключением библиотек и фреймворков, на основе которых он написан) расположена в директории **app**. Если мы заглянем внутрь, то увидим там следующее содержимое:
app
|----- Mage.php
|----- code
|----- design
|----- etc
|----- locale
*Mage.php* — модуль, описывающий основной класс-хаб системы — Mage
*code* — весь код
*design* — как видно из названия, здесь располагаются описания дизайна: именно логика и шаблоны вывода блоков; описания непосредственно css-стилей, скрипты и картинки вынесены в отдельное место
*etc* — конфигурационные файлы
*locale* — базовые языковые файлы, или, другими словами, локализация вывода; под конкретный интерфейс локализованный вывод так же может быть частично или полностью переопределен в описаниях собственного интерфейса в поддиректориях design.
Для данной задачи нас интересует директория **code**. В ней мы видим три стандартные папки: *core* — содержит код основных модулей системы, а так же *community* и *local*, которые изначально пусты и предназначены для установки сторонних модулей (community) либо для разработанных самостоятельно (*local*). На самом деле различий между папкими никаких нет, но для удобства собственные модули будем складывать в папку *local*.
Итак, для начала нам нужно создать папку, которая будет содержать наши модули. Название этой папки будет являться названием пакета (package) модулей, которые мы разработам. Т.к. я разрабатывал модули под свой проект, папка у меня носит имя проекта — **Cifrum**.
`# pwd
//app/code
# ll -a
total 10
drwxrwxr-x 5 vlad www 512 18 апр 09:37 .
drwxrwxr-x 6 vlad www 512 29 апр 19:30 ..
drwxrwxr-x 3 vlad www 512 29 апр 19:30 community
drwxrwxr-x 4 vlad www 512 18 апр 09:37 core
drwxrwxr-x 3 vlad www 512 27 апр 02:37 local
# ll -a local
total 6
drwxrwxr-x 3 vlad www 512 27 апр 02:37 .
drwxrwxr-x 5 vlad www 512 18 апр 09:37 ..
drwxrwxr-x 6 vlad www 512 29 апр 23:48 Cifrum`
Далее необходимо создать директорию, в которой будет находится модуль, одним из классов которого мы и будем реализовывать необходимую функциональность. Стандартный модуль, отвечающий за форматирование цены, называется Core, поэтому я назвал свой CoreC.
Создайте следующую структуру директорий:
`# ll -1aR //app/code/local/
.
..
Cifrum
//app/code/local/Cifrum:
.
..
CoreC
//app/code/local/Cifrum/CoreC:
.
..
Block
Helper
Model
controllers
etc
sql`
Приведенный в конце список папок — стандартная структура модуля. Я не буду здесь подробно останавливаться на описании, если необходимо, вы можете ознакомиться с книгой [php|architect’s Guide to Programming with Magento](http://www.phparch.com/c/books/id/9780973862171 "php|architect’s Guide to Programming with Magento").
В данном случае нас будут интересовать две директории — это *etc*, в которой мы расположим файл *config.xml*, и *Model*, где и будет располагаться описание нашего класса.
Выводом форматированной цены занимается модуль Core, а конкректо класс Store, метод formatPrice(). Нам необходимо создать новый класс — наследник Mage\_Core\_Model\_Store и переопределить его метод.
Давайте создадим файл *Model/Store.php* со следующим содержимым:
``> php <br/
>
>
> /\*\*\*\*\*
>
>
>
> Trying to rewrite Core\_Model\_Store
>
>
>
> \*/
>
>
>
> // Описываем новый класс, наследующий стандартный класс, контролирующий работу с ценой
>
> // app/code/core/Mage/Core/Model/Store.php
>
>
>
> class Cifrum\_CoreC\_Model\_Store extends Mage\_Core\_Model\_Store
>
> {
>
>
>
>
>
> /\*\*
>
> \*
>
> \* formatPrice without decimals, for rubles only for right now
>
> \*
>
> \*/
>
>
>
> // Переопределяем функцию, форматирующую вывод
>
>
>
> public function formatPrice($price, $includeContainer = true)
>
> {
>
> if($this->getCurrentCurrency()) {
>
> $priceReturn = $this->getCurrentCurrency()->format($price, array(), $includeContainer);
>
>
>
> //Not the cleanest method but the fastest for now…
>
> if(preg\_match('/руб/i', $priceReturn)) {
>
> return $this->getCurrentCurrency()->format($price, array('precision' => 0), $includeContainer);
>
> } else {
>
> return $priceReturn;
>
> }
>
> }
>
>
>
> return $price;
>
> }
>
>
>
> }
>
>
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видно, мы берем код стандартной фукнции Mage_Core_Model_Store::formatPrice() и дописываем проверку на вхождение в строку подстроки “руб”. Не уверен, что будет работать на всех локалях (быть может, где-то фигурирует просто “р"), однако у меня работает.
Теперь нам необходимо указать, что же именно нужно делать с созданным нами классом. Для этого создаем *etc/config.xml* и наполняем его следующим:
``> </fontxml version="1.0"?>
>
> <config>
>
> <modules>
>
>
>
>
>
> <Cifrum\_CoreC>
>
> <version>0.0.1version>
>
> <depends>
>
>
>
> depends>
>
> Cifrum\_CoreC>
>
>
>
>
>
> modules>
>
> <global>
>
> <models>
>
>
>
>
>
>
>
> <core>
>
> <rewrite>
>
> <store>Cifrum\_CoreC\_Model\_Storestore>
>
> rewrite>
>
> core>
>
>
>
>
>
> models>
>
> <resources>resources>
>
> <blocks>blocks>
>
> <corec>
>
>
>
> corec>
>
> global>
>
> <adminhtml>
>
> <menu>menu>
>
> <acl>acl>
>
> <events>events>
>
> <translate>translate>
>
> adminhtml>
>
> <frontend>
>
> <routers>routers>
>
> <events>events>
>
> <translate>translate>
>
> <layout>layout>
>
> frontend>
>
> <default>
>
> <config\_vars>
>
>
>
> config\_vars>
>
> default>
>
> config>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Опять-таки, структура файла стандартная, нам нужно не все. Важные моменты я выделил комментариями. Вначале описываем название и версию нашего модуля, а ниже переопределяем с помощью тега системный вызов класса *store* модуля *core*.
Однако это не все. Нам нужно указать системе, что у нас есть новый модуль, активировать его.
Как вы помните, системные конфиги лежат в *app/code/etc*. Создаем и открываем файл *app/etc/modules/Cifrum\_All.xml*, который в моем случае содержит описание всех модулей пакета Cifrum.
``> </fontxml version="1.0"?>
>
> <config>
>
> <modules>
>
> <Cifrum\_CoreC>
>
> <active>trueactive>
>
> <codePool>localcodePool>
>
> Cifrum\_CoreC>
>
> modules>
>
> config>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На этом, собственно, все. Обновив страницу магазина, мы увидим, что десятые части рублей исчезли.
Если есть вопросы или уточнения — пишите, с удовольствием пообщаюсь.
P.S. Прошу прощения за дикую смесь русских и английских комментариев — русские добавил по ходу написания статьи, для себя писал английские.``` | https://habr.com/ru/post/63902/ | null | ru | null |
# Проверяем эмулятор GPCS4, или сможем ли когда-нибудь поиграть в «Bloodborne» на PC
Эмулятор – это приложение, способное имитировать запуск программы, предназначенной для одной платформы, на другой. Примером эмулятора является GPCS4, предназначенный для запуска игр для PS4 на PC. Недавно состоялся первый релиз GPCS4, и мы решили проверить этот проект. Давайте посмотрим, какие ошибки удалось найти PVS-Studio в исходном коде этого эмулятора.
### О проекте
GPCS4 – это эмулятор PlayStation 4, написанный на C и C++.
Изначально целью автора проекта было исследовать архитектуру PS4. Однако проект быстро развивался, и уже в начале 2020 года разработчикам GPCS4 удалось запустить на своём эмуляторе игру [We are Doomed](https://habr.com/ru/news/t/487050/). Это был первый успешный стабильный запуск на PC игры для PS4. Впрочем, сам игровой процесс пока что был далёк от идеала: игра тормозила, картинка дёргалась. Тем не менее, [основной разработчик проекта](https://github.com/Inori/) полон энтузиазма и продолжает совершенствовать эмулятор.
В конце апреля 2022 года состоялся [первый релиз GPCS4](https://github.com/Inori/GPCS4/releases/tag/v0.1.0). Я скачал и проверил версию 0.1.0 проекта. К слову, на момент публикации статьи уже вышел релиз 0.2.0 – проект развивается очень быстро. Давайте перейдём к ошибкам и недочётам, которые удалось найти анализатору PVS-Studio в первом релизе проекта GPCS4.
### Потерянный break
[V796](https://pvs-studio.com/ru/docs/warnings/v794) [CWE-484] It is possible that 'break' statement is missing in switch statement. AudioOut.cpp 137
```
static AudioProperties getAudioProperties(uint32_t param)
{
uint32_t format = param & 0x000000ff;
AudioProperties props = {};
switch (format)
{
// ....
case SCE_AUDIO_OUT_PARAM_FORMAT_S16_8CH_STD:
{
props.nChannels = 8;
props.bytesPerSample = 2;
props.audioFormat = RTAUDIO_FORMAT_SINT16;
break;
}
case SCE_AUDIO_OUT_PARAM_FORMAT_FLOAT_MONO:
{
props.nChannels = 1;
props.bytesPerSample = 4;
props.audioFormat = RTAUDIO_FORMAT_FLOAT32; // <=
}
case SCE_AUDIO_OUT_PARAM_FORMAT_FLOAT_STEREO:
{
props.nChannels = 2;
props.bytesPerSample = 4;
props.audioFormat = RTAUDIO_FORMAT_FLOAT32;
break;
}
}
return props;
}
```
В данном фрагменте кода для случая *SCE\_AUDIO\_OUT\_PARAM\_FORMAT\_FLOAT\_MONO* потерян *break*. Из-за этого количество каналов будет выставлено неправильно.
### Проверка указателя после использования
[V595](https://pvs-studio.com/ru/docs/warnings/v595/) The 'm\_moduleData' pointer was utilized before it was verified against nullptr. Check lines: 49, 53. ELFMapper.cpp 49
```
struct NativeModule { /*....*/ };
class ELFMapper
{
// ....
NativeModule *m_moduleData;
};
bool ELFMapper::validateHeader()
{
bool retVal = false;
auto &fileMemory = m_moduleData->m_fileMemory;
do
{
if (m_moduleData == nullptr)
{
LOG_ERR("file has not been loaded");
break;
}
// ....
} while (false);
return retVal;
}
```
В приведённом фрагменте указатель *m\_moduleData* сначала разыменовывается, а затем в цикле *do-while* сравнивается с *nullptr*.
Внимательные читатели могут возразить: "Может быть, на вход функции всегда приходит валидный указатель? А потом в цикле *do-while* этот указатель модифицируется и может стать нулевым? Тогда и ошибки тут нет". В данном случае это не так. Во-первых, из-за условия *while (false)* выполнится ровно одна итерация цикла. Во-вторых, указатель *m\_moduleData* [не модифицируется](https://github.com/Inori/GPCS4/blob/67442ae29df1916137a01b87b675375d8b48be0e/GPCS4/Loader/ELFMapper.cpp#L45-L88).
Другое возражение может заключаться в том, что взятие ссылки – это безопасно. Ведь использоваться эта ссылка будет, только если указатель валидный. Но нет, такой [код содержит неопределённое поведение](https://pvs-studio.com/ru/blog/posts/cpp/0306/). Это ошибка. Скорее всего, нужно сделать проверку указателя до его первого разыменования:
```
bool ELFMapper::validateHeader()
{
bool retVal = false;
do
{
if (m_moduleData == nullptr)
{
LOG_ERR("file has not been loaded");
break;
}
auto &fileMemory = m_moduleData->m_fileMemory;
// ....
} while (false);
return retVal;
}
```
### Повторное присвоение
[V519](https://pvs-studio.com/ru/docs/warnings/v519/) [CWE-563] The '\* memoryType' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 54, 55. sce\_kernel\_memory.cpp 55
```
int PS4API sceKernelGetDirectMemoryType(sce_off_t start, int *memoryType,
sce_off_t *regionStartOut, sce_off_t *regionEndOut)
{
LOG_SCE_DUMMY_IMPL();
*memoryType = SCE_KERNEL_WB_GARLIC;
*memoryType = SCE_KERNEL_WC_GARLIC;
return SCE_OK;
}
```
Как можно догадаться по названию *LOG\_SCE\_DUMMY\_IMPL*, реализация метода *sceKernelGetDirectMemoryType* ещё будет меняться. И всё же, два присваивания по одному и тому же адресу *memoryType* выглядят странно. Возможно, так получилось в результате неудачного слияния кода.
### Переполнение буфера
[V512](https://pvs-studio.com/ru/docs/warnings/v512/) [CWE-119] A call of the 'memset' function will lead to overflow of the buffer 'param->reserved'. sce\_gnm\_draw.cpp 420
[V531](https://pvs-studio.com/ru/docs/warnings/v531/) [CWE-131] It is odd that a sizeof() operator is multiplied by sizeof(). sce\_gnm\_draw.cpp 420
```
struct GnmCmdPSShader
{
uint32_t opcode;
gcn::PsStageRegisters psRegs;
uint32_t reserved[27];
};
int PS4API sceGnmSetPsShader350(uint32_t* cmdBuffer, uint32_t numDwords,
const gcn::PsStageRegisters *psRegs)
{
// ....
memset(param->reserved, 0, sizeof(param->reserved) * sizeof(uint32_t));
return SCE_OK;
}
```
Иногда бывает, что на одну и ту же строчку кода указывают сразу несколько диагностик PVS-Studio. Так получилось и в этом примере. В данном фрагменте кода в функцию *memset* передаётся неправильное значение третьим аргументом. Выражение *sizeof(param->reserved)* уже вернёт размер массива *param->reserved*. Умножение на *sizeof(uint32\_t)* увеличит это значение в 4 раза, и значение получится неправильным. Поэтому в результате вызова *memset* произойдёт выход за границу массива *param->reserved*. Нужно убрать лишнее умножение:
```
int PS4API sceGnmSetPsShader350( /*....*/ )
{
// ....
memset(param->reserved, 0, sizeof(param->reserved));
return SCE_OK;
}
```
Всего анализатор обнаружил 20 подобных переполнений, приведу ещё один пример:
[V512](https://pvs-studio.com/ru/docs/warnings/v512/) [CWE-119] A call of the 'memset' function will lead to overflow of the buffer 'initParam->reserved'. sce\_gnm\_dispatch.cpp 16
```
uint32_t PS4API sceGnmDispatchInitDefaultHardwareState(uint32_t* cmdBuffer,
uint32_t numDwords)
{
// ....
memset(initParam->reserved, 0,
sizeof(initParam->reserved) * sizeof(uint32_t));
return initCmdSize;
}
```
В этом фрагменте кода происходит выход за границу массива *initParam->reserved*.
### Учимся считать до семи, или ещё одно переполнение буфера
[V557](https://pvs-studio.com/ru/docs/warnings/v557/) [CWE-787] Array overrun is possible. The 'dynamicStateCount ++' index is pointing beyond array bound. VltGraphics.cpp 157
```
VkPipeline VltGraphicsPipeline::createPipeline(/* .... */) const
{
// ....
std::array dynamicStates;
uint32\_t dynamicStateCount = 0;
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_VIEWPORT;
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_SCISSOR;
if (state.useDynamicDepthBias())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_DEPTH\_BIAS;
if (state.useDynamicDepthBounds())
{
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_DEPTH\_BOUNDS;
dynamicStates[dynamicStateCount++] =
VK\_DYNAMIC\_STATE\_DEPTH\_BOUNDS\_TEST\_ENABLE;
}
if (state.useDynamicBlendConstants())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_BLEND\_CONSTANTS;
if (state.useDynamicStencilRef())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_STENCIL\_REFERENCE;
// ....
}
```
Анализатор предупреждает, что может произойти переполнение массива *dynamicStates*. В данном фрагменте кода есть 4 проверки:
* if (state.useDynamicDepthBias())
* if (state.useDynamicDepthBounds())
* if (state.useDynamicBlendConstants())
* if (state.useDynamicStencilRef())
Каждая из них – это проверка одного из независимых флагов. Например, проверка *if (state.useDynamicDepthBias())*:
```
bool useDynamicDepthBias() const
{
return rs.depthBiasEnable();
}
VkBool32 depthBiasEnable() const
{
return VkBool32(m_depthBiasEnable);
}
```
Получается, все эти 4 проверки могут быть истинными одновременно. Тогда выполнится 7 строк вида *'dynamicStates[dynamicStateCount++] = ....'*. На седьмой такой строке произойдёт обращение к *dynamicStates[6]*. Это выход за границу массива.
Для исправления нужно выделить память на 7 элементов:
```
VkPipeline VltGraphicsPipeline::createPipeline(/* .... */) const
{
// ....
std::array dynamicStates; // <=
uint32\_t dynamicStateCount = 0;
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_VIEWPORT;
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_SCISSOR;
if (state.useDynamicDepthBias())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_DEPTH\_BIAS;
if (state.useDynamicDepthBounds())
{
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_DEPTH\_BOUNDS;
dynamicStates[dynamicStateCount++] =
VK\_DYNAMIC\_STATE\_DEPTH\_BOUNDS\_TEST\_ENABLE;
}
if (state.useDynamicBlendConstants())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_BLEND\_CONSTANTS;
if (state.useDynamicStencilRef())
dynamicStates[dynamicStateCount++] = VK\_DYNAMIC\_STATE\_STENCIL\_REFERENCE;
// ....
}
```
### Неправильное использование флага
[V547](https://pvs-studio.com/ru/docs/warnings/v547/) [CWE-570] Expression 'nOldFlag & VMPF\_NOACCESS' is always false. PlatMemory.cpp 22
```
#define PAGE_NOACCESS 0x01
#define PAGE_READONLY 0x02
#define PAGE_READWRITE 0x04
#define PAGE_EXECUTE 0x10
#define PAGE_EXECUTE_READ 0x20
#define PAGE_EXECUTE_READWRITE 0x40
enum VM_PROTECT_FLAG
{
VMPF_NOACCESS = 0x00000000,
VMPF_CPU_READ = 0x00000001,
VMPF_CPU_WRITE = 0x00000002,
VMPF_CPU_EXEC = 0x00000004,
VMPF_CPU_RW = VMPF_CPU_READ | VMPF_CPU_WRITE,
VMPF_CPU_RWX = VMPF_CPU_READ | VMPF_CPU_WRITE | VMPF_CPU_EXEC,
};
inline uint32_t GetProtectFlag(VM_PROTECT_FLAG nOldFlag)
{
uint32_t nNewFlag = 0;
do
{
if (nOldFlag & VMPF_NOACCESS)
{
nNewFlag = PAGE_NOACCESS;
break;
}
if (nOldFlag & VMPF_CPU_READ)
{
nNewFlag = PAGE_READONLY;
}
if (nOldFlag & VMPF_CPU_WRITE)
{
nNewFlag = PAGE_READWRITE;
}
if (nOldFlag & VMPF_CPU_EXEC)
{
nNewFlag = PAGE_EXECUTE_READWRITE;
}
} while (false);
return nNewFlag;
}
```
Функция *GetProtectFlag* конвертирует флаг с правами доступа к файлу из одного формата в другой. Однако делает это некорректно. Программист не учёл, что значение *VMPF\_NOACCESS* равно нулю. Из-за этого условие *if (nOldFlag & VMPF\_NOACCESS)* всегда ложное и функция никогда не вернёт значение *PAGE\_NOACCESS*.
Кроме того, функция *GetProtectFlag* неправильно конвертирует не только флаг *VMPF\_NOACCESS*, но и другие. Например, флаг *VMPF\_CPU\_EXEC* будет сконвертирован во флаг *PAGE\_EXECUTE\_READWRITE*.
Когда я думал, как это исправить, первой мыслью было написать что-то в таком роде:
```
inline uint32_t GetProtectFlag(VM_PROTECT_FLAG nOldFlag)
{
uint32_t nNewFlag = PAGE_NOACCESS;
if (nOldFlag & VMPF_CPU_READ)
{
nNewFlag |= PAGE_READ;
}
if (nOldFlag & VMPF_CPU_WRITE)
{
nNewFlag |= PAGE_WRITE;
}
if (nOldFlag & VMPF_CPU_EXEC)
{
nNewFlag |= PAGE_EXECUTE;
}
return nNewFlag;
}
```
Однако в данном случае такой подход не работает. Дело в том, что *PAGE\_NOACCESS*, *PAGE\_READONLY* и остальные – это Windows-флаги со своей спецификой. Например, среди них нет флага *PAGE\_WRITE*. Считается, что если есть права на запись, то как минимум есть права еще и на чтение. По тем же причинам нет флага *PAGE\_EXECUTE\_WRITE*.
Кроме того, побитовое "ИЛИ" двух Windows-флагов не даёт в результате флаг, соответствующий сумме прав: *PAGE\_READONLY | PAGE\_EXECUTE != PAGE\_EXECUTE\_READ*. Поэтому нужно перебирать все возможные комбинации флагов:
```
inline uint32_t GetProtectFlag(VM_PROTECT_FLAG nOldFlag)
{
switch (nOldFlag)
{
case VMPF_NOACCESS:
return PAGE_NOACCESS;
case VMPF_CPU_READ:
return PAGE_READONLY;
case VMPF_CPU_WRITE: // same as ReadWrite
case VMPF_CPU_RW:
return PAGE_READWRITE;
case VMPF_CPU_EXEC:
return PAGE_EXECUTE;
case VMPF_CPU_READ | VMPF_CPU_EXEC:
return PAGE_EXECUTE_READ:
case VMPF_CPU_WRITE | VMPF_CPU_EXEC: // same as ExecuteReadWrite
case VMPF_CPU_RWX:
return PAGE_EXECUTE_READWRITE;
default:
LOG("unknown PS4 flag");
return PAGE_NOACCESS;
}
}
```
### Лишняя проверка
[V547](https://pvs-studio.com/ru/docs/warnings/v547/) [CWE-571] Expression 'retAddress' is always true. Memory.cpp 373
```
void* MemoryAllocator::allocateInternal(void* addrIn, size_t len,
size_t alignment, int prot)
{
// ....
while (searchAddr < SCE_KERNEL_APP_MAP_AREA_END_ADDR)
{
// ....
void* retAddress = VMAllocate(reinterpret_cast(regionAddress), len,
plat::VMAT\_RESERVE\_COMMIT, uprot);
if (!retAddress)
{
searchAddr = reinterpret\_cast(mi.pRegionStart) + mi.nRegionSize;
continue;
}
// ....
if (retAddress)
{
// unlikely
plat::VMFree(retAddress);
}
// ....
}
// ....
}
```
В этом фрагменте кода указатель *retAddress* проверяется дважды. Сначала делается проверка *if (!retAddress)*. Если указатель нулевой, то выполнение перейдёт к следующей итерации цикла *while*. Иначе указатель *retAddress* ненулевой. Поэтому вторая проверка *if (retAddress)* всегда истинная, и её можно убрать.
### Ещё одно всегда истинное условие
[V547](https://pvs-studio.com/ru/docs/warnings/v547/) [CWE-571] Expression 'pipeConfig == kPipeConfigP16' is always true. GnmDepthRenderTarget.h 170
```
uint8_t getZReadTileSwizzleMask(void) const
{
// From IDA
auto pipeConfig = getPipeConfig();
auto zfmt = getZFormat();
auto tileMode = getTileMode();
if (pipeConfig != kPipeConfigP16 || // <=
zfmt == kZFormatInvalid ||
!GpuAddress::isMacroTiled(tileMode))
{
return 0;
}
auto dataFormat = DataFormat::build(zfmt);
auto totalBitsPerElement = dataFormat.getTotalBitsPerElement();
uint32_t numFragments = 1 << getNumFragments();
uint32_t shift = 0;
NumBanks numBanks = {};
if (pipeConfig == kPipeConfigP16) // <=
{
GpuAddress::getAltNumBanks(&numBanks, tileMode,
totalBitsPerElement, numFragments);
shift = 4;
}
else
{
GpuAddress::getNumBanks(&numBanks, tileMode,
totalBitsPerElement, numFragments);
shift = 3;
}
return (this->m_regs[2] & (((1 << (numBanks + 1)) - 1) << shift)) >> 4;
}
```
В данном фрагменте кода анализатор нашёл всегда истинное условие *if (pipeConfig == kPipeConfigP16)*. Давайте разберёмся, почему это так.
Если вызов функции *getPipeConfig* вернул значение, не равное *kPipeConfigP16*, то первое условие будет верным и выполнение программы не достигнет проверки *if (pipeConfig == kPipeConfigP16)*.
Получается, что вторая проверка этой переменной либо не выполняется, либо всегда истинна. Но не стоит спешить и убирать её. Возможно, первое условие было добавлено временно и будет убрано в дальнейшем.
### Ошибка копипасты
[V517](https://pvs-studio.com/ru/docs/warnings/v517/) [CWE-570] The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 469, 475. GnmGpuAddress.cpp 469
```
int32_t sce::GpuAddress::adjustTileMode(/* .... */)
{
switch(microTileMode)
{
case Gnm::kMicroTileModeThin:
if (newArrayMode == Gnm::kArrayMode3dTiledThick)
*outTileMode = Gnm::kTileModeThick_3dThick;
else if (newArrayMode == Gnm::kArrayMode2dTiledThick)
*outTileMode = Gnm::kTileModeThick_2dThick;
else if (newArrayMode == Gnm::kArrayMode1dTiledThick)
*outTileMode = Gnm::kTileModeThick_1dThick;
else if (newArrayMode == Gnm::kArrayMode3dTiledThin)
*outTileMode = Gnm::kTileModeThin_3dThin; // ....
else if (newArrayMode == Gnm::kArrayMode3dTiledThinPrt)
*outTileMode = Gnm::kTileModeThin_3dThinPrt; // ....
else if (newArrayMode == Gnm::kArrayMode2dTiledThin) // <=
*outTileMode = Gnm::kTileModeThin_2dThin; // ....
else if (newArrayMode == Gnm::kArrayMode2dTiledThinPrt)
*outTileMode = Gnm::kTileModeThin_2dThinPrt; // ....
else if (newArrayMode == Gnm::kArrayModeTiledThinPrt)
*outTileMode = Gnm::kTileModeThin_ThinPrt; // ....
else if (newArrayMode == Gnm::kArrayMode2dTiledThin) // <=
*outTileMode = Gnm::kTileModeThin_2dThin;
else if (newArrayMode == Gnm::kArrayMode1dTiledThin)
*outTileMode = Gnm::kTileModeThin_1dThin;
else
break;
return kStatusSuccess;
// ....
}
}
```
Не обошлось и без ошибок копипасты. В данном фрагменте кода дважды написана одна и та же проверка *newArrayMode == Gnm::kArrayMode2dTiledThin*.
Сложно сказать, как именно нужно это поправить. Скорее всего, вторая проверка должна быть несколько другой. А может быть, она лишняя, и её можно убрать.
### Почему лучше избегать сложных выражений?
[V732](https://pvs-studio.com/ru/docs/warnings/v732/) [CWE-480] Unary minus operator does not modify a bool type value. Consider using the '!' operator. GnmRenderTarget.h 237
```
typedef enum RenderTargetChannelType
{
kRenderTargetChannelTypeUNorm = 0x00000000,
kRenderTargetChannelTypeSNorm = 0x00000001,
kRenderTargetChannelTypeUInt = 0x00000004,
kRenderTargetChannelTypeSInt = 0x00000005,
kRenderTargetChannelTypeSrgb = 0x00000006,
kRenderTargetChannelTypeFloat = 0x00000007,
} RenderTargetChannelType;
void setDataFormat(DataFormat format)
{
// ....
int v3;
RenderTargetChannelType type; // [rsp+4h] [rbp-3Ch]
__int64 v9; // [rsp+10h] [rbp-30h]
bool typeConvertable = format.getRenderTargetChannelType(&type);
v2 = type | kRenderTargetChannelTypeSNorm;
v3 = (uint8_t) - (type < 7) & (uint8_t)(0x43u >> type) & 1; // <=
// ....
}
```
Похоже, что программист ожидал следующего поведения при вычислении выражения:
* пусть переменная *type* меньше *7*;
* тогда выражение *type < 7* равно *true*;
* затем к *true* применяется унарный минус, получается *-1*;
* значение *-1* приводится к *unsigned char*, получается *0b1111'1111*.
Однако на самом деле происходит следующее:
* пусть переменная *type* меньше *7*;
* тогда выражение *type < 7* равно *true*;
* затем к *true* применяется унарный минус, получается *1*;
* значение *1* приводится к *unsigned char*, получается *0b0000'0001*.
Впрочем, следующая операция *& 1* приводит к одному и тому же результату. По этой счастливой случайности, код целиком работает так, как ожидает программист. Тем не менее, стоит поправить этот код. Попробуем понять, какое значение присваивается переменной *v3* в зависимости от значения *type*.
Первый случай: переменная *type* больше или равна 7.
* Тогда выражение *type < 7* равно *false*.
* К *false* применяется унарный минус, получается *false*.
* False приводится к unsigned char, получается *0b0000'0000*.
* Побитовое "И" с 0 всегда даёт 0, поэтому в результате получаем 0.
Второй случай: переменная *type* меньше 7.
* Как уже выяснили раньше, выражение *(uint8\_t) - (type < 7)* равно 1.
* В данном случае есть смысл вычислять выражение *0x43u >> type*.
* Для удобства запишем бинарное представление числа 0x43 = 0b0100'0011.
* Нас интересует только младший бит, потому что к результату выражения *0x43u >> type* применится побитовое "И" с 1.
* Если *type* равен 0, 1 или 6, то младший бит будет равен 1, и результат всего выражения будет 1. Во всех других случаях получится 0.
Итого, если type равен 0, 1 или 6, то в переменную v3 будет записано значение 1, а во всех остальных случаях – значение 0. Стоит заменить сложное выражение на более простое и понятное *(type == 0) || (type == 1) || (type == 6)*. Предлагаю следующий код:
```
typedef enum RenderTargetChannelType
{
kRenderTargetChannelTypeUNorm = 0x00000000,
kRenderTargetChannelTypeSNorm = 0x00000001,
kRenderTargetChannelTypeUInt = 0x00000004,
kRenderTargetChannelTypeSInt = 0x00000005,
kRenderTargetChannelTypeSrgb = 0x00000006,
kRenderTargetChannelTypeFloat = 0x00000007,
} RenderTargetChannelType;
void setDataFormat(DataFormat format)
{
// ....
int v3;
RenderTargetChannelType type; // [rsp+4h] [rbp-3Ch]
__int64 v9; // [rsp+10h] [rbp-30h]
bool typeConvertable = format.getRenderTargetChannelType(&type);
v2 = type | kRenderTargetChannelTypeSNorm;
v3 = (type == kRenderTargetChannelTypeUNorm)
|| (type == kRenderTargetChannelTypeSNorm)
|| (type == kRenderTargetChannelTypeSrgb);
// ....
}
```
Здесь я также заменил числа 0, 1 и 6 на соответствующие именованные значения перечисления и записал подвыражения в табличном виде.
### Краевой случай в операторе перемещения
[V794](https://pvs-studio.com/ru/docs/warnings/v794/) The assignment operator should be protected from the case of 'this == &other'. VltShader.cpp 39
```
VltShaderConstData& VltShaderConstData::operator=(VltShaderConstData&& other)
{
delete[] m_data;
this->m_size = other.m_size;
this->m_data = other.m_data;
other.m_size = 0;
other.m_data = nullptr;
return *this;
}
```
Если при вызове такого оператора окажется, что *'this == &other'*, то все поля текущего объекта будут очищены и данные потеряются. Такое поведение некорректно, нужно добавить проверку. Исправленный код:
```
VltShaderConstData& VltShaderConstData::operator=(VltShaderConstData&& other)
{
if (this == std::addressof(other))
{
return *this;
}
delete[] m_data;
this->m_size = other.m_size;
this->m_data = other.m_data;
other.m_size = 0;
other.m_data = nullptr;
return *this;
}
```
### Повторное присвоение как повод для рефакторинга
[V1048](https://pvs-studio.com/ru/docs/warnings/v1048/) [CWE-1164] The 'retVal' variable was assigned the same value. Module.cpp 129
```
bool NativeModule::getSymbolInfo( /* .... */) const
{
bool retVal = false;
do
{
uint32_t modId = 0, libId = 0;
if (modName == nullptr || libName == nullptr || nid == nullptr)
{
break;
}
if (!isEncodedSymbol(encSymbol))
{
*modName = "";
*libName = "";
*nid = 0;
retVal = true;
break;
}
retVal = decodeSymbol(encSymbol, &modId, &libId, nid);
if (!retVal)
{
LOG_ERR("fail to decode encoded symbol");
break;
}
retVal = getModNameFromId(modId, mods, modName);
if (!retVal)
{
LOG_ERR("fail to get module name for symbol: %s in %s",
encSymbol.c_str(), fileName.c_str());
break;
}
retVal = getLibNameFromId(libId, libs, libName);
if (!retVal)
{
LOG_ERR("fail to get library name");
break;
}
retVal = true; // <=
} while (false);
return retVal;
}
```
В данном фрагменте кода есть повторное присваивание значения *true* в переменную *retVal*. Давайте разберемся, почему так происходит. Для этого рассмотрим все возможные модификации переменной *retVal* до присваивания, указанного анализатором.
* Переменная *retVal* инициализируется значением *false*.
* Если вызов функции *isEncodedSymbol* вернул *false*, то переменной *retVal* присваивается значение *true* и прерывается цикл *do-while*.
* Переменной *retVal* присваивается результат вызова функции *decodeSymbol*. После этого если *retVal == false*, то цикл *do-while* прерывается.
* То же самое происходит и с двумя вызовами функции *getModNameFromId*. Если любой из вызовов вернёт *false*, то цикл *do-while* прерывается.
Заметим, что если цикл *do-while* был досрочно прерван, то и указанное анализатором присваивание не выполнится. Это значит, подозрительное присваивание *retVal = true* будет выполнено, только если все рассмотренные выше вызовы функций вернули *true*. Поэтому переменная *retVal* уже равна *true*, и присваивание не имеет смысла.
А зачем вообще использовать конструкцию '*do ... while(false)*'? Дело в том, что такая конструкция позволяет сделать ранний выход из функции с одним *return*. К функциям с одним *return*, в свою очередь, с большей вероятностью будет применена [NRVO](https://pvs-studio.com/ru/blog/terms/6516/) – named return value optimization. Эта оптимизация компилятора позволяет избежать лишнего копирования или перемещения возвращаемого объекта, конструируя его сразу на месте вызова функции. В данном случае функция возвращает легковесный тип *bool*, поэтому выигрыш от NRVO будет незначительным. Кроме того, современные компиляторы умеют применять NRVO и к функциям [с несколькими *return*](https://godbolt.org/z/GhTv4WTzr), если во всех *return* возвращается один и тот же объект.
Метод *getSymbolInfo* не содержит ошибки и работает так, как задумал программист. Однако стоит провести рефакторинг метода *getSymbolInfo* и убрать цикл *do-while* вместе с переменной *retVal*. Предлагаю следующий код:
```
bool NativeModule::getSymbolInfo( /* .... */) const
{
uint32_t modId = 0, libId = 0;
if (modName == nullptr || libName == nullptr || nid == nullptr)
{
return false;
}
if (!isEncodedSymbol(encSymbol))
{
*modName = "";
*libName = "";
*nid = 0;
return true;
}
if (!decodeSymbol(encSymbol, &modId, &libId, nid))
{
LOG_ERR("fail to decode encoded symbol");
return false;
}
if (!getModNameFromId(modId, mods, modName))
{
LOG_ERR("fail to get module name for symbol: %s in %s",
encSymbol.c_str(), fileName.c_str());
return false;
}
if (!getLibNameFromId(libId, libs, libName))
{
LOG_ERR("fail to get library name");
return false;
}
return true;
}
```
Здесь я сделал следующее:
* убрал цикл *do-while* и лишнюю переменную *retVal*;
* каждую проверку переменной *retVal* заменил на проверку результата вызова соответствующей функции;
* каждый *break* цикла *do-while* заменил на возврат нужного значения *true* / *false*. Какое именно значение вернуть, знаем из анализа переменной *retVal*, который провели ранее.
На мой взгляд, такой код проще читать и поддерживать.
### Заключение
Конечно, это не все ошибки и недочёты, которые мы нашли в GPCS4. Некоторые случаи было довольно сложно описать, поэтому я не включил их в статью.
Мы желаем разработчикам GPCS4 успехов в дальнейшем развитии эмулятора и рекомендуем проверить текущую версию проекта анализатором PVS-Studio. Для этого достаточно [скачать дистрибутив](https://pvs-studio.com/ru/pvs-studio/try-free/) анализатора и запросить бесплатную лицензию для Open Source проектов. Если вас заинтересовал статический анализ в целом и PVS-Studio в частности – самое время попробовать. Вы можете проверить GPCS4 вслед за нами, а можете проверить свой собственный проект:) Спасибо за внимание!
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку [**Checking the GPCS4 emulator: will we ever be able to play "Bloodborne" on PC?**](https://pvs-studio.com/en/blog/posts/cpp/0955/) | https://habr.com/ru/post/671754/ | null | ru | null |
# Советы и секреты №3
#### Как сжать Windows 10 и освободить место. Самый удобный аудио- и видеотранскодер под Windows, Mac и Linux. Аналог GitHub для внутреннего использования
**Как сжать Windows 10**
В июле 2016 года Microsoft выпустила для Windows 10 новый механизм компрессии [Compact OS](https://msdn.microsoft.com/windows/hardware/commercialize/manufacture/desktop/compact-os) для утилиты командной строки `compact.exe`, которая сжимает файлы операционной системы непосредственно во время её работы. У нового механизма компрессии есть много других интересных функций, но в целом он похож на работу программы WIMBoot в Windows 8.1 Update 1.
Compact OS освобождает [минимум 2 ГБ](http://www.ghacks.net/2016/07/28/free-up-windows-10-disk-space-with-compact-os/) места на диске. Не так уж и много, но на небольших SSD-накопителях это заметно.
Программа работает из командной строки с привилегиями администратора. Это значит, что после запуска *cmd.exe* следует нажать комбинацию клавиш Ctrl+Shift+Enter.
Перед началом сжатия Windows 10 есть смысл узнать, принесёт ли эта процедура результат, отличный от нулевого. Возможно, система уже находится в сжатом состоянии, так что дополнительных процедур не требуется. Чтобы определить текущее состояние бинарников ОС, запускаем следующую команду:
* compact.exe /q
Команда покажет информацию о текущем состоянии: сколько файлов сжато или не сжато, уровень компрессии, сколько конкретно байт находится в контейнере сжатых файлов. Если уровень компрессии близок к 1.0, то использование программы будет эффективно.
В определённых условиях система в сжатом состоянии может немного снизить производительность, но на большинстве компьютеров это будет незаметно. Имейте в виду, что всегда есть возможность вернуть файлы в обычное состояние, если заметите какие-то проблемы с производительностью. В любом случае, перед сжатием системных файлов рекомендуется сделать резервную копию.
Для проведения процедуры нужно запустить следующую команду:
* compact.exe /CompactOS:always
Сжатие всех файлов должно занять несколько минут, хотя на некоторых системах может занять 20 или более минут. На последнем Insider Build освобождается более 2 ГБ.
Для возвращения системы в исходное состояние:
* compact.exe /CompactOS:never
Обратная процедура происходит несколько быстрее.
**Удобная и бесплатная программа, которая конвертирует аудио- и видеофайлы в разные форматы**
Есть несколько программ, которые соответствуют главным требованиям:
* открытые исходники;
* бесплатное использование;
* поддержка многих форматов файлов;
* кроссплатформенность;
* легковесность.
Пожалуй, самыми удобными из них являются две: [Handbrake](http://handbrake.fr/) и ffmpeg (например, с графическим интерфейсом [WinFF](http://winff.org/html_new/)). Конвертировать файлы умеет, например, и популярный свободный видеоплеер VLC, но всё-таки в большинстве случаев удобнее использовать специализированную программу.
[Handbrake](http://handbrake.fr/) работает под Windows, Mac и Linux. Последней версией под Windows на данный момент является 0.10.5.
В качестве исходного материала принимается *практически любой* мультимедийный файл (или папка с файлами), диск DVD или BlueRay, если там нет защиты от копирования.
**Форматы целевого файла**
* **Контейнеры**: .MP4(.M4V) и .MKV
* **Видеокодеры**: H.265 (x265 и QuickSync), H.264 (x264 и QuickSync), H.265 MPEG-4 и MPEG-2, VP8, Theora
* **Аудиокодеры**: AAC / HE-AAC, MP3, Flac, AC3, Vorbis
* **Сквозная передача аудио**: AC-3, E-AC3, DTS, DTS-HD, TrueHD, AAC, треки MP3
Программу удобно использовать, чтобы перекодировать DVD или скачанный файл для просмотра на другом устройстве, кроме ПК. В Handbrake встроены профили кодирования для следующих устройств:
* iPod
* iPhone и iPod touch
* iPad
* AppleTV
* AppleTV 2
* AppleTV 3
* Android
* Android Tablet
* Windows Phone 8
В программе множество дополнительных функций.
* Выбор фрагментов (частей исходного файла для кодирования)
* Пакетная обработка и очередь запросов
* Маркеры глав
* Субтитры (VobSub, Closed Captions CEA-608, SSA, SRT)
* Постоянный битрейт или постоянное качество (переменный битрейт)
* Поддержка VFR, CFR и VFR
* Видеофильтры при транскодировании: Deinterlacing, Decomb, Denoise, Detelecine, Deblock, Grayscale, Cropping, Scaling
* Предварительный просмотр в реальном времени
Бóльшая часть исходного кода Handbrake распространяется под свободной лицензией GNU GPL, version 2. Отдельные части — под BSD 3 Clause.
Похожую функциональность обеспечивает ещё одна свободная программа [WinFF](http://winff.org/html_new/), которая как будто ориентирована на пользователей Linux (см. [список дистрибутивов](http://winff.org/html_new/downloads.html)), хотя есть версии под Windows от Windows 95 до Windows 8. Для неё разработаны интерфейсы на русском, украинском и многих других языках.
**Какой выбрать бесплатный VPN**
Для анонимной работы в интернете и обхода государственной цензуры (блокировка сайтов) удобно использовать бесплатный VPN. Одним из самых популярных вариантов является [FreeOpenVPN](https://www.freeopenvpn.org/) (через клиентское приложение OpenVPN).
Кстати, 31 июля 2016 года вышел Kaspersky Internet Security 2017 (популярный в России антивирус), в состав которого включён VPN-клиент. В бесплатном режиме он работает только через сервера в России и позволяет передавать 200 МБ в сутки. Конечно, это довольно убогое предложение, но если у вас уже установлен KIS 2017, то такой вариант следует иметь в виду. Только пользователям KIS не следует активировать функцию платного VPN в программе, потому что существует множество бесплатных альтернатив.
**Альтернатива GitHub для собственного хостинга**
Отличный выбор для self-hosted GitHub — [GitLab](https://about.gitlab.com/). Совместная разработка в собственном рабочем коллективе, на собственном сервере. Поддерживается система контроля версий Git, SSH-доступ, разграничение прав доступа, пулл-реквесты, работа с тикетами (открытие, комментирование, закрытие), поиск и т.д. Отличный веб-интерфейс, через который осуществляется администрирование репозиториев.
**[Демо](https://gitlab.com/explore)**
GitLab — разумное предложение для компаний, которые не хотят выкладывать исходный код в открытый доступ в процессе разработки. | https://habr.com/ru/post/396555/ | null | ru | null |
# Итоги 21-го конкурса IOCCC
Объявлены [победители](http://www.ioccc.org/2012/README.html) 21-го международного конкурса обфусцированного кода на C. Как обычно, участники удивили способностью втиснуть совершенно невероятные вещи в программы до 4096 байт. Чтобы получить максимальное удовольствие, организаторы конкурса рекомендуют смотреть [версию без спойлеров](http://www.ioccc.org/years.html#2012) и пытаться понять по коду программы, что она делает.
Например, что делает такая программа?
```
main(l
,a,n,d)char**a;{
for(d=atoi(a[1])/10*80-
atoi(a[2])/5-596;n="@NKA\
CLCCGZAAQBEAADAFaISADJABBA^\
SNLGAQABDAXIMBAACTBATAHDBAN\
ZcEMMCCCCAAhEIJFAEAAABAfHJE\
TBdFLDAANEfDNBPHdBcBBBEA_AL\
H E L L O, W O R L D! "
[l++-3];)for(;n-->64;)
putchar(!d+++33^
l&1);}
```
**Ответ**Правильно, печатает карту мира.
И не просто печатает, но ещё отмечает на карте место (символ `"` или [#](https://gist.github.com/3910435) с координатами, которые можно указать при запуске).
Кстати, это «лучшая маленькая программа» на IOCCC 1992 года.
Изобретатель бинарного лямбда-исчисления Джон Тромп представил на конкурс IOCCC программу [tromp.c](http://www.ioccc.org/2012/tromp/tromp.c) с минимальной реализацией бинарного λ-исчисления.
```
Int L[A],m,b,*D=A,
*c,*a=L,C,*U=L,u;s
(_){u--&&s(a=*a);}
char*B,I,O;S(){b=b
--?b:m|read(0,&I,1
)-1;return~I>>b&1;
}k(l,u){for(;l<=u;
U-L
```
Однако, не вошёл даже в тройку победителей.
**Первое место. Идеальная обфускация**
[zeitak.c](http://www.ioccc.org/2012/zeitak/zeitak.c)
Очень изощрённо обфусцированный код. Даже если анализировать деобфусцированную версию [zeitak\_deobfucate.c](http://www.ioccc.org/2012/zeitak/zeitak_deobfucate.c), то очень сложно понять, что она делает.
**Второе место. Самое простое использование C**
[hamano.c](http://www.ioccc.org/2012/hamano/hamano.c)
Смешная программка шифрует тексты по алгоритму [пляшущих человечков](https://en.wikipedia.org/wiki/The_Adventure_of_the_Dancing_Men), генерируя файлы PDF.
Ну, и код программы как бы намекает:
**Код**
```
#define \
D(s)"<<"#s">>"
#define q(s)p(#s)
#define S " endobj "
#define Y "endstream"S
#include
#define o(s) b[s]=\_;\
p("%u 0 obj",s);
#define E for (c=d;c < 123;c++)
#define DANCE "trailer "D\
(/Root 3 0 R /Size %d) "\nstartxref %u %%%%EOF\n\*/"
#define p(s, ...) \_+=printf(s, ##\_\_VA\_ARGS\_\_)
#define C "<>n&3|n\*2];
for(a=0;\*\_=\*s++;
a++,\_++,\*\_++=32)
{\*\_+=\*\_-32?10:0;
if(a%2&&\*\_/16==3
){if(g>>8)\*\_=105-\*\_;
\_++;\*\_++=32;\*\_=~-a&&a-13
?108:109;}}return n?n-9?nyan
(\_,y,n-2):\_:nyan(\_+=~y&' '?sprintf
(\_,17[w]):0,y,9);}N main(N c){A e[256];
p("/\*%%PDF-1.3%%\*/")-2;q(#include\n);
q(#define o \*\_++&& \*\_-41\n#define);p(" endstream ");q
(main(){for(;\*\_++; \*\_-40?:putchar(o?\*\_:o?10:41));\n)
;q(#define endobj return 0;}\n);q(typedef int ET;/)
;q(\*);o(1)\*b=~(p(D (/Length 2 0 R)"stream\n"))
;for(p("BT 12 818" " Td/%c 12 Tf 12 TL%%%c/"
"static char\*\_=\"" " \\\n",7[v],\*v/2);c=
getchar(),~c;c-10? p("/%c 12 Tf(\\%o)"
"Tj",v[~-c%' '<25[ v]&&!~-(~-c/'@')?0
:7],c):(p("()'"))) ;p("%%\";\nET ");\*
b-=~\_;p(Y"/\*");E{a =nyan(e+sprintf(e,
16[w]),c,6)-e;o(c- 59)p(D(/Length %d)
"stream\n%s"Y,a,e) ;}o(2)p(" %u"S,\*b);
o(3)p(D(/Pages 4 0 R)S);o(4)p(D(/Count
1/MediaBox[0 0 595 842]/Kids[5 0 R])S)
;o(5)p(C,4,0,6e-2, 6e-2f,d,122,d);E p(
"/%c",~-c/6+~14?c: d);q(]>>/CharProcs<<)
;E if(~-c/6+~14)p( "/%c %d 0 R",c,c+~58);
for(q(>>/Widths[), c=59;--c;p(" 10"));a=p
("]>>>>>>/Contents 1 0 R>>"S);for(p("xref\
0 %d ",--d);c
```
**Третье место. Стеганография**
[vik.c](http://www.ioccc.org/2012/vik/vik.c)
Приложение для стеганографии прячет картинку PNG или текст внутрь другой картинки PNG, а потом достаёт обратно. Секретные биты добавляются в нижние значения RGB. В качестве бонуса автор предоставил изображение шоколадных конфет, которое обладает уникальным качеством: после кодирования и последующего декодирования в изображении появляется код валидной программы на Brainfuck, причём запустить её можно без стороннего интерпретатора.
 | https://habr.com/ru/post/155335/ | null | ru | null |
# Динамическая таблица поверх Google Maps
Введение
========
Вам когда-нибудь нужно было отображать крупные массивы данных с привязкой к карте? Мне на работе понадобилось отображать заказы сгруппированные по широте и долготе. И не просто статической таблицей, а динамической, с разной детализацией для разного приближения карты.
К сожалению (или к счастью?), готовых решений я не нашёл. Google Карты позволяют накладывать маркеры и фигуры на карты, но эти способы представляют слишком мало информации. С Яндекс картами оказалось не лучше. Но Карты Гугл имеют механизм пользовательских наложений с HTML-содержанием. И для инкапсуляции этой работы с картами и наложениями я создал JavaScript библиотеку GMapsTable. Возможно, кому-нибудь она окажется интересной или полезной. [Рабочий пример.](http://www.aivanf.com/static/gmt/example.html)
**Условности**Чтобы не возникло путаницы, параметр zoom будем называть приближением карты, а scale — масштабом. Первый относится к Google Maps API, а второй к описываемой библиотеке.
Задача в целом
==============
Итак, что у нас есть? Какой-нибудь источник данных (например, сервер с базой данных, обрабатывающий и посылающий данные в формате JSON) и веб-страничка с JavaScript, которая запрашивает данные и визуализирует их на Картах Гугл.
Данные имеют аккумулятивную природу (в моём случае каждой области можно поставить в соответствие: число заказов, клиентов и среднюю сумму). Поэтому данные могут и должны отображаться с разной детализацией для разных приближений.
Основное содержание HTML страницы для GMapsTable:
```
..в :
..в :
```
GMapsTable позволяет абстрагироваться от взаимодействия с GoogleMaps API. Вам нужно лишь предоставить подходящий объект с данными. Время перейти к JavaScript'y! Чтобы использовать GMapsTable, нужно всего лишь получить объект DataContainer для Вашего div'a карты:
```
// Аргумент: ID div'а
// и словарь параметров GoogleMaps,
// это не обязательно
var container = new DataContainer("map", {
zoom: 9,
center: {lat: 55.7558, lng: 37.6173},
mapTypeId: 'roadmap'
});
```
И затем нужно передать парочку функции:
```
container.dataLoader = function (scale, borders) {
... вызвать container.processData(some_data);
}
container.scaler = function (zoom) {
... return какое-нибудь число;
}
```
Но что именно писать внутри функций?.. Для начала разберёмся, как работает GMapsTable.
Data для DataContainer
======================
`DataContainer` занимается отображением Ваших данных и заботится о том, когда оно должно быть обновлено. В самом начале и когда изменяются приближение и границы "камеры", он пробует использовать сохранённые данные, а если их нет, то вызывает функцию `dataLoader`. Вам нужно сгенерировать объект с данными и передать его функции DataContainer.processData. Структура объекта должна быть такая:
```
data: {
minLat: float,
difLat: float,
minLon: float,
difLon: float,
scale: int,
table: [
[value, value, ...],
[value, value, ...],
...
],
tocache: boolean
}
```
Значением (`value`) может быть число, строка или любой объект, если вы укажите собственную функцию форматирования ячейки таблицы. Масштаб (`sale`) это целое число, говорящее, на сколько частей должны делиться единицы широты и долготы. Параметр `tocache` указывает, должны ли данные для текущего масштаба быть сохранены и более не запрашиваться.
**Пример объекта данных**
```
data: {
minLat: 55.0,
difLat: 2.0,
minLon: 37.0,
difLon: 1.0,
scale: 2,
table: [
[1, 3, 0, 1],
[0, 1, 2, 0]
],
tocache: true
}
```
Здесь данные покрывают область от 55.0, 37.0 до 57.0, 38.0 и делят каждую единицу широты и долготы на 2 части (получается, одна клетка широты-долготы делится на 4 части). Также здесь указано, что для данного масштаба это полные данные, и они должны быть сохранены для использования в дальнейшем.
Перевод приближения в масштаб
=============================
Приближение (`zoom`) это параметр Google Maps API, целое число между 1 (карта мира) и 22 (улица). Запрашивать и хранить данные для каждой единицы приближения неудобно и нецелесообразно, поэтому GMapsTable переводит их в масштаб (`scale`) — число, указывающее, на сколько частей нужно делить единицу широты и долготы.
Сохранение данных
=================
Чтобы отображение при изменении масштаба было моментальным, GMapsTable хранит наборы данных для некоторых (либо всех) масштабов. Например, у меня была база данных с координатами почти со всей России — около 42 тысяч ячеек для масштаба 10 (500 КБ, довольно легко хранится и обрабатывается у меня в десктопном браузере) и 17 миллионов для масштаба 200 (несколько МБ, вызывает значительные подвисания). Поэтому сервер оценивает число ячеек всех данных, и если их немного, отправляет данные из всей БД, иначе только для запрошенного региона. Получается такой алгоритм:
Границы (`bounds`) — это объект JavaScript с полями `minlat, maxlat, minlon, maxlon` — текущими границами Google Maps и хорошим отступом про запас.
В Вашей реализации `dataLoader` Вы можете смело игнорировать аргументы, если нет нужды использовать разную детализацию для разных масштабов или если Ваши данные не покрывают такой большой регион. Просто передайте данные и их границы по широте и долготе и `scale`, на сколько разбиваете единицы широты-долготы. Но для полноты картины я предлагаю такое поведение функции `dataLoader` (или сервера, к которому она обращается):
Список всех параметров
======================
Вы можете указать такие параметры для DataContainer:
1) `scaler(zoom)` — переводит приближение из GoogleMaps в масштаб для GMapsTable. Оба целые числа.
2) `dataLoader(scale, borders)` — вызывается, когда нужны новые данные. Должен передать объект данных в `DataContainer.processData(data)`.
Аргумент `borders` это объект JavaScript с полями `minlat, maxlat, minlon, maxlon` — текущими границами Google Maps и хорошим отступом про запас.
3) `tableBeforeInit(map, table, data)` — вызывается перед тем, как таблица начинает заполняться ячейками. Аргумент `map` это объект Google Maps, `table` — HTML элемент созданной таблицы, а `data` — предоставленный Вами объект данных для текущего масштаба. Здесь можно настроить таблицу, какие-нибудь переменные в используя актуальные данные или текущие параметры карты.
4) `cellFormatter(td, val)` — вызывается для заполнения ячейки. `td` это HTML element, ячейка таблицы. `val` это данные из Вашего объекта данных. Здесь можно легко настроить вывод нескольких значений или заливку цветом в соответствии с какими-либо параметрами.
5) `boundsChangedListener(zoom)` — вызывается, когда изменяются границы Google Maps.
6) `minZoomLevel`, `maxZoomLevel` — переменные для минимального и максимального приближения карты. Целые числа между 1 (карта мира) и 22 (улица).
Для успешной работы DataContainer необходимы только первые две функции.
Пример и исходники
==================
Полный и хорошо прокомментированный пример использования: [HTML-страничка](http://www.aivanf.com/static/gmt/example.html) и [JS-код](http://www.aivanf.com/static/gmt/example.js).
А также есть [GMapsTable в GitHub](https://github.com/AivanF/GMapsTable). | https://habr.com/ru/post/330920/ | null | ru | null |
# Streaming API. Небольшой пример на PHP
Летом проходил конкурс от ВКонтакте на тему «Streaming API Contest». Я решил поучаствовать, но так как нормальной идеи для реализации всех возможностей Streaming API я не нашел, то решил просто выводить записи по указанным правилам.
**Подробнее о правилах**Правило — это набор ключевых слов, наличие которых в тексте объекта означает, что объект попадёт в поток. Если слова указаны без двойных кавычек, поиск ведётся с упрощением (все словоформы, без учёта регистра). Для поиска по точному вхождению (с учётом регистра, словоформы и т.п.) каждое слово должно быть указано в двойных кавычках.
Более подробно [здесь](https://vk.com/dev/streaming_api_docs).
Сначала думал реализовать все на Node.Js, но потом, чтобы не тратить время на его настройку на VPS сервере, решил использовать PHP.
Всю логику проекта решил отдать клиенту, на сервере же только небольшие настройки по работе с API ВКонтакте и анализатор.
Начнем с интересного — главного:
```
//все понятно и стандартно
var socket = new WebSocket("wss://streaming.vk.com/stream?key=" + window.key);
var close_connect = ge("close_connect");
/*
* Здесь еще очень много кода
*/
socket.onmessage = function(event) {
var incomingMessage = event.data;
var loading = document.getElementById("loading_text");
var preview = document.getElementById("preview_text");
var serf = document.getElementById("serf");
loading.classList.add("none");
preview.classList.add("none");
serf.classList.remove("none");
parser(event.data); //вот здесь начинается вся логика
console.log(event.data);
};
socket.onclose = function(event) {
if (event.wasClean) {
console.warn('Соединение закрыто чисто');
} else {
console.warn('Обрыв соединения');
}
console.info('Код: ' + event.code + ' причина: ' + event.reason);
var loading = ge("loading_text");
if (event.code == 1006) {
loading.innerHTML = "На этой планете уже есть человек, который сидит на этом сайте.
К сожалению - это не Вы. Повторите попытку позже.
Код ошибки - " + event.code;
} else {
loading.innerHTML = "Что-то или кто-то здесь не так...
Код ошибки - " + event.code;
}
};
socket.onerror = function(error) {};
//close connect
close_connect.addEventListener("click", function() {
socket.close();
close_connect.innerHTML = "Соединение закрыто клиентом.";
ge("analiz_block").classList.remove("none");
}, false);
```
Как стало понятно из кода выше, на сайте одна сессия для всех пользователей, т.е. пока кто-то уже сидит и парсит правила, другой не получит доступ к сайту.
**Здесь есть минус**Пока один человек создает правила и получает новости, другой может видеть эти самые правила и удалять их. Я заметил это поздно, после конкурса, поэтому не исправил.
Далее разберём основную функцию **parser(event.data)**. Я люблю шаблоны, ими легко управлять и с ними легко взаимодействовать.
**Много кода**
```
var parser = function(json) {
var response = JSON.parse(json);
console.log(response);
var code = response.code;
console.log(code);
if (code != 100) return;
var tpl_block = document.getElementById("tpl");
var tpl = tpl_block.innerHTML;
var main_tpl = tpl_block.innerHTML;
var content = document.getElementById("main").innerHTML;
var main = document.getElementById("main");
var time = response.event['creation_time'];
var date = new Date(time);
var type;
var cnt = ge("cnt");
var cnt_value = +cnt.innerHTML;
cnt.innerHTML = cnt_value + 1;
var creation_time = timestampToDate(response.event['creation_time'] * 1000);
if (response.event['event_type'] == "post") {
type = "Публикация";
count['post'] = ++count['post'];
} else if (response.event['event_type'] == "comment") {
type = "Комментарий";
count['comment'] = ++count['comment'];
} else if (response.event['event_type'] == "share") {
type = "Репост";
count['share'] = ++count['share'];
}
var photo_context;
if (response.event.attachments) {
//image
if (response.event.attachments[0].type == "photo") {
photo_context = '';
} else {
photo_context = "";
}
} else {
photo_context = "";
}
tpl = tpl.split("{event_type}").join(type);
tpl = tpl.split("{text}").join(response.event['text']);
tpl = tpl.split("{url}").join(response.event['event_url']);
tpl = tpl.split("{date}").join(creation_time);
tpl = tpl.split("{photo}").join(photo_context);
tpl = tpl.split("{type}").join(response.event['event_type']);
tpl = tpl.split("{cnt}").join(cnt_value+1);
tpl = tpl.split("\"").join("'");
if (filter.top) main.innerHTML = tpl + "" + content;
else main.innerHTML = content + "" + tpl;
//post_id
if (response.event['event_type'] != "comment") {
var post_owner_id = response.event.event_id['post_owner_id'];
var post_id = response.event.event_id['post_id'];
var wall_id = post_owner_id + "_" + post_id;
array_post_id.push(wall_id);
}
//limit
if (cnt_value + 1 >= +filter.limit) {
socket.close();
close_connect.innerHTML = "Достигнут лимит публикаций.";
ge("analiz_block").classList.remove("none");
}
}
```
Сам шаблон:
```
**{event\_type}**
{text}
{photo}
Дата публикации - {date}
[спам](javascript: return;)
[к публикации]({url})
```
В коде выше происходит:
1. Парс json с информацией о записях(комментарий, репост или же публикация)
2. Парс шаблона по информации, которую мы получили из json
Один шаблон под три разновидности публикации. Удобно.
Проект работает, записи выводятся, всё шикарно, но скучно. Сдавать таким проект на конкурс — это тоже самое, что не сдавать его. Поэтому было решено написать небольшой фильтр по записям, который умел бы показывать небольшую статистику. За основу взял информацию о количестве той или иной записи, общий охват, кнопка «Мне нравится» и репосты, а также средний возраст аудитории охвата и процентное соотношение пола.
**Анализ кода**
```
var analiz = {
start: function() {
//
if (count['post'] == 0 && count['comment'] == 0 && count['share'] == 0) {
alert("Невозможно запустить анализ. Причина - публикации не найдены.");
return;
}
var url = "/vk-competition/VKanaliz.php";
var loading = ge("loading_sp");
var button = ge("btn_analiz");
var analiz_stats = ge("analiz_stats");
loading.classList.remove("none");
button.classList.add("none");
ajax.post({
url: url,
data: "post_id=" + array_post_id.join(","),
callback: function(data) {
var resp = JSON.parse(data);
if (resp.error) {
alert(resp.error);
return;
} else {
var count_likes_all_ = resp.response.count_likes_all;
var count_share_all_ = resp.response.count_share_all;
var count_views_all_ = resp.response.count_views_all;
var analiz_posts = ge("analiz_post");
var analiz_share = ge("analiz_share");
var analiz_comments = ge("analiz_comments");
var analiz_likes = ge("analiz_likes");
var analiz_views = ge("analiz_views");
var analiz_reposts = ge("analiz_reposts");
var analiz_years = ge("analiz_years_");
var analiz_sex = ge("analiz_sex");
var percent_sex_m, percent_sex_w;
if (resp.response.percent_sex_w == "-")
percent_sex_w = 0;
else
percent_sex_w = resp.response.percent_sex_w;
if (resp.response.percent_sex_w == "-")
percent_sex_m = 0;
else
percent_sex_m = 100 - +percent_sex_w;
console.log("spam " + resp.response.spam + "%");
//insert data
analiz_posts.innerHTML = count['post'];
analiz_share.innerHTML = count['share'];
analiz_comments.innerHTML = count['comment'];
analiz_likes.innerHTML = count_likes_all_;
analiz_views.innerHTML = "≈" + count_views_all_;
analiz_reposts.innerHTML = count_share_all_;
analiz_sex.innerHTML = percent_sex_w + "%, " + percent_sex_m + "%";
analiz_years.innerHTML = resp.response.middle_years;
//show stats
loading.classList.add("none");
analiz_stats.classList.remove("none");
}
}
});
}
}
```
**VKanaliz.php** — файл, который возвращает данные в json. Его содержимое можно посмотреть [здесь](https://github.com/artemmolod/Streaming-API/blob/master/example/VKanaliz.php).
Что получилось в итоге? В итоге вышел небольшой проект, который позволяет анализировать публикацию, ее охват и обратную связь. Уже лучше прежнего.
→ Посмотреть пример в живую можно [здесь](https://cebattle.com/vk-competition/)
→ Исходный код доступен на [GitHub](https://github.com/artemmolod/Streaming-API)
Всем добра! | https://habr.com/ru/post/337874/ | null | ru | null |
# Практический пример создания собственного View-компонента
Мне нравится [Dribbble](https://dribbble.com/). Там есть много крутых и вдохновляющих дизайн-проектов. Но если вы разработчик, то часто чувство прекрасного быстро сменяется на отчаяние, когда вы начинаете думать о том, как реализовать этот крутой дизайн.
В этой статье я покажу вам пример такого дизайна и его реализацию, но перед этим давайте поговорим о решении проблемы в целом.
Самый простой способ — использовать какую-то библиотеку, закрывающую наши потребности. Теперь не поймите меня неправильно, я большой сторонник подхода «не изобретать велосипед». Есть отличные библиотеки с открытым исходным кодом, и когда мне будет нужно загружать изображения или реализовывать REST API, [Glide](https://github.com/bumptech/glide)/[Picasso](https://github.com/square/picasso) и [Retrofit](https://github.com/square/retrofit) очень здорово помогут мне.
Но когда вам нужно реализовать какой-то необычный дизайн, это не всегда лучший выбор. Вам нужно будет потратить время на поиск хорошей, поддерживаемой библиотеки, которая будет делать что-то подобное. Затем вам нужно заглянуть в код, чтобы убедиться, что там написано что-то адекватное. Вам нужно будет уделить больше времени пониманию настроек и конфигураций, которыми вы сможете управлять для использования библиотеки в ваших задачах. И давайте будем честными, скорее всего, библиотека не покроет ваших нужд на 100%, и вам нужно будет пойти на некоторые компромиссы с дизайнерами.
Поэтому я говорю о том, что зачастую проще и лучше создать свой собственный `View`-компонент. Когда я говорю «собственный `View`-компонент», я имею в виду расширение класса `View`, переопределение метода `onDraw()` и использование `Paint` и `Canvas` для рисования `View`-компонента. Это может показаться страшным, если вы не делали этого раньше, потому что у этих классов есть много методов и свойств, но вы можете сосредоточиться на основных:
* `canvas.drawRect()` — укажите координаты углов и нарисуете прямоугольник;
* `canvas.drawRoundRect()` — дополнительно укажите радиус, и углы прямоугольника будут закруглены;
* `canvas.drawPath()` — это более сложный, но и более мощный способ создания собственной фигуры с помощью линий и кривых;
* `canvas.drawText()` — для рисования текста на канвасе (с помощью `Paint` вы сможете контролировать размер, цвет и другие свойства);
* `canvas.drawCircle()` — укажите центральную точку и радиус и получится круг;
* `canvas.drawArc()` — укажите ограничивающий прямоугольник, а также начальный и поворотный углы для рисования дуги;
* `paint.style` — указывает, будет ли нарисованная фигура заполнена, обведена или и то, и другое;
* `paint.color` — указывает цвет (включая прозрачность);
* `paint.strokeWidth` — управляет шириной для обводки фигур;
* `paint.pathEffect` — позволяет влиять на геометрию рисуемой фигуры;
* `paint.shader` — позволяет рисовать градиенты.
Помните, иногда вам может понадобиться использовать другие API, но даже овладев этими методами, вы сможете рисовать очень сложные фигуры.
Практический пример
-------------------
Вот такой дизайн предлагает нам [Pepper](https://www.pepper.co.il/):
Здесь много чего интересного, но давайте разберём всё на мелкие кусочки.
### Шаг 1. Рассчитать позиции маркеров
```
private fun calcPositions(markers: List) {
val max = markers.maxBy { it.value }
val min = markers.minBy { it.value }
pxPerUnit = chartHeight / (max - min)
zeroY = max \* pxPerUnit + paddingTop
val step = (width - 2 \* padding - scalesWidth) / (markers.size - 1)
for ((i, marker) in markers.withIndex()) {
val x = step \* i + paddingLeft
val y = zeroY - entry.value \* pxPerUnit
marker.currentPos.x = x
marker.currentPos.y = y
}
}
```
Мы находим минимальное и максимальное значения, вычисляем соотношение пикселей на единицу, размер шага по горизонтали между маркерами и позиции X и Y.
### Шаг 2. Нарисовать градиент
```
// prepare the gradient paint
val colors = intArrayOf(colorStart, colorEnd))
val gradient = LinearGradient(
0f, paddingTop, 0f, zeroY, colors, null, CLAMP
)
gradientPaint.style = FILL
gradientPaint.shader = gradient
private fun drawGradient(canvas: Canvas) {
path.reset()
path.moveTo(paddingLeft, zeroY)
for (marker in markers) {
path.lineTo(marker.targetPos.x, entry.targetPos.y)
}
// close the path
path.lineTo(markers.last().targetPos.x, zeroY)
path.lineTo(paddingLeft, zeroY)
canvas.drawPath(path, gradientPaint)
}
```
Мы создаем фигуру, начиная с левого края, проводя линию между каждым маркером и завершая фигуру в начальной точке. Затем рисуем эту фигуру, используя краску с градиентным шейдером.
### Шаг 3. Нарисовать сетку
```
// prepare the guideline paint
dottedPaint.style = STROKE
dottedPaint.strokeWidth = DOTTED_STROKE_WIDTH_DP
dottedPaint.pathEffect = DashPathEffect(floatArrayOf(INTERVAL, INTERVAL), 0f)
private fun drawGuidelines(canvas: Canvas) {
val first = findFirstDayOfWeekInMonth(markers)
for (i in first..markers.lastIndex step 7) {
val marker = markers[i]
guidelinePath.reset()
guidelinePath.moveTo(entry.currentPos.x, paddingTop)
guidelinePath.lineTo(entry.currentPos.x, zeroY)
canvas.drawPath(guidelinePath, dottedPaint)
}
}
```
Мы настраиваем краску, чтобы она рисовала пунктиром. Затем мы используем специальный цикл языка Kotlin, который позволяет нам перебирать маркеры с шагом 7 (количество дней в неделе). Для каждого маркера мы берём координату X и рисуем вертикальную пунктирную линию от вершины графика до `zeroY`.
### Шаг 4. Нарисовать график и маркеры
```
private fun drawLineAndMarkers(canvas: Canvas) {
var previousMarker: Marker? = null
for (marker in markers) {
if (previousMarker != null) {
// draw the line
val p1 = previousMarker.currentPos
val p2 = marker.currentPos
canvas.drawLine(p1.x, p1.y, p2.x, p2.y, strokePaint)
}
previousMarker = marker
// draw the marker
canvas.drawCircle(
marker.currentPos.x,
marker.currentPos.y,
pointRadius,
pointPaint
)
}
}
```
Мы перебираем маркеры, рисуем для каждого из них закрашенный круг и простую линию от предыдущего маркера до текущего.
### Шаг 5. Нарисовать кнопки недель
```
private fun drawWeeks(canvas: Canvas) {
for ((i, week) in weeks.withIndex()) {
textPaint.getTextBounds(week, 0, week.length, rect)
val x = middle(i)
val y = zeroY + rect.height()
val halfWidth = rect.width() / 2f
val halfHeight = rect.height() / 2f
val left = x - halfWidth - padding
val top = y - halfHeight - padding
val right = x + halfWidth + padding
val bottom = y + halfHeight + padding
rect.set(left, top, right, bottom)
paint.color = bgColor
paint.style = FILL
canvas.drawRoundRect(rect, radius, radius, paint)
paint.color = strokeColor
paint.style = STROKE
canvas.drawRoundRect(rect, radius, radius, paint)
canvas.drawText(week, x, keyY, textPaint)
}
}
```
Мы перебираем метки недель, находим координату X середины недели и начинаем рисовать кнопку по слоям: сначала рисуем фон с закругленными углами, затем границу и, наконец, текст. Мы настраиваем краску перед рисованием каждого слоя.
### Шаг 6. Нарисовать числовые маркеры справа
```
private fun drawGraduations(canvas: Canvas) {
val x = markers.last().currentPos.x + padding
for (value in graduations) {
val y = zeroY - scale * pxPerUnit
val formatted = NumberFormat.getIntegerInstance().format(value)
canvas.drawText(formatted, x, y, textPaint)
}
}
```
Координата X — это позиция последнего маркера плюс некоторый отступ. Координата Y рассчитывается с использованием соотношения пикселей на единицу. Мы форматируем число в строку (при необходимости добавляем разделитель тысяч) и рисуем текст.
Вот и всё, теперь наш `onDraw()` будет выглядеть так:
```
override fun onDraw(canvas: Canvas) {
drawGradient(canvas)
drawGuidelines(canvas)
drawLineAndMarkers(canvas)
drawWeeks(canvas)
drawGraduations(canvas)
}
```
И объединение слоёв даст нам желаемый результат:
Итог
----
1. Не бойтесь создавать собственные `View`-компоненты (при необходимости).
2. Изучите основные API `Canvas` и `Paint`.
3. Разбивайте ваш дизайн на маленькие слои и рисуйте каждый независимо.
Что касается последнего пункта, для меня это один из лучших уроков программирования в целом: когда сталкиваетесь с большой и сложной задачей, разбейте её на более мелкие, более простые задачи. | https://habr.com/ru/post/433782/ | null | ru | null |
# Построение выпуклой 3D оболочки
Что? Зачем?
===========
Всем привет!
Я хотел бы рассмотреть задачу вычислительной геометрии, а именно **построение выпуклой 3D оболочки**. Как мне кажется, это и не самый сложный, и не самый простой алгоритм, который было бы очень интересно и полезно разобрать.
Если Вы никогда не сталкивались с такой задачей, думаю, Вам будет интересно узнать о ней, посмотреть что это такое.
Если Вы только что-то слышали о выпуклых оболочках, Вы сможете поподробнее разузнать о них.
Если же Вы гуру выпуклых оболочек, возможно, Вам понравится еще раз послушать решение интересной задачи.
---
Содержание
----------
* Что? Зачем?
* Что такое выпуклая оболочка?
* Общие слова
* Описание алгоритма
* Асимптотика
* Реализация алгоритма
* Полная реализация
---
*Выражаю благодарность [muji-4ok](https://habr.com/ru/users/muji-4ok/) за помощь в написании и редактировании статьи.*
Что такое выпуклая оболочка?
----------------------------
*Выпуклой оболочкой* множества X называется наименьшее выпуклое множество, содержащее множество X.
*Строго, но не очень понятно.* Сейчас попробую рассказать на примере:
Представим множество точек на плоскости, и, допустим, мы хотим узнать, какое минимальное количество точек надо соединить, чтобы всё оставшееся множество точек лежало внутри обведённой поверхности. Это и есть задача поиска минимальной выпуклой оболочки.
*На картинке красной линией показана выпуклая 2D оболочка*
*Как мы видим, многие точки не входят в оболочку*
Если мы поняли, что означает выпуклая оболочка, мы также сразу осознаем, что нам просто необходимо научиться ее строить, ведь зная оболочку мы сможем гораздо быстрее решать многие задачи, к примеру, просто рассматривая "внешние" точки оболочки, не обращая внимания на все точки внутри.
Общие слова
-----------
В данной статье мы будем рассматривать более сложную, чем на картинке, выпуклую оболочку, а точнее 3D оболочку. То есть наши точки будут располагаться в трехмерном пространстве, а наша оболочка будет объемной.
*В связи с этим возникает вопрос: если соединение точек на плоскости нам довольно понятно и привычно, что же мы будем делать в объёмном случае?*
Ответ простой — мы будем покрывать наше множество плоскостями.
Если пока не очень понятно что мы будем делать и как — так и должно быть. Пока можно представить, что у нас есть объёмный многогранник, и перед нами стоит задача: обернуть многогранник бумагой.
Вместо *многогранника* возьмем *подарок* и будем его обертывать подарочной, блестящей, бумагой.
Теперь мы можем понять, почему один из алгоритмов (который мы и будем рассматривать) поиска выпуклой оболочки называется **"завертывание подарка"**.
*Замечание* Алгоритм работает только если на вход подается множество точек, в котором никакие 4 не лежат в одной плоскости. То есть каждые 3 точки задают свою плоскость.
Описание алгоритма
------------------
В алгоритме будет несколько важных этапов, поэтому мы разобьем наше построение на меньшие подзадачи, и будем поочередно их решать.
Я прошу не обращать внимание на то, что получается так много текста, это сделано для упрощения понимания 3d манипуляций, каждый пункт расписывается очень подробно. На самом деле, каждый шаг достаточно интуитивен и несложен.
**1. Инициализация**
Нам необходимо найти грань, с которой начнется наш алгоритм, и, в отличии от последующих действий, первую сторону мы должны найти вручную.
Это уже непростая задача, и мы попробуем максимально подробно ее объяснить.
Первую точку мы выбираем минимальную по оси Z. Понятно, что можно было бы взять любую ось, но как бы "класть" наш подарок на минимальную точку по оси Z звучит интуитивно понятнее всего. То есть в нашем воображении координатная плоскость XY сместилась, и теперь находится на одном уровне с нашей точкой. Мы как бы положили подарок на стол. Очевидно, что найденная точка будет лежать в выпуклой оболочке. Назовем первую точку P, а плоскость, на которую мы "поставили" подарок — f.
Выбор второй точки посложнее, но все еще понятен. Мы берем точку Q, находим ее проекцию на плоскость f (точку prQ). Ищем такую точку, что угол между векторами (ориентированными) {P, Q} и {Q, prQ} минимальный — то есть отмеченный на картинке угол — наибольший. Так как треугольник будет максимально тупой, значит точка Q как бы будет лежать ниже всех остальных, если смотреть по полярному углу. Поэтому точка Q тоже всегда будет лежать в выпуклой оболочке.
Выбор третьей точки совсем интересен. Мы выбираем точку R, такую что нормаль к поверхности, образуемой P, Q и R будет образовывать с вектором (0, 0, 1) минимальный угол. То есть это поверхность, максимально приближенная к плоскости f — стремится к параллельной координатной плоскости XY. Как мне кажется, картинка с таким чертежом может только ухудшить понимание, поэтому лучше попробовать понять это без углубления в картинку. Очевидно, это будет наша нижняя плоскость, а значит точка R тоже будет лежать в выпуклой оболочке.
Для дальнейшего использования алгоритма, нам потребуется хранить векторы нормали к плоскости, и так как они ориентированы, возьмем за правило брать тот вектор, который смотрит наружу (для первой грани наш вектор смотрит куда-то вниз).
Также для удобства сделаем из нашей тройки точек левую тройку векторов, то есть просто расположим точки P, Q, R по часовой стрелке.
Та-дам! Инициализация закончилась, приступаем к добавлению граней.
**2. Итеративное рассмотрение ребер**
Как мне кажется, вторая, и последняя, часть алгоритма проще первой. То есть если Вы поняли идею инициализации, Вам будет довольно просто понять дальнейшее добавление ребер.
*Идея:* Мы храним ребра в стеке, поочередно достаем их и рассматриваем. Если мы видим, что грань, которую мы можем построить из этого ребра, еще не лежит в оболочке, мы добавляем новую (эту) грань (которая прилегает к этому ребру), а потом при необходимости добавляем в стек два ребра, которые опоясывают нашу грань. Естественно, мы смотрим, лежат ли наши ребра в нашей оболочке, и если да, то мы не добавляем их в стек.
*Начало:* Из инициализации мы знаем одну грань и три ребра, уже точно входящих в оболочку. Так что с них мы и начнем наш второй шаг: добавим три ребра в стек.
*Зам1.* Как мы выбираем нужную точку? Мы помним, что хотим хранить нормали к каждой добавленной поверхности. Настало время их использовать. На определенной итерации из стека было взято ребро E. Мы смотрим на все точки, кроме точек плоскости, в которой лежит ребро E — допустим рассматриваем точку R. И смотрим на угол между нормалями к плоскости грани (в которой уже лежит ребро E) и к плоскости, образованной ребром E и точкой R. Мы помним, что наши нормали смотрят во внешнюю сторону от оболочки, то есть мы выбираем грань, которая будет максимально внешней — а именно такая и лежит в выпуклой оболочке.
*Зам2.* Как мы поняли из предыдущего замечания, нам необходимо находить нормали, "смотрящие во внешнюю сторону", а значит когда мы добавляем ребро E в оболочку, мы добавляем его так, чтобы точки в ребре E находились по часовой стрелке.
*Зам3.* Как мы помним из идеи, Мы обязаны смотреть, нужно ли добавлять ребра. То есть мы точно добавляем грань, а вот одно, или оба ребра мы можем и не добавить. Мы должны проверить, лежит ли наше ребро в оболочке, и если лежит, не добавлять.
*Зам4.* Если мы достали ребро, значит уже одна грань прилежит к этому ребру. Но мы точно знаем, что к одному ребру может прилежать только два ребра в выпуклой оболочке. Именно поэтому после использования этого ребра, мы обязаны "закрыть" его, чтобы дальше к нему не прибавить ни одну грань.
*Зам5.* Если ребро помечено, как "закрытое" мы не должны ничего с ним делать, просто переходим к следующей итерации.
*Зам6.* Мы отдельно храним массив ребер, лежащих в нашей оболочке. И когда мы добавляем ребро в стек, мы на самом деле добавляем лишь индекс нашего ребра в массиве ребер из оболочки.
Если мы соблюли все пункты этого алгоритма, по выходе из стека (когда он станет пуст), мы построили нашу минимальную выпуклую 3D оболочку.
Асимптотика
-----------
Перед тем, как приступить к реализации алгоритма, давайте подумаем над его асимптотикой. Мы рассматриваем каждое ребро выпуклой оболочки, а затем смотрим на все точки нашего множества. Поэтому если мощность множества N, а в нашей оболочке H ребер, сложность алгоритма O(NH). В худшем случае H вырождается в 2N, и тогда алгоритм работает за O(N^2).
Возможно, это не лучшая асимптотика, ведь есть алгоритм Чана, работающий за O(NlogN), но лично мне кажется, что завертывание подарка лучше иллюстрирует сам процесс построения выпуклой оболочки. Хотя если мы вспомним построение 2D оболочки, которая довольно просто строится за O(NlogN), мы понимаем, что хоть мы и переходим в трехмерное измерение, и все вычисление становятся гораздо сложнее и непонятнее, по асимптотике мы ушли не так далеко.
А теперь, пожалуй, мы пришли к самому интересному: реализация алгоритма.
Реализация алгоритма
--------------------
Я постараюсь разбивать код на максимально мелкие части и объяснять смысл последовательно, тем не менее, некоторые части разбить не получится, и будет достаточно большой, хоть и не сложный, но сплошной код. В конце приведена полная реализация алгоритма на C++.
***Хранение точек.*** Мы будем хранить точки в структуре. Важно понимать, что зачастую, вместо точек мы будем подразумевать радиус-вектора. Как и у радиус-вектора у точки будут определены простейшие операторы. (для просмотра полной реализации, спуститесь в конец).
```
struct Point
{
coordinate x;
coordinate y;
coordinate z;
Point (coordinate x = 0, coordinate y = 0, coordinate z = 0) : x(x), y(y), z(z) {}
Point operator- (const Point& other) const;
Point operator+ (const Point& other) const;
bool operator!= (const Point& other) const;
bool operator== (const Point& other) const;
};
```
***Функции подсчета.*** Нам нужно уметь вычислять определители матриц 2х2 для дальнейшего подсчета векторного произведения (для нахождения нормалей).
```
coordinate Det2x2(coordinate a11, coordinate a12, coordinate a21, coordinate a22)
{
return a11 * a22 - a12 * a21;
}
```
Соответственно нужно уметь считать само векторное произведение (где точка A — стартовая — или по-другому точка начала координат для двух радиус-векторов AB и AC):
```
Point VectorProduct(const Point& A, const Point& B, const Point& C)
{
Point a = B - A;
Point b = C - A;
return Point (Det2x2(a.y, a.z, b.y, b.z),
Det2x2(a.x, a.z, b.x, b.z),
Det2x2(a.x, a.y, b.x, b.y));
}
```
Нужно уметь находить длину вектора (для нормализации и нахождения углов):
```
double GetLenghtVector(Point A, Point B = Point(0, 0, 0))
{
Point vec = B - A;
double lenght = std::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
return lenght;
}
```
Ну и конечно нужно находить угол между двумя векторами:
```
double GetAngle(const Point& n1, const Point& n2)
{
double len_n1 = GetLenghtVector(n1);
double len_n2 = GetLenghtVector(n2);
double scalar_prod = n1.x * n2.x + n1.y * n2.y + n1.z * n2.z;
if (scalar_prod == 0)
{
return 0;
}
return std::acos((scalar_prod) / (len_n1 * len_n2));
}
```
На этом малосодержательная и техническая часть заканчивается, начинается **построение минимальной выпуклой оболочки**.
***Грани и ребра.*** Мы будем хранить внутри нашей оболочки и грани, и ребра. В каждом ребре мы сохраняем номер нашей грани, ведь нам придется иногда обращаться к третьей точке нашей плоскости, также нам нужно будет знать нормаль к плоскости, в которой лежит данная точка, а ее логичнее хранить в структуре грани. Для оптимизации памяти и упрощения работы, мы будем хранить только номера наших точек, которые будут храниться в отдельном массиве.
```
struct Edge
{
int first;
int second;
int flatness; //номер грани
bool is_close = false; // открыто ли наше ребро, можно ли добавить еще грань?
Edge(int first, int second, int flatness = -1, Point normal = Point(0, 0 , 0)) :
first(first), second(second), flatness(flatness) {}
};
```
Далее объявим структуру Flatness — грани нашей оболочки. Там хранится 3 точки, нормаль к поверхности (направленная вовне оболочки). А также есть специальный метод — Another, который по двум точкам плоскости находит третью. (его реализация — просто три if — можно также посмотреть в конце.)
```
struct Flatness
{
int first;
int second;
int third;
Point normal; // нормаль к грани, изначально содержащее это ребро
Flatness(int first, int second, int third, Point normal) :
first(first), second(second), third(third), normal(normal) {}
int Another(int one, int two);
};
```
***Class Выпуклая оболочка.***
```
class ConvexHull
{
struct Flatness;
struct Edge;
std::vector points\_; // Точки изначального множества
std::vector verge\_; // Грани
std::vector edges\_; // Ребра
int count\_; // Количество точек изначального множества
int findMinZ() const;
void findFirstFlatness();
int returnIsEdgeInHull(int a, int b) const;
void makeHull();
public:
ConvexHull(const std::vector& points): points\_(points), count\_(points.size()) { makeHull(); }
};
```
*Вспомогательные методы*
Поиск первой точки: минимальной по оси Z (для упрощения, также сортируется и по остальным координатам в обратном лексикографическом порядке)
```
int ConvexHull::findMinZ() const
{
int min_id = 0;
for (int i = 1; i < count_; ++i)
{
if (points_[i].z < points_[min_id].z ||
(points_[i].z == points_[min_id].z && points_[i].y < points_[min_id].y) ||
(points_[i].z == points_[min_id].z && points_[i].y == points_[min_id].y &&
points_[i].x < points_[min_id].x))
{
min_id = i;
}
}
return min_id;
}
```
Проверка, лежит ли уже определенное определенное ребро в массиве ребер:
```
int ConvexHull::returnIsEdgeInHull(int a, int b) const
{
for (int i = 0; i < edges_.size(); ++i)
{
if ((edges_[i].first == a && edges_[i].second == b) ||
(edges_[i].first == b && edges_[i].second == a))
{
return i;
}
}
return -1;
}
```
***Сам алгоритм.*** *(наконец-то)*
Теперь поочередно будем смотреть на стадии работы алгоритма. Напомню, их две основных: инициализация и итеративное построение. Если кто-то не прочитал еще описание алгоритма, настоятельно рекомендую это сделать, ведь я буду опираться на данную там информацию.
*Шаг первый:*
```
void ConvexHull::findFirstFlatness()
{
int first_point, second_point, third_point; // наши первые три точки
first_point = findMinZ();
```
сейчас мы нашли первую точку, как минимальную по оси Z. Именно на эту точку мы будем класть наш "подарок".
```
double min_angle = 7; // Так как угол может быть от нуля до 2pi, он никогда не будет больше 7
int min_id = -1;
for (int i = 0; i < count_; ++i)
{
if (first_point == i) // наша вторая точка не должна совпадать с первой
{
continue;
}
Point start = points_[first_point];
Point next = points_[i];
double angle = GetAngle(start - next, next - Point(next.x, next.y, start.z));
if (min_angle > angle)
{
min_angle = angle;
min_id = i;
}
}
second_point = min_id;
```
В этой части мы нашли вторую точку, как минимальное отклонение от плоскости основания.
```
min_angle = 7;
min_id = -1;
for (int i = 0; i < count_; ++i)
{
if (first_point == i || second_point == i)
{
continue;
}
Point normal = VectorProduct(points_[first_point], points_[second_point], points_[i]);
double angle = GetAngle(Point(0, 0, 1), normal);
if (min_angle > angle)
{
min_angle = angle;
min_id = i;
}
}
third_point = min_id;
```
Третью точку мы находим такую, чтобы плоскость, проходящая через первые две и искомую точку была максимальна приближена к координатной плоскости XY, у которой нормаль (0, 0, 1). Что и отражено в поиске нашего угла.
И в конце мы должны правильно ориентировать наши три точки (как левая тройка векторов), добавить нулевую грань и правильно добавить наши три ребра в вектор ребер.
```
if (VectorProduct(points_[first_point], points_[second_point], points_[third_point]).z > 0)
{
std::swap (second_point, third_point);
}
Point new_normal = VectorProduct(points_[first_point], points_[second_point], points_[third_point]);
verge_.push_back(Flatness(first_point, second_point, third_point, new_normal)); // нулевая грань
edges_.push_back(Edge(first_point, second_point, 0));
edges_.push_back(Edge(second_point, third_point, 0));
edges_.push_back(Edge(third_point, first_point, 0));
}
```
*Шаг второй:*
Начинаем с вызова нашей функции инициализации и со скучного добавления первых ребер:
```
void ConvexHull::makeHull()
{
findFirstFlatness();
std::stack stack;
stack.push(0);
stack.push(1);
stack.push(2);
```
А вот теперь сердце нашего алгоритма: наш цикл, пока стек не пуст. Так как это единый блок, я разобью код всего на две части: нахождение точки и проверка ее корректности и добавление ребер в массив.
```
while (!stack.empty())
{
Point new_normal;
Edge e = edges_[stack.top()]; // берем верхнее ребро, рассматриваем его
stack.pop();
if (e.is_close) // если в ребро уже нельзя добавлять грани, мы этого не делаем
{
continue;
}
int min_id = -1;
double min_angle = 7;
for (int i = 0; i < count_; ++i)
{
int another = verge_[e.flatness].Another(e.first, e.second);
if (i != another && e.first != i && e.second != i) // проверка, что точка не из той же грани
{
// нахождение нормали к плоскости, образуемой ребром и i-ой точкой
Point current_normal = VectorProduct(points_[e.second], points_[e.first], points_[i]);
double angle = GetAngle(current_normal, verge_[e.flatness].normal);
if (min_angle > angle)
{
min_angle = angle;
min_id = i;
new_normal = current_normal;
}
}
}
```
Соответственно после нахождения такой точки надо проверить, есть ли уже ребра, ведущие из ребра e в найденную вершину, и при необходимости запомнить. Также если мы не добавляем ребро, то есть такое ребро уже присутствует в оболочке, мы красим его в is\_closed = true, ведь мы в любом случае добавляем грань, даже если это ребро уже есть в оболочке, а значит, к данному ребру будет примыкать два ребра — максимальное количество — наше добавленное и то, которое и добавило ребро е в оболочку.
```
if (min_id != -1) // защита от дурака - если в оболочке меньше 4х вершин
{
e.is_close = true; // раз мы рассмоттрели это ребро, значит добавили уже вторую грань к этому ребру
int count_flatness = verge_.size(); // номер нашей грани
int first_edge_in_hull = returnIsEdgeInHull(e.first, min_id); // возвращает -1, если ребра еще нет
int second_edge_in_hull = returnIsEdgeInHull(e.second, min_id);
if (first_edge_in_hull == -1)
{
edges_.push_back(Edge(e.first, min_id, count_flatness));
stack.push(edges_.size() - 1);
}
if (second_edge_in_hull == -1)
{
edges_.push_back(Edge(min_id, e.second, count_flatness));
stack.push(edges_.size() - 1);
}
if (first_edge_in_hull != -1)
{
edges_[first_edge_in_hull].is_close = true;
}
if (second_edge_in_hull != -1)
{
edges_[second_edge_in_hull].is_close = true;
}
verge_.push_back(Flatness(e.first, e.second, min_id, new_normal));
}
} // закрытие while
} // закрытие метода
```
**В заключение приведу полный код программы:**
```
#include
#include
#include
#include
#include
using coordinate = int64\_t;
struct Point;
coordinate Det2x2(coordinate a11, coordinate a12, coordinate a21, coordinate a22);
Point VectorProduct(const Point& A, const Point& B, const Point& C);
double GetLenghtVector(Point A, Point B);
double GetAngle(const Point& n1, const Point& n2);
struct Point
{
coordinate x;
coordinate y;
coordinate z;
Point(coordinate x = 0, coordinate y = 0, coordinate z = 0) : x(x), y(y), z(z) {}
Point operator-(const Point& other) const
{
return Point(x - other.x, y - other.y, z - other.z);
}
Point operator+(const Point& other) const
{
return Point(x + other.x, y + other.y, z + other.z);
}
bool operator!= (const Point& other) const
{
return (x != other.x || y != other.y || z != other.z);
}
bool operator== (const Point& other) const
{
return (x == other.x && y == other.y && z == other.z);
}
};
coordinate Det2x2(coordinate a11, coordinate a12, coordinate a21, coordinate a22)
{
return a11 \* a22 - a12 \* a21;
}
//[AB, AC]
Point VectorProduct(const Point& A, const Point& B, const Point& C)
{
Point a = B - A;
Point b = C - A;
return Point (Det2x2(a.y, a.z, b.y, b.z),
Det2x2(a.x, a.z, b.x, b.z),
Det2x2(a.x, a.y, b.x, b.y));
}
//vector AB
double GetLenghtVector(Point A, Point B = Point(0, 0, 0))
{
Point vec = B - A;
double lenght = std::sqrt(vec.x \* vec.x + vec.y \* vec.y + vec.z \* vec.z);
return lenght;
}
double GetAngle(const Point& n1, const Point& n2)
{
double len\_n1 = GetLenghtVector(n1);
double len\_n2 = GetLenghtVector(n2);
double scalar\_prod = n1.x \* n2.x + n1.y \* n2.y + n1.z \* n2.z;
if (scalar\_prod == 0)
{
return 0;
}
return std::acos((scalar\_prod) / (len\_n1 \* len\_n2));
}
class ConvexHull
{
struct Flatness
{
int first;
int second;
int third;
Point normal; // нормаль к грани, изначально содержащее это ребро
Flatness(int first, int second, int third, Point normal) :
first(first), second(second), third(third), normal(normal) {}
int Another(int one, int two)
{
if ((one == first && two == second) || (one == second && two == first))
{
return third;
}
if ((one == first && two == third) || (one == third && two == first))
{
return second;
}
if ((one == third && two == second) || (one == second && two == third))
{
return first;
}
return -1; // error
}
};
struct Edge
{
int first;
int second;
int flatness; //номер грани
bool is\_close = false;
Edge(int first, int second, int flatness = -1, Point normal = Point(0, 0 , 0)):
first(first), second(second), flatness(flatness) {}
};
std::vector points\_;
std::vector verge\_;
std::vector edges\_;
int count\_; // Количество точек изначального множества
int findMinZ() const;
void findFirstFlatness();
int returnIsEdgeInHull(int a, int b) const;
void makeHull();
public:
ConvexHull(const std::vector& points): points\_(points), count\_(points.size()) { makeHull();}
};
void ConvexHull::makeHull()
{
findFirstFlatness();
std::stack stack;
stack.push(0);
stack.push(1);
stack.push(2);
while (!stack.empty())
{
Point new\_normal;
Edge e = edges\_[stack.top()]; // берем верхнее ребро, рассматриваем его
stack.pop();
if (e.is\_close) // если в ребро уже нельзя добавлять грани, мы этого не делаем
{
continue;
}
int min\_id = -1;
double min\_angle = 7;
for (int i = 0; i < count\_; ++i)
{
int another = verge\_[e.flatness].Another(e.first, e.second);
if (i != another && e.first != i && e.second != i) // проверка, что точка не из той же грани
{
// нахождение нормали к плоскости, образуемой ребром и i-ой точкой
Point current\_normal = VectorProduct(points\_[e.second], points\_[e.first], points\_[i]);
double angle = GetAngle(current\_normal, verge\_[e.flatness].normal);
if (min\_angle > angle)
{
min\_angle = angle;
min\_id = i;
new\_normal = current\_normal;
}
}
}
if (min\_id != -1) // защита от дурака - если в оболочке меньше 4х вершин
{
e.is\_close = true; // раз мы рассмоттрели это ребро, значит добавили уже вторую грань к этому ребру
int count\_flatness = verge\_.size(); // номер нашей грани
int first\_edge\_in\_hull = returnIsEdgeInHull(e.first, min\_id);
int second\_edge\_in\_hull = returnIsEdgeInHull(e.second, min\_id);
if (first\_edge\_in\_hull == -1)
{
edges\_.push\_back(Edge(e.first, min\_id, count\_flatness));
stack.push(edges\_.size() - 1);
}
if (second\_edge\_in\_hull == -1)
{
edges\_.push\_back(Edge(min\_id, e.second, count\_flatness));
stack.push(edges\_.size() - 1);
}
if (first\_edge\_in\_hull != -1)
{
edges\_[first\_edge\_in\_hull].is\_close = true;
}
if (second\_edge\_in\_hull != -1)
{
edges\_[second\_edge\_in\_hull].is\_close = true;
}
verge\_.push\_back(Flatness(e.first, e.second, min\_id, new\_normal));
}
} // закрытие while
} // закрытие метода
int ConvexHull::findMinZ() const
{
int min\_id = 0;
for (int i = 1; i < count\_; ++i)
{
if (points\_[i].z < points\_[min\_id].z ||
(points\_[i].z == points\_[min\_id].z && points\_[i].y < points\_[min\_id].y) ||
(points\_[i].z == points\_[min\_id].z && points\_[i].y == points\_[min\_id].y &&
points\_[i].x < points\_[min\_id].x))
{
min\_id = i;
}
}
return min\_id;
}
void ConvexHull::findFirstFlatness()
{
int first\_point, second\_point, third\_point;
first\_point = findMinZ();
double min\_angle = 7;
int min\_id = -1;
for (int i = 0; i < count\_; ++i)
{
if (first\_point == i)
{
continue;
}
Point start = points\_[first\_point];
Point next = points\_[i];
double angle = GetAngle(start - next, next - Point(next.x, next.y, start.z));
if (min\_angle > angle)
{
min\_angle = angle;
min\_id = i;
}
}
second\_point = min\_id;
min\_angle = 7;
min\_id = -1;
for (int i = 0; i < count\_; ++i)
{
if (first\_point == i || second\_point == i)
{
continue;
}
Point normal = VectorProduct(points\_[first\_point], points\_[second\_point], points\_[i]);
double angle = GetAngle(Point(0, 0, 1), normal);
if (min\_angle > angle)
{
min\_angle = angle;
min\_id = i;
}
}
third\_point = min\_id;
// правильное ориентирование
if (VectorProduct(points\_[first\_point], points\_[second\_point], points\_[third\_point]).z > 0)
{
std::swap (second\_point, third\_point);
}
Point new\_normal = VectorProduct(points\_[first\_point], points\_[second\_point], points\_[third\_point]);
verge\_.push\_back(Flatness(first\_point, second\_point, third\_point, new\_normal)); // перая грань
edges\_.push\_back(Edge(first\_point, second\_point, 0));
edges\_.push\_back(Edge(second\_point, third\_point, 0));
edges\_.push\_back(Edge(third\_point, first\_point, 0));
}
int ConvexHull::returnIsEdgeInHull(int a, int b) const
{
for (int i = 0; i < edges\_.size(); ++i)
{
if ((edges\_[i].first == a && edges\_[i].second == b) ||
(edges\_[i].first == b && edges\_[i].second == a))
{
return i;
}
}
return -1;
}
```
Буду рад ответить на интересующие вопросы в комментариях и личных сообщениях. | https://habr.com/ru/post/529352/ | null | ru | null |
# Геометрические фигуры на CSS
[Отличная подборка](http://css-tricks.com/examples/ShapesOfCSS/), как нарисовать различные геометрические фигуры одним элементом HTML.
Квадрат
=======
```
#square {
width: 100px;
height: 100px;
background: red;
}
```
Прямоугольник
=============
```
#rectangle {
width: 200px;
height: 100px;
background: red;
}
```
Круг
====
```
#circle {
width: 100px;
height: 100px;
background: red;
-moz-border-radius: 50px;
-webkit-border-radius: 50px;
border-radius: 50px;
}
```
Овал
====
```
#oval {
width: 200px;
height: 100px;
background: red;
-moz-border-radius: 100px / 50px;
-webkit-border-radius: 100px / 50px;
border-radius: 100px / 50px;
}
```
Треугольник вверх
=================
```
#triangle-up {
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-bottom: 100px solid red;
}
```
Треугольник вниз
================
```
#triangle-down {
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-top: 100px solid red;
}
```
Треугольник налево
==================
```
#triangle-left {
width: 0;
height: 0;
border-top: 50px solid transparent;
border-right: 100px solid red;
border-bottom: 50px solid transparent;
}
```
Треугольник направо
===================
```
#triangle-right {
width: 0;
height: 0;
border-top: 50px solid transparent;
border-left: 100px solid red;
border-bottom: 50px solid transparent;
}
```
Треугольник в левом верхнем углу
================================
```
#triangle-topleft {
width: 0;
height: 0;
border-top: 100px solid red;
border-right: 100px solid transparent;
}
```
Треугольник в правом верхнем углу
=================================
```
#triangle-topright {
width: 0;
height: 0;
border-top: 100px solid red;
border-left: 100px solid transparent;
}
```
Треугольник в левом нижнем углу
===============================
```
#triangle-bottomleft {
width: 0;
height: 0;
border-bottom: 100px solid red;
border-right: 100px solid transparent;
}
```
Треугольник в правом нижнем углу
================================
```
#triangle-bottomright {
width: 0;
height: 0;
border-bottom: 100px solid red;
border-left: 100px solid transparent;
}
```
Параллелограмм
==============
```
#parallelogram {
width: 150px;
height: 100px;
-webkit-transform: skew(20deg);
-moz-transform: skew(20deg);
-o-transform: skew(20deg);
background: red;
}
```
Трапеция
========
```
#trapezoid {
border-bottom: 100px solid red;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
height: 0;
width: 100px;
}
```
Звезда (6-конечная)
===================
```
#star-six {
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-bottom: 100px solid red;
position: relative;
}
#star-six:after {
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-top: 100px solid red;
position: absolute;
content: "";
top: 30px;
left: -50px;
}
```
Звезда (5-конечная)
===================
```
#star-five {
margin: 50px 0;
position: relative;
display: block;
color: red;
width: 0px;
height: 0px;
border-right: 100px solid transparent;
border-bottom: 70px solid red;
border-left: 100px solid transparent;
-moz-transform: rotate(35deg);
-webkit-transform: rotate(35deg);
-ms-transform: rotate(35deg);
-o-transform: rotate(35deg);
}
#star-five:before {
border-bottom: 80px solid red;
border-left: 30px solid transparent;
border-right: 30px solid transparent;
position: absolute;
height: 0;
width: 0;
top: -45px;
left: -65px;
display: block;
content: '';
-webkit-transform: rotate(-35deg);
-moz-transform: rotate(-35deg);
-ms-transform: rotate(-35deg);
-o-transform: rotate(-35deg);
}
#star-five:after {
position: absolute;
display: block;
color: red;
top: 3px;
left: -105px;
width: 0px;
height: 0px;
border-right: 100px solid transparent;
border-bottom: 70px solid red;
border-left: 100px solid transparent;
-webkit-transform: rotate(-70deg);
-moz-transform: rotate(-70deg);
-ms-transform: rotate(-70deg);
-o-transform: rotate(-70deg);
content: '';
}
```
Пятиугольник
============
```
#pentagon {
position: relative;
width: 54px;
border-width: 50px 18px 0;
border-style: solid;
border-color: red transparent;
}
#pentagon:before {
content: "";
position: absolute;
height: 0;
width: 0;
top: -85px;
left: -18px;
border-width: 0 45px 35px;
border-style: solid;
border-color: transparent transparent red;
}
```
Шестиугольник
=============
```
#hexagon {
width: 100px;
height: 55px;
background: red;
position: relative;
}
#hexagon:before {
content: "";
position: absolute;
top: -25px;
left: 0;
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-bottom: 25px solid red;
}
#hexagon:after {
content: "";
position: absolute;
bottom: -25px;
left: 0;
width: 0;
height: 0;
border-left: 50px solid transparent;
border-right: 50px solid transparent;
border-top: 25px solid red;
}
```
Восьмиугольник
==============
```
#octagon {
width: 100px;
height: 100px;
background: red;
position: relative;
}
#octagon:before {
content: "";
position: absolute;
top: 0;
left: 0;
border-bottom: 29px solid red;
border-left: 29px solid #eee;
border-right: 29px solid #eee;
width: 42px;
height: 0;
}
#octagon:after {
content: "";
position: absolute;
bottom: 0;
left: 0;
border-top: 29px solid red;
border-left: 29px solid #eee;
border-right: 29px solid #eee;
width: 42px;
height: 0;
}
```
Сердечко
========
```
#heart {
position: relative;
width: 100px;
height: 90px;
}
#heart:before,
#heart:after {
position: absolute;
content: "";
left: 50px;
top: 0;
width: 50px;
height: 80px;
background: red;
-moz-border-radius: 50px 50px 0 0;
border-radius: 50px 50px 0 0;
-webkit-transform: rotate(-45deg);
-moz-transform: rotate(-45deg);
-ms-transform: rotate(-45deg);
-o-transform: rotate(-45deg);
transform: rotate(-45deg);
-webkit-transform-origin: 0 100%;
-moz-transform-origin: 0 100%;
-ms-transform-origin: 0 100%;
-o-transform-origin: 0 100%;
transform-origin: 0 100%;
}
#heart:after {
left: 0;
-webkit-transform: rotate(45deg);
-moz-transform: rotate(45deg);
-ms-transform: rotate(45deg);
-o-transform: rotate(45deg);
transform: rotate(45deg);
-webkit-transform-origin: 100% 100%;
-moz-transform-origin: 100% 100%;
-ms-transform-origin: 100% 100%;
-o-transform-origin: 100% 100%;
transform-origin :100% 100%;
}
```
Знак бесконечности
==================
```
#infinity {
position: relative;
width: 212px;
height: 100px;
}
#infinity:before,
#infinity:after {
content: "";
position: absolute;
top: 0;
left: 0;
width: 60px;
height: 60px;
border: 20px solid red;
-moz-border-radius: 50px 50px 0 50px;
border-radius: 50px 50px 0 50px;
-webkit-transform: rotate(-45deg);
-moz-transform: rotate(-45deg);
-ms-transform: rotate(-45deg);
-o-transform: rotate(-45deg);
transform: rotate(-45deg);
}
#infinity:after {
left: auto;
right: 0;
-moz-border-radius: 50px 50px 50px 0;
border-radius: 50px 50px 50px 0;
-webkit-transform:rotate(45deg);
-moz-transform:rotate(45deg);
-ms-transform:rotate(45deg);
-o-transform:rotate(45deg);
transform:rotate(45deg);
}
``` | https://habr.com/ru/post/126207/ | null | ru | null |
# Как установить лицензионную защиту кода на Python и обезопасить данные с помощью HASP?
Всем привет, я Вячеслав Жуйко – Lead команды разработки Audiogram в MTS AI.
При переходе от On-Cloud размещений ПО на On-Premises в большинстве случае перед вами неизбежно встанет задача защиты интеллектуальной собственности – и она особенно критична для рынка AI, где задействуются модели, обладающие высокой ценностью для компании. К тому же, в этой сфере широко используется интерпретируемый язык Python, ПО на котором содержит алгоритмы, являющиеся интеллектуальной собственностью компании, но фактически распространяется в виде исходных кодов. Это не является проблемой для On-Cloud решений, но в случае с On-Premises требует особой защиты как от утечек кода, так и самих данных.
Рассказываю реальную историю решения этой, казалось бы, не самой тривиальной задачи.
### Почему нам потребовалось шифровать код и данные
Мы с коллегами разрабатываем Audiogram — платформу синтеза и распознавания речи. Она состоит из большого количества микросервисов, связанных между собой. Обычно мы разворачивали это решение On-Cloud, и поэтому задачи защитить код у нас не возникало. Однако все изменилось, после того как к нам пришел заказчик, которому нужно было установить Audiogram On-Premises. Мы не могли передать код программы клиенту — это создало бы опасность кражи нашей интеллектуальной собственности. Именно поэтому мы начали искать способ зашифровать информацию и остановились на одном простом и эффективном варианте. Далее я расскажу подробнее, как сгенерировать и зашифровать код. Итак, разберем все по шагам.
### Генерируем из кода на Python код на C++
Для простоты представим, что у нас уже есть минимальный проект на Python, который загружает файл с данными, а затем использует их. Пусть это будет совсем просто:
```
with open(path, 'rb') as f:
data = f.read()
use_data(data)
```
Понятно, что мы не можем передавать заказчику ни исходный код, ни тем более данные. Последние предстоит зашифровать, а код обфусцировать.
В случае с кодом я использовал Cython – для генерации из кода на Python кода на C или C++. Вообще способы генерации могут быть разными, а самым распространенным является Setuptools. Однако сходу у меня не вышло написать setup.py для генерации исполняемого файла (не библиотеки), поэтому пошел путем использования Cython через коммандную строку.
Примеры вызовов Cython:
```
cython -3 --no-docstrings --fast-fail --output-file lib.c lib.py
cython -3 --no-docstrings --fast-fail --cplus --output-file lib.cpp lib.py
cython -3 --no-docstrings --fast-fail --embed --output-file app.c app.py
```
Рассмотрим используемые параметры:
`-3` -- версия Python
`--no-docstrings` -- не включает Python Docstrings в сгенерированный файл
`--fast-fail` -- процесс генерации прерывается по первой ошибке
`--embed` -- включает функцию `main()`, что позволяет собрать как исполняемый файл и запускать не через интерпретатор, а напрямую: `./app`
`--cplus` -- генерирует `C++` вместо `C`
Теперь полученные C или C++ файлы нужно собрать. Безусловно, применить можно разные подходы, в том числе написать Makefile. Я пошел схожим путем, как и в случае с Cython, и вызвал сборку из командной строки. Если попробуете повторить, сначала убедитесь, что у вас установлены пакеты `build-essential python-dev-is-python3`.
Примеры вызова сборки из коммандной строки:
```
gcc $(python3.8-config --cflags) -fPIC -g0 -s -shared lib.c -o lib.so
gcc $(python3.8-config --cflags) -fPIC -g0 -s app.c -o app $(python3.8-config --libs --embed)
```
Рассмотрим используемые параметры:
`python3.8-config --cflags` -- возвращает CFLAGS
`-fPIC` -- генерировать позиционно независимый код
`-g0` -- не включать информацию для отладки
`-s` -- удаляет таблицу символов и информацию о релокации
`-shared` -- собирает динамическую библиотеку
`python3.8-config --libs --embed` -- возвращает строку с библиотеками для линкера
Параметры `-g0` и `-s` я добавил для затруднения отладки.
Написал скрипт на Python, который проходится по дереву исходников и выполняет две вышеописанные операции: ситонизирует и собирает, после чего удаляет исходник.
Итак, с кодом разобрались – мы больше не поставляем исходники, заменив их на бинарные ELF файлы без Python Docstrings и отладочной информации. Кстати, приятный бонус – ситонизация может увеличить скорость работы по сравнению с Python, особенно если используется type hinting.
Все ли всегда так гладко? Увы, нет. Cython отстает по фичам от Python, например, не поддерживаются "the walrus operator", Data Classes, а функции из inspect возвращают неадекватные результаты – это только то, с чем столкнулись мы. Это все неприятно, но жить с этим можно. К тому же, где-то с проблемой можно справиться, например, в случае с Data Classes достаточно добавить annotations вручную, после чего их можно использовать.
### Шифруем данные
Теперь нам осталось зашифровать данные. Для шифрования используем SDK от одного из решений для HASP, в нашем случае это Sentinel.
Средства шифрования файлов в SDK предоставляются ["из коробки"](https://docs.sentinel.thalesgroup.com/ldk/LDKdocs/SPNL/LDK_SLnP_Guide/Protection/Data_File_Protection/0_datahasp_working_with.htm). Данные зашифрованы, теперь предстоит научить наш код на Python их расшифровывать. Сделать это можно, просто добавить вызов:
```
with open(path, 'rb') as f:
data = f.read()
data = decrypt(data)
use_data(data)
```
Правда, сосчитав количество вариантов загрузки данных из файла в реальном коде, я решил все же пойти другим путем. В самых общих словах – где-то данные загружаются как в приведенном примере, где-то построчно, а самое страшное: `f` передается как параметр в сторонний пакет, в который не хотелось бы погружаться вообще.
В итоге, показалось проще сделать на основе Sentinel SDK статическую библиотеку на C++ libsentinel.a с единственной экспортируемой функцией:
```
std::vector sentinel\_decrypt(const std::string& path);
```
Почему именно статическую? Если в файловой системе будет лежать библиотека libsentinel.so с экспортируемой функцией sentinel\_decrypt(), воспользоваться ей сможет любой.
Написал на Cython подмену стандартного механизма чтения файла:
```
import os
import io
from typing import Union, List, AnyStr, Iterator
from libcpp.vector cimport vector
from libcpp.string cimport string
cdef extern from "sentinel.h":
vector[unsigned char] sentinel_decrypt(const string& path) except +
def sentinel_open(path: Union[str, bytes, os.PathLike], mode: str, **kwargs) -> 'SentinelFileIo':
return SentinelFileIo(path, mode, **kwargs)
class SentinelFileIo:
def init(self, path: Union[str, bytes, os.PathLike], mode: str, **kwargs) -> None:
if isinstance(path, os.PathLike):
path = str(path)
if isinstance(path, str):
path = path.encode('utf-8')
data = bytes(sentinel_decrypt(path))
encoding = kwargs.get('encoding', None)
if encoding is not None:
data = data.decode(encoding)
self._data = data
self._size = len(self._data)
self._pos = 0
def close(self) -> None:
self._data = None
def closed(self) -> bool:
return self._data is None
def tell(self) -> int:
self._ensure_open()
return self._pos
def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
self._ensure_open()
if whence == io.SEEK_SET:
if offset < 0:
raise ValueError(f'negative seek position {offset}')
self._pos = offset
else:
raise io.UnsupportedOperation("can't do nonzero cur-relative seeks")
return self._pos
def read(self, n: int = -1) -> AnyStr:
self._ensure_open()
data = self._data[self._pos:self._pos+n] if n >= 0 else self._data[self._pos:]
self._pos += len(data)
return data
def readline(self, limit: int = -1) -> AnyStr:
self._ensure_open()
data = self._data[self._pos:]
stream = io.BytesIO(data) if isinstance(data, bytes) else io.StringIO(data)
line = stream.readline(limit)
self._pos += len(line)
return line
def readlines(self, hint: int = -1) -> List[AnyStr]:
self._ensure_open()
data = self._data[self._pos:]
stream = io.BytesIO(data) if isinstance(data, bytes) else io.StringIO(data)
lines = stream.readlines(hint)
self._pos += sum([len(line) for line in lines])
return lines
def __enter__(self) -> 'SentinelFileIo':
return self
def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
self.close()
return exc_type is None
def __iter__(self) -> Iterator[AnyStr]:
self._ensure_open()
while self._pos < self._size:
yield self.readline()
def _ensure_open(self) -> None:
if self.closed():
raise ValueError('I/O operation on closed file.')
```
Все, что теперь остается сделать с кодом -- это поменять `open()` на `sentinel_open()` больше не трогая ни строчки. Теперь код выглядит так:
```
with sentinel_open(path, 'rb') as f:
data = f.read()
use_data(data)
```
На самом деле действий нужно чуть больше:
* переименовать файл .py -> .pyx
* вставить вышеприведенный кусок кода в файл
Теперь с кодом точно все. Осталось сгенерировать C++ код из – теперь уже – Cython кода вышеописанным способом, а также собрать, прилинковав libsentinel.a и библиотеку из Sentinel SDK.
Примеры вызовов:
```
g++ $(python3.8-config --cflags) -fPIC -g0 -s -shared lib.cpp -o lib.so -lsentinel -lhasp_cpp_linux_x86_64
g++ $(python3.8-config --cflags) -fPIC -g0 -s app.cpp -o app $(python3.8-config --libs --embed) -lsentinel -lhasp_cpp_linux_x86_64
```
Теперь у нас есть зашифрованный файл данных и бинарный ELF-файл, который сможет расшифровать их при загрузке. Результат достигнут? Казалось бы, да, но есть еще особенность.
В собранном файле, к которому был прилинкован libsentinel.a, можно найти строку с vendor code, имея который и Sentinel SDK, данные возможно расшифровать. На помощь нам приходит утилита из того же Sentinel SDK: Envelope, которая особым образом трансформирует файл, после чего вызов утилиты strings больше не выводит ни единой читаемой строки.
Пример вызова утилиты:
```
Sentinel-LDK/VendorTools/Envelope/linuxenv --vcf:company-product.hvc --fid:1 input-file.so output-file.so
```
А как же лицензионная защита упомянутая в заголовке статьи? После обработки утилитой Envelope, ELF-файл может быть использован только на машине с установленной лицензией. А это значит, что код под надежной защитой Вот такой способ мы нашли при установке клиенту On-Premises-версии Audiogram. Пишите в комментариях, была ли полезна вам моя статья, и делитесь лайфхаками, как вы решаете задачу с защитой кода и данных.
P.S.
Решение от Sentinel – это коммерческий продукт и нужна платная лицензия. И Sentinel ушел из России, но есть другие похожие решения. Например, [Guardant](https://www.guardant.ru/). | https://habr.com/ru/post/678928/ | null | ru | null |
# Продолжение истории про «Сердце» электронного устройства или простейшее программирование Silicon Labs C8051F320
Не так давно я написал статью про [мою поделку](http://habrahabr.ru/blogs/DIY/132295/) на основе микроконтроллера Silicon Labs C8051F320. Пришло время рассказать и про программирование данного мк под простейшие задачи.
Подробности под катом.
Итак, в предыдущей статье я рассказал о небольшой платке, которая должна стать основой будущего устройства. На ней расположен сам микроконтроллер и его небольшая обвеска, предназначенная для ресета прошивки, питания мк и т.д. Одной из задач, которую данное устройство должно было выполнять у нас на работе, было управление некоторыми устройствами на исследовательском стенде. Так как по сути задача была не шибко сложной, то и прошивка для мк не требовала каких либо сложных решений наподобие работы с USB и прочими специфичными штуками, но разбор этой прошивки может в будущем хорошо помочь тем, кому придется работать с подобным мк по учебе (у моего друга вроде как сейчас по учебе идет программирование 51го ядра) или по работе. Но обо всем по порядку.
##### Задача
Задачу поставили довольно несложную — организовать простейшее включение/выключение удаленных устройств от микроконтроллера, организовав необходимые задержки между срабатываниями. В теории, надо было еще сделать управление этими задержками с ПК через USB, но, как оказалось потом, это не так важно.
##### Аппаратная часть
Для решения данной задачи нужна была реализация апаратной части устройства, отвечающео за сопряжение мк с удаленными устройствами, так как само «сердце» ничего такого на борту не несло, да и изначально оно расчитывалось на уравление периферийной платой. Особо зацикливаться на аппаратной части не буду, так как статья про прошивку, но все же для полноты картины представлю ее схему и краткое описание.
Всего удаленных устройств было 6 штук, три из которых управлялись по оптоволоконнной связи, два через реле и одно простым импульсом в размере 5 вольт. Так как наше начальство не любит, чтобы все делалось с умом и, соответственно, денег на грамотную работу выделять не желает, принципиальная схема была наворочена быстро и на коленке, так что в ней возможны небольшие недочеты. Вот она.
Убедившись, что никаких изменений в устройстве не предполагается, а точнее уточнив у начальства, что не будет всяких там «Ой, а давайте-ка...», после которых придется делать совершенно новую схему, мы приступили к изготовлению печатной платы. Про отсутствие денег я уже говорил, так что всего лишь скажу, что делалось все из подручных элементов — плата травилась у нас же на коленке из куска старого текстолита, элементы нашлись в кладовке. В общем, полная разруха. НИИ, что еще сказать… В общем, результат виден на фото:
К слову, потом все же случилось «Ой, а давайте-ка...», поэтому пришлось клепать пару мелких платок, резать дорожки на этой и все это соплями соединять, но пост не об этом.
##### Программная часть
Описание программной части будет состоять из нескольких подпунктов, чтоб было проще читать и понимать, о чем вообще речь.
###### Алгоритм работы
Алгоритм прост как валенок:
* Проверяем наличие внешнего сигнала «Старт» от вышестоящего устройства
* Если сигнал получен — отрабатываем заданную последовательность, наплевав на проверку срабатывания устройств. К слову, этот метод показался мне не совсем корректным, поэтому все же одну проверку я сделал, чтоб не бабахнуло, но реализовал ее просто аппаратно, а не в прошивке.
* Возвращаемся в пункт первый
Алгоритм выбран, аппататная часть готова, приступаем ко конфигурированию и программизму микроконтроллера.
###### Конфигурирование микроконтроллера
Вот что мне нравится в SILabs, так это то, что у них есть куча плюшек в виде программ для инициализации, конфигурирования, прошивки и прямого дебага их микроконтроллеров. Итак, берем их программу для начального конфигурирования МК с [их сайта](http://www.silabs.com/Support%20Documents/Software/ConfigAndConfig2Install.exe) и запускаем ее. Выбираем в настройках нужный нам мк и начинаем конфигурацию.
В процессе настройки МК нам нужно будет настроить его порты ввода/вывода, чтоб в исходном состоянии на них был логический ноль, настроить таймер-счетчик на нужный нам интервал (ЕМНИП я ставил 50 микросекунд), включить прерывания от таймера и еще по мелочи. Точно я все не помню, делал давно, покажу просто пример. В меню Properties выбираем нужный нам пункт и видим октрывшееся окно, где все необходимые нам параметры настраиваются в GUI.
При нажатии ОК все настройки копируются в окно с кодом. Настроили МК, но не спешим закрывать конфигуратор, он там еще понадобится. Качаем с [того же сайта](http://www.silabs.com/products/mcu/Pages/SoftwareDownloads.aspx) [Silicon Labs IDE](http://www.silabs.com/Support%20Documents/Software/mcu_ide.exe), с помощью которой и будем прошивать МК. Запускаем ее.
Тут есть один нюанс, ей нужно подсунуть компилятор от Keil С51, чтобы она его использовала. Не буду на этом зацикливаться, просто покажу картинкой как это делается. Открываем меню Project — Tool Chain Integration и указываем пути к компиляторам кейля.
Открываем конфигуратор и копируем из него получившийся код в IDE.
```
//--------------------------------------------------------------------------------//
// Initialization of timer //
//--------------------------------------------------------------------------------//
void timerInit(void)
{
TMOD = 0x10;
TMR2CN = 0x24;
TF2LEN = 1;
TMR2RLL = 0xCF;
TMR2RLH = 0xFF;
TMR2L = 0xCF;
TMR2H = 0xFF;
T2SPLIT = 0;
T2SOF = 0;
ET2 = 1;
TMR2 = 0xffff; // set to reload immediately
ET2 = 1; // enable Timer2 interrupts
TR2 = 1; // start Timer2
}
//--------------------------------------------------------------------------------//
// Initialization of ports I/O //
//--------------------------------------------------------------------------------//
void portIOInit(void)
{
P1MDOUT = 0x7F;
XBR1 = 0x40;
P0 = 0x00;
P1 = 0x00;
P2 = 0x00;
}
//------------------------------------------------------------------------------//
// Interrupts init //
//------------------------------------------------------------------------------//
void interruptsInit(void)
{
IP = 0x20;
IE = 0xA0;
}
//-----------------------------------------------------------------------------
// SYSCLK_Init
//-----------------------------------------------------------------------------
//
// This routine initializes the system clock to use the internal 24.5MHz / 8
// oscillator as its clock source. Also enables missing clock detector reset.
//
void SYSCLK_Init (void)
{
OSCICN = 0xC3; // configure internal oscillator for
// its lowest frequency
RSTSRC = 0x04; // enable missing clock detector
}
//------------------------------------------------------------------------------//
// Device init //
//------------------------------------------------------------------------------//
void deviceInit(void)
{
// disable watchdog timer
PCA0MD &= ~0x40; // WDTE = 0 (clear watchdog timer
SYSCLK_Init();
timerInit();
portIOInit();
interruptsInit();
EA = 1; // enable global interrupts
//------------------------------------------------------------------------------//
// Main function //
//------------------------------------------------------------------------------//
void main(void)
{
_delay1 = 0;
_delay2 = 19980;
_widthImp = 20;
_cDelay = 0;
_state = ST_IDLE;
deviceInit();
while(1) {
};
}
}
```
###### Реализация основной задачи
Итак, МК сконфигурирован, приступаем к реализации основной задачи — проверяем входящий сигнал и отрабатываем последовательность.
Алгоритм работы данной функции такой — запускаем таймер на щелчки через каждые 50 микросекунд. Создаем глобальную переменную \_state, которая будет отвечать за текущее состояние контроллера. По умолчанию делаем ее равной 0, т.е. первому состоянию. Остальные состояния МК сделаем более читабельными с помощью define:
```
#define ST_IDLE 0
#define ST_DELAY_0 1
#define ST_RNT_START 2
#define ST_DELAY_1 3
#define ST_RNT_STOP 4
```
Смотрим по даташиту контроллера таблицу прерываний и узнаем, что прерывание нужного нам таймера имеет вектор (номер) 5. Код, реализующий работу функции:
```
//------------------------------------------------------------------------------//
// Timer ISR //
//------------------------------------------------------------------------------//
void timerISR (void) interrupt 5
{
TF2H = 0;
TF2L = 0; // Clear Timer2 interrupt flag
switch(_state)
{
case ST_IDLE:
if (_inputPulse == 0)
{
_state = ST_DELAY_0;
_cDelay = 0;
}
break;
case ST_DELAY_0:
_cDelay++;
if (_cDelay>=_delay1)
{
_state = ST_RNT_START;
_rntStart = ON;
_cDelay = 0;
}
break;
case ST_RNT_START:
_cDelay++;
if (_cDelay >= _widthImp)
{
_state = ST_DELAY_1;
_rntStart = OFF;
_cDelay = 0;
}
break;
case ST_DELAY_1:
_cDelay++;
if (_cDelay >= _delay2)
{
_state = ST_RNT_STOP;
_rntStop = ON;
_cDelay = 0;
}
break;
case ST_RNT_STOP:
_cDelay++;
if (_cDelay >= _widthImp)
{
_state = ST_IDLE;
_rntStop = OFF;
_cDelay = 0;
}
break;
default:
_state = ST_IDLE;
break;
}
```
Итак, что мы делаем? При кажом щелчке таймера проверяем состояние МК. Если оно равно 0 — проверяем, есть ли на входе стартовый сигнал. Если он есть (inputPulse == 1) — запускаем последовательность. Длительность задержек между сигналами регулируем количеством щелчков таймера, проверяя его при каждом щелчке в коде обработки состояния. При завершении всего цикла работы — возвращаем МК в состояние 0 и ожидаем следующего входящего сигнала.
###### Прошивка
Компилируется и прошивается МК довольно просто, из той же IDE нажатием одной кнопки. Подключаем программатор к плате (как — показано в предыдущей статье), включаем питание, жмем кнопку «Подключиться», потом кнопку «Download code». Все, МК прошит. Запустить код на выполнение в МК можно отсюда же, нажав кнопку «Go». Здесь же можно расставить точки останова и провести с ним сеанс дебага, рассматривая результаты на осциллографе.
Кнопки показаны на рисунке и подписаны разными цветами.
#### Заключение
Как видите, не все так сложно при работе с данным МК. Думаю, что кому-нибудь этот пост поможет с ним разобраться. | https://habr.com/ru/post/133856/ | null | ru | null |
# Заметки о вращении вектора кватернионом
#### Структура публикации
* Получение кватерниона из вектора и величины угла разворота
* Обратный кватернион
* Умножение кватернионов
* Поворот вектора
* Рысканье, тангаж, крен
* Серия поворотов
#### Получение кватерниона из вектора и величины угла разворота
Ещё раз – что такое [кватернион](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D1%82%D0%B5%D1%80%D0%BD%D0%B8%D0%BE%D0%BD)? Для разработчика – это прежде всего инструмент, описывающий действие – поворот вокруг оси на заданный угол:
(w, vx, vy, vz),
где v – ось, выраженная вектором;
w – компонента, описывающая поворот (косинус половины угла).
Положительное значение угла разворота означает поворот вдоль вектора по часовой стрелке, если смотреть с конца вектора в его начало.
Например, кватернион поворота вдоль оси Х на 90 градусов имеет следующие значения своих компонент: w = 0,7071; x = 0,7071; y = 0; z = 0. Левая или правая система координат, разницы нет – главное, чтобы все операции выполнялись в одинаковых системах координат, или все в левых или все в правых.
С помощью следующего кода (под рукой был Visual Basic), мы можем получить кватернион из вектора и угла разворота вокруг него:
```
Public Function create_quat(rotate_vector As TVector, rotate_angle As Double) As TQuat
rotate_vector = normal(rotate_vector)
create_quat.w = Cos(rotate_angle / 2)
create_quat.x = rotate_vector.x * Sin(rotate_angle / 2)
create_quat.y = rotate_vector.y * Sin(rotate_angle / 2)
create_quat.z = rotate_vector.z * Sin(rotate_angle / 2)
End Function
```
В коде rotate\_vector – это вектор, описывающий ось разворота, а rotate\_angle – это угол разворота в радианах. Вектор должен быть нормализован. То есть его длина должа быть равна 1.
```
Public Function normal(v As TVector) As TVector
Dim length As Double
length = (v.x ^ 2 + v.y ^ 2 + v.z ^ 2) ^ 0.5
normal.x = v.x / length
normal.y = v.y / length
normal.z = v.z / length
End Function
```
Не забывайте про ситуацию, когда длина может быть 0. Вместо ошибки вам может понадобиться обработать эту ситуацию индивидуально.
#### Обратный кватернион
Для поворота вектора кватернионом требуется уметь делать обратный разворот и правильно выполнять операцию умножения кватернионов. Под обратным разворотом я имею ввиду обратный кватернион, т. е. тот, который вращает в обратную сторону.
Чтобы получить обратный кватернион от заданного, достаточно развернуть вектор оси в другую сторону и при необходимости нормализовать кватернион. Нормализация кватерниона так же как и в векторах, это просто приведение к длине = 1.
```
Public Function quat_scale(q As TQuat, val As Double) As TQuat
q.w = q.w * val ' x
q.x = q.x * val ' x
q.y = q.y * val ' y
q.z = q.z * val ' z
quat_scale = q
End Function
Public Function quat_length(q As TQuat) As Double
quat_length = (q.w * q.w + q.x * q.x + q.y * q.y + q.z * q.z) ^ 0.5
End Function
Public Function quat_normalize(q As TQuat) As TQuat
Dim n As Double
n = quat_length(q)
quat_normalize = quat_scale(q, 1 / n)
End Function
Public Function quat_invert(q As TQuat) As TQuat
Dim res As TQuat
res.w = q.w
res.x = -q.x
res.y = -q.y
res.z = -q.z
quat_invert = quat_normalize(res)
End Function
```
Например, если разворот вокруг оси Y на 90 градусов = (w=0,707; x = 0; y = 0,707; z=0), то обратный = (w=0,707; x = 0; y = -0,707; z=0). Казалось бы, можно инвертировать только компоненту W, но при поворотах на 180 градусов она = 0. Кватернион, который означает «нет разворота» = (w=1; x = 0; y = 0; z=0), то есть у него длина вектора оси = 0.
#### Умножение кватернионов
Умножение кватернионов крайне полезная штука. Результатом умножения является кватернион, который после поворота даёт такой же результат, если последовательно выполнить развороты умножаемыми кватернионами. Причём разворот будет происходить в локальной для поворачиваемого вектора системе отчёта, т. е. система отчёта поворачиваемого вектора также двигается.
 
Умножение кватернионов выполняется следующим образом:
```
Public Function quat_mul_quat(a As TQuat, b As TQuat) As TQuat
Dim res As TQuat
res.w = a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
res.x = a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y
res.y = a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x
res.z = a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w
quat_mul_quat = res
End Function
```
Для того, чтобы умножить кватернион на 3D вектор, нужно вектор преобразовать в кватернион присвоив компоненте W = 0 и умножить кватернион на кватернион. Или подставить ноль и выразить это в виде функции:
```
Public Function quat_mul_vector(a As TQuat, b As TVector) As TQuat
Dim res As TQuat
res.w = -a.x * b.x - a.y * b.y - a.z * b.z
res.x = a.w * b.x + a.y * b.z - a.z * b.y
res.y = a.w * b.y - a.x * b.z + a.z * b.x
res.z = a.w * b.z + a.x * b.y - a.y * b.x
quat_mul_vector = res
End Function
```
#### Поворот вектора
Теперь, собственно, поворот вектора кватернионом:
```
Public Function quat_transform_vector(q As TQuat, v As TVector) As TVector
Dim t As TQuat
t = quat_mul_vector(q, v)
t = quat_mul_quat(t, quat_invert(q))
quat_transform_vector.x = t.x
quat_transform_vector.y = t.y
quat_transform_vector.z = t.z
End Function
```
Пример:
Вектор описывающий ось (x=1; y=0; z=1). Угол поворота 180 градусов.
Поворачиваемый вектор (x=0; y=0; z=1). Результат равен (x=1; y=0; z=0).
#### Рысканье, тангаж, крен
Рассмотрим инструмент формирования кватерниона с помощью поворотов вокруг одной из осей:
Рысканье = heading = yaw = вокруг оси Z; тангаж = altitude = pitch = вокруг оси Y; крен = bank = roll = вокруг оси X.
```
Public Function quat_from_angles_rad(angles As TKrylov) As TQuat
Dim q_heading As TQuat
Dim q_alt As TQuat
Dim q_bank As TQuat
Dim q_tmp As TQuat
q_heading.x = 0
q_heading.y = 0
q_heading.z = Sin(angles.heading / 2)
q_heading.w = Cos(angles.heading / 2)
q_alt.x = 0
q_alt.y = Sin(angles.altitude / 2)
q_alt.z = 0
q_alt.w = Cos(angles.altitude / 2)
q_bank.x = Sin(angles.bank / 2)
q_bank.y = 0
q_bank.z = 0
q_bank.w = Cos(angles.bank / 2)
q_tmp = quat_mul_quat(q_heading, q_alt)
quat_from_angles_rad = quat_mul_quat(q_tmp, q_bank)
End Function
```
И в обратную сторону, из кватерниона:
```
Public Function quat_to_krylov(q As TQuat) As TKrylov
Dim qx2 As Double
Dim qy2 As Double
Dim qz2 As Double
q = quat_normalize(q) 'кватернион должен быть нормализован
qx2 = q.x * q.x
qy2 = q.y * q.y
qz2 = q.z * q.z
quat_to_krylov_v3.bank = atan2(2 * (q.x * q.w + q.y * q.z), 1 - 2 * (qx2 + qy2))
quat_to_krylov_v3.altitude = Application.WorksheetFunction.Asin(2 * (q.y * q.w - q.z * q.x))
quat_to_krylov_v3.heading = atan2(2 * (q.z * q.w + q.x * q.y), 1 - 2 * (qy2 + qz2))
End Function
```
Формулы преобразования зависят от принятой системы координат.
#### Серия поворотов
Рассмотрим пример:
1. Первый поворот – рысканье (вокруг Z) 90 градусов по часовой;
2. Второй поворот – тангаж (вокруг Y) 90 градусов по часовой;
3. Третий поворот – крен (вокруг X) 90 градусов по часовой.
Рисунки, изображающие поворот и подписанные как «global» демонстрируют повороты относительно неподвижных осей XYZ. Такой результат мы получим, если будем использовать кватернионы разворота по отдельности. Четвёртый рисунок демонстрирует, где окажется вектор, если начальные координаты у него были X=1; Y=0; Z=0.
Рисунки, подписанные как «local» демонстрируют вращение осей вместе с самолетом. То есть все вращения происходят относительно пилота, а не относительно неподвижной системы координат. Четвёртый рисунок показывает, где окажется тот же самый вектор (1; 0; 0) в итоге всех трёх поворотов. Такой результат мы получим, перемножив кватернионы разворота и применив полученный кватернион.
 
 
 
  | https://habr.com/ru/post/255005/ | null | ru | null |
# Инструкция по обновлению ПО и первичной настройке Nokia 7750 (SR-7 | SR-12)
Данная статья продолжает тему первичной настройки оборудования Nokia (ранее Alcatel-Lucent). Она будет полезна тем, кто не имеет большого опыта эксплуатации данного оборудования, но в ближайшей перспективе планирует связать свои рабочие часы с Nokia 7750 (SR-7 | SR-12)
Я постараюсь помочь разобраться в процедуре первичной интеграции 7750 SR на сети, но сразу замечу, что никакая инструкция не сможет заменить официальную документацию от производителя, тем более, что в новых версиях ПО описанные процедуры могут быть изменены. Я планирую ограничиться лишь тем минимумом информации, которая требуется для запуска 7750 и предоставлению к нему удаленного доступа. Тем не менее с готовностью дополню данную статью (либо напишу новую, если вопросы выйдут за ее рамки) информацией, к которой будет проявлен интерес.
Если вас интересует тема первичной настройки Nokia 7210 SAS-M, то ознакомиться с ней можно в [соответствующей статье](https://habrahabr.ru/post/306030/).
### 1. Обновление ПО на 7750 SR
Первым делом рекомендую обновить ПО (TiMOS) до актуальной версии. Хочу сразу отметить, что в случае использования системы управления 5620SAM, необходимо учитывать, какую максимальную версию TiMOS она поддерживает.
##### **1.1 Подготовка к работе**
Что необходимо для проведения работ:
1) Ноутбук с COM-портом или переходник usb-com;
2) Serial кабель. Я использую rollover-кабель Cisco с дополнительным переходником, так как консоль 7750 представляет из себя DB9 разъем (в отличии от 7210, в котором используется RJ45)
3) Терминальный клиент (Putty, SecureCRT или аналог);
4) TFTP сервер (tftp32 или аналог);
5) Наличие актуального TiMOS (в качестве примера использовал TiMOS 13.0R10).
##### **1.2 Заливка софта**
Для загрузки софта необходимо подключиться к порту Console и настроить параметры сессии следующим образом:
`Baud Rate 115,200`
`Data Bits 8`
`Parity None`
`Stop Bits 1`
`Flow Control None`
Прямым кабелем подключаем Management порт 7750 к сетевой карте компьютера. Устанавливаем IP на локальный компьютер (в примере 192.168.1.10/24). Запускаем TFTP сервер и в качестве рабочей папки выбираем каталог с TiMOS.
Если на SR уже установлен TiMOS, то пропускаем пункт 1.3 и переходим сразу к 1.4.
##### **1.3 На оборудовании нет TiMOS (режим monitor)**
Нажимаем любую клавишу для начала изменения параметров загрузки. При запросе пароля вводим: “password”. Далее следуем диалогу:
`tftp://192.168.1.10/7750/TiMOS-SR-13.0.R10/both.tim` #Задаем адрес операционной системы
`tftp://192.168.1.10/7750/config.cfg` # Задаем адрес конфигурационного файла
Включаем eth-mgmt порт, прописав команду enable и назначаем IP-адрес из той же подсети, что настраивали на компьютере.
При запросе на сохранение конфигурации отвечаем — yes.
После данного шага, операционная система должна загрузиться.
##### **1.4. Оборудование загрузилось (TiMOS)**
Логин/пароль: admin/admin
`bof` # Заходим в меню настройки Boot Options File
`no eth-mgmt-disabled` # Включаем eth-mgmt
`eth-mgmt-address 192.168.1.1/24`# Назначаем eth-mgmt адрес нашему 7750
`save` # Сохраняем Boot Options File
`back`
`file dir` #Проверяем свободное место на карте памяти. В случае нехватки памяти файлы можно удалить командой file delete "имя файла"
`file md cf1:\TiMOS-13.0.R10` # Создаем папку для нового TiMOS на карте памяти и загружаем в нее системные файлы
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\both.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\cpm.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\iom.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\isa-aa.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\isa-tms.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\support.tim`
`file copy tftp://192.168.1.10/both.tim cf3:\TiMOS-13.0.R10\boot.ldr`
`file copy tftp://192.168.1.10/boot.tim cf3:\boot.ldr` # Загружаем (перезаписав) boot loader
`bof primary-image cf3:\TiMOS-13.0.R10\` # Указываем основной образ TiMOS для загрузки
`bof secondary-image cf3:\<Пусть к старому TiMOS, если он есть>` # Опционально
`bof primary-config cf3:\config.cfg` # Указываем файл конфигурации
`bof no eth-mgmt-address 192.168.1.1/24` # Удаляем адрес eth-mgmt
`bof eth-mgmt-disabled` # Отключаем eth-mgmt
`bof save`
`admin save`
Файл успешно скопирован, когда оборудование отображает в консоли следующую информацию:
`Copying file tftp://192.168.1.10/both.tim ... OK`
`1 file copied.`
После сохранения конфигурации (admin save) необходимо перезагрузить 7750 командой `admin reboot upgrade` и удостовериться, что оборудование прошло успешную загрузку.
**##### 1.5 Резервный процессорный модуль (standby CPM)**
Если в 7750 установлен резервный CPM, то необходимо произвести перенос системных файлов и конфигурации на его карту памяти (в системе cf3-b) командой `admin redundancy synchronize boot-env`
Внимание! С 11-го релиза появился новый файл support.tim. В случае, если обновление производится с версии меньше 11-ой, то данный файл необходимо скопировать на резервный CPM вручную командой `copy cf3:\TiMOS-13.0.R10\support.tim cf3-b:\TiMOS-13.0.R10\support.tim`
Так же необходимо выполнить команду `/configure redundancy synchronize config`. Если не применить данную конфигурацию, то при выполнении команды `admin save` конфигурация не будет сохранена на резервный CPM.
Наличие резервного модуля позволяет выполнить процедуру In-Service Software Upgrade (ISSU). Данная опция не доступна в начальных минорных версиях TiMOS, перед обновлением необходимо ознакомиться с software release notes соответствующей версии ПО.
В данной процедуре присутствуют следующие ключевые команды (считаем, что на момент начала обновления активным является CPM в слоту А):
1. Копируем софт на cf3 основного CPM в папку cf3:\TiMOS-13.0.R10\
2. Производим перезапись boot.ldr в корне (cf3:)
3. Изменяем путь к основному и резервному образу TiMOS в BOF
4. `admin redundancy synchronize boot-env` # Cинхронизируем карточки основного и резервного CPM (не забыв про ручное копирование support.tim на старых релизах)
5. `admin reboot standby now` # Производим перезагрузку резервного модуля.
6. `show card` # Проверяем, что CPM-B перезагрузился и имеет статус `up ISSU/standby`
7. `admin redundancy force-switchove` # Делаем обновленный резервный модуль активным. После этого второй (бывший активный) модуль начнет процесс обновления.
8. `show card`# Проверяем, что все карты в состоянии up.
### 2. Установка и инициализация карт
Линейные карты необходимо устанавливать в различные части шасси (для SR-7, при наличии двух линейных карт, их следует размещать в 1 и 5 слоты, а не в 4 и 5). Связано это с ограничениями по использованию Timing References. Ref1 может быть использован на карте в 1-2/1-5 слоте, а Ref2 на карте в 3-5/6-10 слоте для SR-7/SR-12 соответственно.
**##### 2.1 Определение карт**
Установленные в 7750 карты и модули необходимо определять в конфигурации, до тех пор их состояние будет `unequipped`
`configure card <номер слота в шасси>`
`card-type`
`mda <позиция mda в карте>`
`mda-type`
Корректным состоянием в выдаче show card и show mda является Admin up, Operational up. Для получения более подробной информации о карте (P/N, S/N, температура и пр.) необходимо добавить в указанные команды `detail`
**##### 2.2 Chassis-mode**
Команда `configure system chassis-mode <>` позволяет настроить набор функций, доступных в шасси. Зависит данный параметр от типа используемых карт:
a (по умолчанию): соответствует набору функций, связанных с iom-20g.
b: соответствует набору функций, связанных с iom-20g-b.
c: соответствует набору функций, связанных с iom2-20g.
d: соответствует набору функций, связанных с iom3-xp
Например, если у вас установлены iom3-xp карты, то необходимо ввести команду `configure system chassis-mode d`
### 3. Пример начальной настройки 7750 SR
`/configure system name "Имя"`
Подготавливаем порт, создаем и ассоциируем с ним интерфейс:
`/configure port 1/1/1`
`description "описание порта"`
`no shutdown`
`/configure router`
`interface "system”`
`address /32` # Cоздаем системный виртуальный интерфейс
`no shutdown`
`exit`
`interface "имя интерфейса"`
`address /30` # IP адрес интерфейса
`port 1/1/1` # Порт на нашем оборудовании, с которого уходит линк
`no shutdown`
`exit`
`/configure router ospf`
`area 0.0.0.0` # Номер area в которой будет состоять 7750
`interface "system"` # Обязательно включаем интерфейс "system" в данную арию
`exit`
`interface "имя интерфейса"` # Указываем имена всех интерфейсов, входящих в эту арию
`interface-type point-to-point` # Указываем тип интерфейса
`exit`
Если 7750 участвует более чем в одной арии, то необходимо прописать вторую арию и все входящие в нее интерфейсы. Если интерфейс участвует так же в non backbone area как secondary, то настраивается он следующим образом:
`area 0.0.0.1 interface "system" secondary exit`
Данная конфигурация является тем минимумом, который позволит получить удаленный доступ к 7750 SR в сети с настроенным протоколом OSPF.
### 4. Полезные заметки
* Просмотреть конфигурацию можно командой «admin display-config». Если необходимо выполнить команду (любую) из места вашего расположения в консоли, то ставим предварительно "/".
* Выполнив команду «info» можно увидеть конфигурацию, которая относится к ветке вашего расположения. Если необходимо просмотреть так же значения параметров «по умолчанию», то используем «info detail»
* Командой “show chassis” и “show card” можно узнать температуру шасии и режим работы FAN. Если вентиляторы работают в режиме full speed, то это свидетельствует о повышенном температурном режиме узла.
* На лицензионной CF карте от Nokia хранится TiMOS и конфигурация, устанавливается она в cf3 процессорной карты. Хорошим решением будет установка дополнительной карты памяти Sandisk (официально поддерживаемый производитель) в слот cf2 или cf1 и использовать ее в качестве хранилища логов.
* Командой “show chassis” можно получить информацию о питании и его выходе за пределы допустимых значений.
* Команды “show log log-id 100” и “show log log-id 99” позволят просмотреть Default Serious Errors Log и Default System Log соответственно.
* Команда «show port» позволит проверить статус портов
* Команда «show router route-table» отразит таблицу маршрутизации
* В файле cf3:/bootlog.txt можно найти лог загрузки 7750. Если оборудование не может загрузить TiMOS (например, уходит в циклическую перезагрузку), то информация из данного файла может помочь при проведении диагностики.
* IOS (Cisco): «ping 1.1.1.1 size 1500 df-bit», в данном случае 1500 байт это размер датаграммы уже с IP и ICMP заголовками.
* TiMOS (Nokia): «ping 1.1.1.1 size 1472» — 1472 байт говорят о размере поля data в ICMP. Другими словами, добавляем еще 8 байт ICMP и 20 байт IP и получаем те же 1500 байт, что на Cisco.
* При обращении в техническую поддержку Nokia вам необходимо будет предоставить два tech-support файла, снятые командой *"/admin tech-support cf3:<имя файла>.bin"* с минимальной временной разницей 15 минут. К сожалению, в отличии от многих других вендоров, данные фалы зашифрованы и прочесть их сможет только инженер Nokia. В случае возникновения каких-либо проблем или аварий, в первую очередь рекомендую снять первый tech-support файл, а дальше приступать к решению проблемы. | https://habr.com/ru/post/306168/ | null | ru | null |
# Импакт-анализ на примере Android-проекта
Одной из самых дорогих по времени операций на CI-сервере является прогон автотестов. Есть множество способов их ускорения, например, распараллеливание выполнения по нескольким CI-агентам и/или эмуляторам, полная эмуляция внешнего окружения(backend/сервисы Google/вебсокеты), тонкая настройка эмуляторов(Отключение анимации/ [Headless-сборки](https://developer.android.com/studio/releases/emulator#headless-build) / отключение снепшотов) и так далее. Сегодня поговорим про импакт-анализ или запуск только тех тестов, которые связаны с последними изменениями в коде. Расскажу какие шаги нужны для импакт-анализа и как мы реализовали это в нашем проекте.
Шаг первый: получаем diff изменений.
------------------------------------
Проще всего достигается встроенными средствами [Git](https://git-scm.com/docs/git-diff). Мы обернули работу импакт-анализа в Gradle-плагин и используем Java-обертку над Git - [JGit](https://www.eclipse.org/jgit/). Для merge request мы используем premerge-сборки(это когда сначала выполняется объединение с целевой веткой, используется для оперативного выявления конфликтов), поэтому достаточно получить diff последнего коммита:
```
val objectReader = git.repository.newObjectReader()
val oldTreeIterator = CanonicalTreeParser()
val oldTree = git.repository.resolve("HEAD^^{tree}")
oldTreeIterator.reset(objectReader, oldTree)
val newTreeIterator = CanonicalTreeParser()
val newTree = git.repository.resolve("HEAD^{tree}")
newTreeIterator.reset(objectReader, newTree)
val formatter = DiffFormatter(DisabledOutputStream.INSTANCE)
formatter.setRepository(git.repository)
val diffEntries = formatter.scan(oldTree, newTree)
val files = HashSet()
diffEntries.forEach { diff ->
files.add(git.repository.directory.parentFile.resolve(diff.oldPath))
files.add(git.repository.directory.parentFile.resolve(diff.newPath))
}
return files
```
Но ничто не мешает собрать все коммиты между двумя ветками:
```
val oldTree = treeParser(git.repository, previousBranchRef)
val newTree = treeParser(git.repository, branchRef)
val diffEntries = git.diff().setOldTree(oldTree).setNewTree(newTree).call()
val files = HashSet()
diffEntries.forEach { diff ->
files.add(git.repository.directory.parentFile.resolve(diff.oldPath))
files.add(git.repository.directory.parentFile.resolve(diff.newPath))
}
return files
```
```
private fun treeParser(repository: Repository, ref: String): AbstractTreeIterator {
val head = repository.exactRef(ref)
RevWalk(repository).use { walk ->
val commit = walk.parseCommit(head.objectId)
val tree = walk.parseTree(commit.tree.id)
val treeParser = CanonicalTreeParser()
repository.newObjectReader().use { reader ->
treeParser.reset(reader, tree.id)
}
walk.dispose()
return treeParser
}
}
```
Шаг второй: собираем дерево зависимостей исходного кода.
--------------------------------------------------------
Детализация дерева зависит от количества кода и автотестов. Чем больше детализация тем выше точность изоляции только нужных тестов, но медленнее отрабатывает сборка дерева. Сейчас мы собираем дерево зависимостей на уровне модулей, и присматриваемся к уровню отдельных классов.
Список модулей в проекте:
```
private fun findModules(projectRootDirectory: File): List {
val modules = ArrayList()
projectRootDirectory.traverse { file ->
if (file.list()?.contains("build.gradle") == true) {
val name = file.path
.removePrefix(projectRootDirectory.absolutePath)
.replace("/", ":")
val pathToBuildGradle = "${file.path}/build.gradle"
val manifestFile = File("${file.path}/$ANDROID\_MANIFEST\_PATH")
if (manifestFile.exists()) {
if (modulePackage != null) {
modules.add(Module(name))
}
}
}
}
return modules
}
```
Ноды мы связываем парсингом файла build.gradle. Также дерево зависимостей можно генерировать не автоматически, а собрать один раз руками и переиспользовать. Преимущество - детализация любого уровня без влияния на время работы, недостаток - кому-то придется вручную поддерживать граф по мере развития проекта.
Шаг третий: выделяем все затронутые ноды дерева зависимостей.
-------------------------------------------------------------
Берем изменения из первого шага, сопоставляем с нодами из второго, и простым обходом в ширину находим все затронутые ноды.
```
private fun findAllDependentModules(origin: Module, links: Set): Set {
val queue = LinkedList()
val visited = HashSet()
queue.add(origin)
val result = HashSet()
while (queue.isNotEmpty()) {
val module = queue.poll()
if (visited.contains(module)) {
continue
}
visited.add(module)
result.add(module)
queue.addAll(links.filter { it.to == module }.map { it.from })
}
return result
}
```
Шаг четвертый: собираем список тестов, связанных с затронутыми нодами дерева зависимостей.
------------------------------------------------------------------------------------------
На этом этапе нам надо как то связать автотесты с нодами дерева зависимостей из второго шага. Путей для этого есть много(например связь через кастомные аннотации), но для надежного и всегда актуального состояния лучше парсить исходный код самих автотестов. Мы используем фреймворк [Kaspresso](https://github.com/KasperskyLab/Kaspresso), и для связки тестов с деревом зависимостей парсим тесты компилятором самого Kotlin. Собираем дерево зависимостей вида тесткейсы -> сценарии -> описания страниц([Page Object](https://martinfowler.com/bliki/PageObject.html))-> ноды зависимостей из второго шага, потом обратным проходом получаем список всех нужных тестов.
Дерево зависимостей
```
implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:1.5.10")
```
```
private fun readUiTestsMetaData(modules: List): List {
val testRootDirectory = rootDirectory.get().resolve(TEST\_ROOT\_PATH)
val ktFiles = kotlinFiles(testRootDirectory)
val pageObjects = ktFiles.mapNotNull { parsePageObjectMetaData(it, modules) }
.sortedBy { it.name }
val scenarioObjects = ktFiles.map { parseScenarioObjects(it, pageObjects) }.flatten()
val scenarios = buildScenarioMetaData(scenarioObjects, pageObjects)
return ktFiles.map { parseUiTestMetaData(it, scenarios, pageObjects) }
.flatten()
.sortedBy { it.name }
}
```
Шаг пятый: запускаем нужные тесты.
----------------------------------
Штатное средство запуска тестов в Android позволяет фильтровать тесты по названию, пакету или привязанным аннотациям. Мы для запуска автотестов используем [Marathon](https://github.com/MarathonLabs/marathon), у которого более широкая функциональность по [фильтрации](https://marathonlabs.github.io/marathon/doc/configuration.html#test-filtering-configuration). В Teamcity на этапе импакт-анализ, наш Gradle-плагин собирает все автотесты из четвертого шага, выдирает из них идентификатор теста и пишет в файл. После этого при подготовке Marathon мы скармливаем ему все эти идентификаторы и получаем запуск только нужных тестов из всех существующих.
Сейчас полный прогон всех тестов занимает около 30 минут, и импакт анализ экономит нам минут 10. С дальнейшим развитием проекта и добавлением новых модулей/автотестов сэкономленное время будет только увеличиваться. Надеюсь статья оказалась вам полезной, and stay tuned folks :) | https://habr.com/ru/post/647519/ | null | ru | null |
# Thunderargs: практика использования. Часть 2
[История создания](http://habrahabr.ru/post/223041/)
[Часть 1](http://habrahabr.ru/post/224705/)
Добрый день. Вкратце напомню, что thunderargs — библиотека, которая даёт использовать аннотации для обработки входящих аргументов.
Кроме того, она даёт возможность достаточно просто накидать гейт, который будет эти самые аргументы для функции вытаскивать откуда-нибудь ещё. Например, из объекта request во фласке. И в итоге мы вместо
```
@app.route('/ugly_calc', dont_wrap=True)
def ugly_calc():
x, y = int(request.args['x']), int(request.args['y'])
op_key = request.args.get('op')
if not op_key:
op_key = '+'
op = OPERATION.get(op_key)
return str(op(x, y))
```
делаем
```
@app.route('/calc')
def calc(x:Arg(int), y:Arg(int), op:Arg(str, default='+')):
return str(OPERATION[op](x, y))
```
Думаю, все хотя бы примерно поняли о чём будет речь в статье. Всё, что в ней описано — размышления о будущем проекта и примерная расстановка «майлстоунов» по нему. Ну и, разумеется, первые наброски всяких-разных фич.
#### В этой части
* Рассмотрим структурные изменения в проекте и пару критических ошибок в изначальной структуре
* Разберёмся как работают валидаторы и как можно кастомизировать выдаваемые ими ошибки
* Создадим зачатки специализированных аргументов (IntArg, StrArg, ListArg и так далее)
* Подготовим класс, который будет автоматически вытаскивать объект из базы по id, поступившему в запросе
* Будем генерировать точки входа по классу модели
* Реализуем листенеры и посмотрим как можно сделать валидатор для нескольких аргументов
* Убедимся, что информацию о структуре аргументов можно смело переносить в БД, и ничего нам за это не будет
* И, наконец, порассуждаем о мелких интересностях, так и не реализованных в рамках этих экспериментов
#### Структурные изменения, или почему меня надо бить ногами
Ну а теперь коротко о важных событиях в судьбе проекта. Во-первых, я наконец-то почитал как Армин Ронашер [рекомендует делать модули к фласку](http://flask.pocoo.org/docs/0.10/extensiondev/), и привёл своего «пэта» к нужному виду. Для этого я целиком и полностью отделил основной функционал библиотеки (эта либа и репа остались под названием thunderargs) от функционала, который позволяет использовать её в качестве дополнения к Flask (теперь эту хрень можно поставить под именем flask-thunderargs, как несложно догадаться). Да, по сути это всего-навсего отделение интерфейса от ядра, которое жизнеспособно и без этого интерфейса. И так следовало поступить с самого начала. За свою непредусмотрительность я поплатился почти пятью часами, потраченными на реорганизацию.
В общем, кратко опишу что именно изменилось и что это значит:
##### Теперь у нас есть две либы — ядро и интерфейс к фласку
Основная библиотека, как я уже говорил, вполне может использоваться и без всяких внешних интерфейсов. И, разумеется, она может быть использована для создания собственных интерфейсов. Например, к другим веб-фреймворкам. Или к argparse. Или к жаббер-боту. Да в общем к чему угодно.
По сути, от этого пункта проект только в плюсе.
##### flask-thunderargs теперь является полноценным flask-модулем
Единственная беда — сам по себе интерфейс просто крошечный. По сути, весь он заключён в [этом](https://bitbucket.org/dsupiev/flask-thunderargs/src/668fb248df604bca7e053497075c3dda1e3fc7ec/flask_thunderargs/__init__.py?at=default) файле. Если кто решит написать свой собственный интерфейс к другой либе, можете смело ориентироваться на него.
А ещё изменился процесс инициализации endpoint'ов, разумеется. Теперь минималистичное приложение выглядит примерно так:
```
from flask import Flask
from flask.ext.thunderargs import ThunderargsProxy
from thunderargs import Arg
app = Flask(__name__)
ThunderargsProxy(app)
@app.route('/max')
def find_max(x: Arg(int, multiple=True)):
return str(max(x))
if __name__ == '__main__':
app.run()
```
Такие дела.
#### Делаем ошибки
В прошлой части мы уже разбирались как создавать свои валидаторы. И убедились, что это довольно просто. Напомню:
```
def less_than_21(x):
return x < 21
@app.route('/step5_alt')
def step5_1(offset: Arg(int, default=0, validators=[lambda x: x >= 0 and
x < len(elements)]),
limit: Arg(int, default=20, validators=[less_than_21])):
return str(elements[offset:offset+limit])
```
Как мы видим, здесь есть два варианта их создания. Один — инлайновый, с помощью лямбд. Второй — полновесный. Сейчас я хочу показать почему полновесный вариант предпочтительней.
Человек, щупавший эксперименты прошлой части, мог заметить, что валидаторы, созданные фабрикой, кидают довольно красивые и понятные ошибки:
```
thunderargs.errors.ValidationError: Value of `limit` must be less than 21
```
Но наш пример выдаёт непонятные и ни о чём говорящие ошибки:
```
thunderargs.errors.ValidationError: Argument limit failed at validator #0.Given value: 23
```
Справиться с этим довольно просто. Более того, наша ошибка будет даже лучше оригинальной:
```
experiments.custom_error.LimitError: limit must be less than 21 and more than 0. Given: 23
```
Для такого результата нам нужен такой код:
```
class LimitError(ValidationError):
pass
```
```
from thunderargs.errors import customize_error
from experiments.custom_error import LimitError
message = "{arg_name} must be less than 21 and more than 0. Given: {value}"
@customize_error(message=message, error_class=LimitError)
def limit_validator(x):
return x < 21 and x>0
@app.route('/step5_alt2')
def step5_2(offset: Arg(int, default=0, validators=[lambda x: x >= 0 and
x < len(elements)]),
limit: Arg(int, default=20, validators=[limit_validator])):
return str(elements[offset:offset+limit])
```
В общем, для кастомизации ошибки нужно просто навесить декоратор `customize_error` на функцию-валидатор. В текст ошибки всегда передаются следующие переменные:
* `error_code` — номер ошибки для отображения; внутрисистемная хрень для любителей систематизации;
* `arg_name` — имя аргумента, которое соответствует присваиваемому в объявлении функции аргументу названию; В нашем случае это, например, limit;
* `value` — значение, полученное валидатором; в случае с flask-thunderargs это чаще всего string, поскольку все, кроме reques.json и reques.files отдают именно его;
* `validator_no` — порядковый номер валидатора; сильно сомневаюсь, что он пригодится в правильно составленных валидаторах;
Кроме того, можно передавать в customize\_error любые именованные параметры, которые класс ошибки сожрёт под соответствующими именами. Это удобно, допустим, если нам нужно передать какие-то прописанные в конфиге данные в качестве уведомления для конечного пользователя. А ещё это применимо если вы пишете генератор ошибок. В качестве примера рассмотрим классическую фабрику декораторов из validfarm:
```
def val_in(x):
@customize_error("Value of `{arg_name}` must be in {possible_values}", possible_values=x)
def validator(value):
return value in x
return validator
```
possible\_values в данном примере берётся из x, переменной, которая будет передана фабрике программистом, и будет получена ещё во время запуска приложения.
*Предположительная версия: **0.4***
#### Наследованные классы переменных
Очевидно, что уменьшение уровня абстракции полезно для конечного пользователя библиотеки. И первым шагом в этом направлении будут специализированные классы. Вот пример:
```
class IntArg(Arg):
def __init__(self, max_val=None, min_val=None, **kwargs):
kwargs['p_type'] = int
if not 'validators' in kwargs or kwargs['validators'] is None:
kwargs['validators'] = []
if min_val is not None:
if not isinstance(min_val, int):
raise TypeError("Minimal value must be int")
kwargs['validators'].append(val_gt(min_val-1))
if max_val is not None:
if not isinstance(max_val, int):
raise TypeError("Maximal value must be int")
kwargs['validators'].append(val_lt(max_val+1))
if min_val is not None and max_val is not None:
if max_val < min_val:
raise ValueError("max_val is greater than min_val")
super().__init__(**kwargs)
```
А вот применение данного класса:
```
from experiments.inherited_args import IntArg
@app.route('/step7')
def step7(x: IntArg(default=0, max_val=100, min_val=0)):
return str(x)
```
Основная фишка таких классов в том, что отпадает необходимость вручную описывать некоторые параметры входящего аргумента. Кроме того, отпадает необходимость описывать некоторые валидаторы вручную. И появляется возможность конкретизировать их смысл в коде, что очень важно для читабельности.
*Предположительная версия: **0.4***
#### Наследованные классы для ORM
Допустим, что у нас есть класс документов, сделанный через mongoengine:
```
class Note(Document):
title = StringField(max_length=40)
text = StringField(min_length=3, required=True)
created = DateTimeField(default=datetime.now)
```
У нас должен быть геттер, который должен вернуть конкретный документ. Давайте сделаем под эту задачу самостоятельный класс:
```
class ItemArg(Arg):
def __init__(self, collection, **kwargs):
kwargs['p_type'] = kwargs.get('p_type') or ObjectId
kwargs['expander'] = lambda x: collection.objects.get(pk=x)
super().__init__(**kwargs)
```
Всё, что он делает — меняет входные аргументы. Просто расширяет их до необходимого набора. И даже такой минималистичный вариант позволяет нам делать так:
```
@app.route('/step9/get')
def step9_2(note: ItemArg(Note)):
return str(note.text)
```
Довольно няшно, правда?
*Предположительная версия: **есть смысл вынести в самостоятельную библиотеку***
#### Генерируем фласковые геттеры
Представим себе, что у нас есть какой-то класс в модели, геттеры которого не совершают никаких особых действий. Нужно написать геттер, который будет выдвать пользователю информацию в таком же виде, в каком она хранится в БД. В этом случае нам не помешает генератор геттеров. Давайте сделаем его:
```
def make_default_serializable_getlist(cls, name="default_getter_name"):
@Endpoint
def get(offset: IntArg(min_val=0, default=0),
limit: IntArg(min_val=1, max_val=50, default=20)):
return list(map(lambda x: x.get_serializable_dict(), cls.objects.skip(offset).limit(limit)))
get.__name__ = name
return get
```
Эта функция должна создать геттер для коллекции MongoEngine. Единственное дополнительное условие — у класса коллекции должен быть определён метод `get_serializable_dict`. Но, думаю, с этим ни у кого особых проблем не возникнет. А вот один из вариантов применения этой штуки:
```
getter = make_default_serializable_getlist(Note, name='step11_getter')
app.route('/step11_alt3')(json_resp(getter))
```
Здесь используется вспомогательная функция `json_resp`, но на самом деле она не делает ничего интересного, просто оборачивает ответ контроллера в `flask.jsonify` (если может). Кроме того, в этом примере я использовал декоратор без применения классического синтаксиса. На мой взгляд, это оправдано, иначе пришлось бы делать не совершающую никакой полезной деятельности обёртку-транспорт.
*Предположительная версия: **аналогично предыдущему***
#### Логгирование вызовов и кое-что ещё
Давайте логгировать каждое телодвижение пользователя, вписывающееся в описанные нами правила. Для этого накидаем простецкий декоратор, который будет принимать в себя функцию-коллбэк:
```
def listen_with(listener):
def decorator(victim):
@wraps(victim)
def wrapper(**kwargs):
listener(func=victim, **kwargs)
return victim(**kwargs)
return wrapper
return decorator
```
и сам коллбэк:
```
def logger(func, **kwargs):
print(func.__name__)
print(kwargs)
```
Этот коллбэк просто выводит все полученные аргументы на экран. А теперь рассмотрим более полезный пример:
```
def denied_for_john_doe(func, firstname, lastname):
if firstname == 'John' and lastname == 'Doe':
raise ValueError("Sorry, John, but you are banned")
@app.route('/step13')
@listen_with(denied_for_john_doe)
def step13(firstname: Arg(str, required=True),
lastname: Arg(str, required=True)):
return "greeting you, {} {}".format(firstname, lastname)
```
Здесь, как мы видим, идёт проверка возможности использования комбинации значений. Вообще, чисто формально, такая конструкция не является лисетенером, и должна быть от них, листенеров, отделена. Но пока, в рамках эксперимента, оставим это так. Вот более корректный с архитектурной точки зрения пример:
```
def mail_sender(func, email):
if func.__name__ == 'step14':
# Здесь был код, отправлявший приветственное письмо
# зарегистрированному пользователю, но его облил супом дедушка :(
pass
@app.route('/step14')
@listen_with(mail_sender)
def step14(email: Arg(str, required=True)):
"""
Здесь был код, регистрирующий юзера в базе, но его съела собака :(
"""
return "ok"
```
Ладно, не пример, а его заготовка.
*Предположительная версия: **0.5***
#### Структура аргументов в БД
А теперь приступим к десерту. Сегодня на «вкусненькое» у нас хранение структуры входящих аргументов в базе данных.
Дело в том, что такая архитектура сводит код, отвечающий за приём и обработку данных, собственно, к данным. И мы можем брать эти данные откуда угодно. Из конфиг-файла, например. Или из БД. А действительно, если подумать, какая между этими двумя источниками данных разница? Приступим.
Для начала нам нужно составить таблицу соответствий объектов исполняемой в текущий момент программы с данными, импортируемыми из БД. В примере мы будем использовать только один тип, уже описанный нами выше. Поэтому пока что здесь будет только он:
```
TYPES = {'IntArg': IntArg}
```
Теперь нам нужно описать модель, которая, собственно, и будет хранить и выдавать информацию о входящих аргументах точек входа.
```
class DBArg(Document):
name = StringField(max_length=30, min_length=1, required=True)
arg_type = StringField(default="IntArg")
params = DictField()
def get_arg(self):
arg = TYPES[self.arg_type](**self.params)
arg.db_entity = self
return arg
```
Здесь, как мы видим, указано имя аргумента, её тип и дополнительные параметры, которые будут передаваться в конструктор данного типа. В нашем случае это IntArg, а параметрами у нас могут быть max\_val, min\_val, required, default и все прочие, которые правильно обрабатываются ОРМ-кой.
Функция `get_arg` предназначена для получения инстанса Arg с хранящейся в БД конфигурацией. Теперь нам нужна такая же балалайка для структур, которые мы обычно присобачиваем к функциям, описывая отдельные аргументы посредством аннотаций. Да-да, всё это сливается в специфичную конструкцию, которая потом и скармливается парсеру аргументов.
```
class DBStruct(Document):
args = ListField(ReferenceField(DBArg))
def get_structure(self):
return {x.name: x.get_arg() for x in self.args}
```
Она намного проще, и вряд ли её стоит описывать отдельно. Пожалуй, стоит уточнить для людей, не «общавшихся» с mongoengine, что конструкция `ListField(ReferenceField(DBArg))` значит всего лишь что в БД в этом поле у нас будет храниться список из элементов класса DBArg.
А ещё нам нужна штука, которая будет компоновать приведённое выше во что-то цельное и конкретное. Скажем так, применять это всё к живым задачам. И такая задача есть. Давайте предположим, что у нас с вами есть магазин или аукцион. Иногда бывает так, что по тех. заданию в админке, кроме всего прочего, должна быть возможность создавать категории товаров, в каждой из которых будут свои параметры, присущие только ей. Вот к этой задаче и приложимся.
```
class Category(Document):
name = StringField(primary_key=True)
label = StringField()
parent = ReferenceField('self')
arg_structure = ReferenceField(DBStruct)
def get_creator(self):
@Endpoint
@annotate(**self.arg_structure.get_structure())
def creator(**kwargs):
return Item(data=kwargs).save()
creator.__name__ = "create_" + self.name
return creator
def get_getter(self):
pass
```
Здесь у нас описана модель категории. У неё будет системное имя, необходимое для именования функций и эндпоинтов, отображаемое имя, которое для нас пока вообще ничего не значит, и родитель (ага, сделаем заранее заготовку для inheritance). Кроме того, указана используемая для данной категории структура данных. И, наконец, описана функция, которая автоматически создаст функцию-создатель для данной категории. Сюда бы неплохо прикрутить кэш и прочие вкусности, но пока что, в рамках эксперимента, проигнорируем это.
И, наконец, нам нужна модель для хранения пользовательских данных, через которую конечные пользователи и будут заливать инфу о товарах. У нас, как и во всех предыдущих примерах, это будет представлено в упрощённом виде:
```
class Item(Document):
data = DictField()
category = ReferenceField(Category)
```
Думаю, тут особых разъяснений не требуется вовсе.
Ну а теперь давайте создадим первую категорию товаров:
```
>>> weight = DBArg(name="weight", params={'max_val': 500, 'min_val':0, 'required': True}).save()
>>> height = DBArg(name="height", params={'max_val': 290}).save()
>>> human_argstructure = DBStruct(args=[weight, height]).save()
>>> human = Category(name="human", arg_structure=human_argstructure).save()
```
Да, я в курсе что продавать людей не очень этично, но так уж вышло :)
Теперь нам нужна обёртка, при помощи которой мы и будем создавать наименования товаров:
```
@app.route('/step15_abstract')
def abstract_add_item(category: ItemArg(Category, required=True, p_type=str)):
creator = category.get_creator()
wrapped_creator = app._arg_taker(creator)
return str(wrapped_creator().id)
```
Сейчас это выглядит очень уродливо. Связано это с ещё одной ошибкой в архитектуре. Впрочем, куда менее значительной, чем предыдущая. Ну да ладно. Сейчас объясню что тут происходит.
Сначала мы получаем инстанс категории способом, который уже был описан выше (см. пример с моделью `Note`). Соответственно, если пользователь попробует добавить товар в несуществующую категорию, он получит DoesNotExist. primary key в этой категории — её системное наименование, и именно его пользователь должен передвать в качестве идентификатора. В нашем случае это `human`. Соответственно, весь запрос должен выглядеть так:
`localhost:5000/step15_abstract?category=human&weight=100&height=200`
Остальная часть предназначена для того, чтобы вызываемый конструктор получил другие параметры. `app._arg_taker` — декоратор, который позволяет эндпоинту «добрать» недостающие аргументы из source. В нашем случае это request.args, но, в принципе, источник может быть любым. Собственно, в этом фрагменте моя архитектурная ошибка и заключается. По-хорошему, нужды оборачивать вложенные эндпоинты в такой декоратор возникать не должно.
*Предположительная версия: **никогда, это просто опыт***
#### Заключение и будущее
Ну, пожалуй, на этом сегодня и закончим. Теперь можно порассуждать на пространные темы. В первую очередь я бы хотел выразить благодарность всем откликнувшимся на первые посты. Даже несмотря на то, что никто так и не сделал ни одного конструктивного предложения, вы мне очень помогли в моральном плане :)
А теперь коротко о намерениях и желаниях.
Главным направлением ближайших месяцев будет комментирование кода, рефакторинг и покрытие тестами. Да, я и сам знаю что в этой области мой код просто отвратителен, глупо было бы это отрицать.
Кроме того, хотелось бы написать ещё парочку гейтов, вроде фласкового, к другим фреймворкам. В общем, я бы хотел найти такие места, где моя библиотека была бы полезна. Пока на примете только tornado и argparse.
Что же касается самой библиотеки, здесь я считаю важным сосредоточиться на обратном информировании. Допустим, мы используем thunderargs для написания restful-интерфейса. Было бы круто, если б он мог дать информацию конечной библиотеке, которая бы позволила сформировать какое-то подобие json-rpc, чтобы клиент по запросу `OPTIONS` мог узнать какие параметры какой из методов принимает и какие в их эндпоинтах могут произойти ошибки.
Позже я напишу ещё одну, заключительную статью. Она будет уже жёстко привязана к «реальной жизни». Полагаю, что там будет описание процесса кодинга какого-нибудь сервиса. Сейчас у меня только одна идея, и она связана с системой тегов на одном интересном сайте (с грустной пандой). Но я буду рад послушать и другие предложения. Микроблоги, Q&A-форумы, что угодно. Мне плевать на банальность или что-либо подобное. Важно чтобы на примере данного кода можно было показать как можно больше аспектов моего «питомца». Кроме всего прочего, это позволит проверить его в деле, и, возможно, найти пару багов или архитектурных недочётов.
Спасибо за внимание. Как всегда, рад любой критике и любым пожеланиям.
[основная репа](https://bitbucket.org/dsupiev/thunderargs)
[фласк-гейт](https://bitbucket.org/dsupiev/flask-thunderargs) (код всех экспериментов из статьи находится здесь) | https://habr.com/ru/post/190088/ | null | ru | null |
# Re: Проблема «maximum-subarray» на примере курса доллара
После прочтения недавней статьи [«Проблема «maximum-subarray» на примере курса доллара»](http://habrahabr.ru/blogs/algorithm/129576/) 3 раза, мне захотелось плеваться. *В статье предлагается найти промежуток дат, за который можно было заработать больше всего на разнице в курсе доллара к рублю за последние 5 лет.* Автор предлагает свое «красивое» решение этой задачи, которое он нашел сам (разделяй и властвуй называется, ага), и которое работает за O(n lg n)…
Товарищи, это стыд и срам в блог «Алгоритмы» публиковать очевидно не оптимальное решение тривиальной задачи. **Максимальная сумма элементов подмассива в массиве ищется за O(n)!** Хоть бы википедию почитали по [этой задаче](http://en.wikipedia.org/wiki/Maximum_subarray_problem).
Нормальное решение под катом.
На самом деле там даже «предподготавливать» ничего не нужно. В статье все перевернуто вверх ногами. Котировки и есть предподготовленныe данныe для решения задачи «maximum-subarray». Задача, решаемая автором не сводится к задаче «maximum-subarray». Наоборот — решение проблемы «maximum-subarray» сводится к тому, что попытался сделать автор. Все что нужно найти, это такие индексы i <= j для некоторого массива A, чтобы A[j]-A[i] было максимальным (или минимальным).
Задача найти две даты, разница значения курсов для которых максимальна, сводится к тому, что бы **найти такой локальный максимум A[j], чтобы разница между ним и предшествующим ему абсолютным на отрезке (0, j) минимумом A[i] была максимальна**. Это типичный пример [динамического программирования](http://ru.wikipedia.org/wiki/Динамическое_программирование), реализация к тому же понятнее и выглядит куда короче, чем приведенное автором решение:
```
def find(A):
currentMin = 1e308
currentMinIndex = None
maxDiff = -1e308
bestResult = None
for i, v in enumerate(A):
if v < currentMin:
currentMin, currentMinIndex = v, i
if v - currentMin > maxDiff:
maxDiff, bestResult = v - currentMin, (currentMinIndex, i)
return bestResult, maxDiff
```
Здесь currenctMin, currentMinIndex — текущее минимальное значение котировки и его индекс на промежутке (0, i). На i-ом шаге текущий наилучший результат сравнивается с разницей между текущим значением курса и предшествующим ему минимальным курсом (currentMin). Если текущая разница больше — она записывается как лучшая, и так до конца. Языком математики:
```
maxDiff(0) = -infinity
maxDiff(i) = max(maxDiff(i-1), A[i] - min(A[0:i])),
где min(A[0:i]) - минимальное значение на промежутке от 0 до i.
```
Ссылки:
[Предыдущий топик](http://habrahabr.ru/blogs/algorithm/129576/)
[Maximum subarray problem](http://en.wikipedia.org/wiki/Maximum_subarray_problem)
[Динамическое программирование](http://ru.wikipedia.org/wiki/Динамическое_программирование)
PS. Я бы не публиковал ответ отдельной статьей, если бы предыдущий топик не вышел на главную. Простите меня. | https://habr.com/ru/post/129755/ | null | ru | null |
# Google Tag Manager: неочевидные и полезные настройки триггеров
Маркетолог в [Otzyvmarketing](https://otzyvmarketing.ru/) Станислав Романов рассказал, как с помощью диспетчера тегов Google Tag Manager (GTM) настроить аналитику и отслеживать скачивание файлов с сайта. Статья для тех, кто знает основы языка JavaScript и уже работал с GTM.
Что такое dataLayer
-------------------
DataLayer — обычная переменная JavaScript. В нее можно записывать данные, чтобы затем передать их сервисам Google:
Название переменной можно изменить — вместо переменной `dataLayer` использовали имя `dataOlga`:
Различие dataLayer=[] и dataLayer.push()
----------------------------------------
Если объявить `dataLayer=[]`, то в памяти компьютера это имя будет ссылаться на целый массив. Таким образом, присваивание переменной новых данных означает простую перезапись значений. Теряется доступ к переменным из первого массива.
Это выглядит примерно так:
При этом `dataLayer.push()` — не переменная и не массив. Это метод, который можно применять к любому массиву и либо получать что-то на выходе, либо как-то изменять сам массив. Иными словами, берем массив dataLayer и применяем к нему метод `push()` — получаем `dataLayer.push()`. `Push` не перезаписывает данные, как в случае переопределения массива, а добавляет к массиву новые значения.
Лучше всего при работе с GTM использовать метод `push` так:
В таком виде `push` нужно применять, чтобы дополнительно проверить, была ли вообще задана переменная `dataLayer` как массив. Проверка позволяет избежать ненужных ошибок при работе сайта.
Как настроить аналитику на одностраничниках
-------------------------------------------
GTM позволяет без проблем синхронизировать работу одностраничника с Google Analytics. Под одностраничником я подразумеваю сайт, где все страницы имеют единственную оболочку, а новые данные появляются на сайте динамически посредством AJAX. Он мешает обычной работе GA, поэтому тут не обойтись без триггера GTM:
После создания триггера следует применить его к Universal Analytics:
Теперь GA сможет получать данные не только, когда пользователь заходит или уходит со страницы, но и во всех остальных случаях перегрузки динамических данных.
Правда, описанный выше метод не подходит для сайтов, где используются различные переменные get-запросов и «портится» URL. Для таких усложненных адресов придется настраивать GTM более хитрым образом.
### 1. Настраиваем переменные
Заходим в настройки раздела «Переменные» и выбираем New History Fragment и History Source — они нужны для сохранения URL вместе с get-запросами и их проверки.
После этого придется поработать с JavaScript и создать свою переменную `getPathWithFragment`, в которую записываем URL. Адрес отправится в GA и таким образом поможет аналитике Google разобраться, когда URL на самом деле меняется:
Код возвращает путь, строку и хеш URL-адреса.
### 2. Создаем триггер
После настройки триггера History fragment change выбираем его тип. Здесь следует взять History change и выбрать активацию popstate. Все эти манипуляции позволят зафиксировать изменение активной записи истории:
### 3. Настраиваем тег
Далее настраиваем Universal Analytics. В настройках выбираем Page и переменную `getPathWithFragment`, которую создали ранее:
Вот и все, осталось только добавить триггер History fragment change и проверить работу тега.
### 4. Для чего нужен тег
Если пользователь, зашедший на сайт, нажимает на ссылку, которая нужна для подгрузки новых данных динамической страницы, срабатывает созданный триггер и, как следствие, тег GA. Благодаря этому данные бесперебойно поступают в аналитику Google.
Как отслеживать исходящие ссылки и загрузки файлов
--------------------------------------------------
Отслеживание ссылок бывает очень полезно. Так можно узнать, куда пользователь переходит с сайта и как часто он это делает. Настройка GTM в этом случае немного отличается от того, что было описано выше. Для отслеживания нужно создать переменную, в которую система будет записывать все необходимые для аналитики данные. Запись будет происходить тогда, когда сработает триггер.
### 1. Создаем переменную
Нам нужно объявить новую переменную, которая будет регистрировать событие. Можно назвать ее Click\_URL\_Hostname. Поскольку переменная будет содержать адрес, то ее тип будет URL. При этом лучше убрать www, чтобы избежать удвоения информации:
### 2. Создаем триггер
Выбираем тип «Только ссылки». В качестве условия выбираем ранее созданную переменную Click\_URL\_Hostname:
### 3. Создаем тег
Создаем тег, который будет отслеживать действия пользователя и повторяем алгоритм, который описывали выше:
Если все сделали правильно, то тег должен работать. Конечно, его нужно проверить с помощью отладчика. Отметим, что UA — это постоянная, в которую записан ID аналитики. Это обычный прием программистов: вместо чисел использовать константы, чтобы потом легко производить массовые замены.
Как отслеживать скачивание файлов с помощью Google Tag Manager
--------------------------------------------------------------
Если вам нужно узнать, как, когда и с какой частотой пользователи скачивают файлы — воспользуйтесь одной из систем аналитики или настройте GTM.
Создаем триггер, выбираем в качестве типа «Только ссылки». Далее настраиваем активацию Click URL:
Такая настройка GTM позволит зафиксировать скачивание файлов с расширением xlsx, pdf, docx, zip и csv.
После этого можно создать тег, выбрав тип «Событие» и настроив параметры. Нечто подобное мы уже делали выше, когда отслеживали исходящие ссылки.
Мнения экспертов: почему выбирают Google Tag Manager
----------------------------------------------------
**Дмитрий Ничипоров, специалист по платному трафику в Elama.**
«Маркетологам важно следить за рекламными кампаниями. Чтобы измерять разнообразные результаты рекламы, нужна полноценная аналитика. При должной настройке статистика рекламы позволяет оптимизировать бюджет, сделать кампанию более эффективной, повысить CTR и даже снизить цену привлечения клиента.
На мой взгляд, GTM — это незаменимая и очень удобная система, которая позволяет гибко управлять тегами. Достаточно один раз правильно настроить код, и потом без всякого труда получать необходимые данные о сайте и клиентах.
Я обычно использую GTM тогда, когда мне необходимо установить на сайт аналитику, проверить эффективность коллтрекинга и чатов, зафиксировать определенные конверсии. Часто я использую GTM при ведении рекламных кампаний для интернет-магазинов.
Ясно, что для компаний, в которых нет штатного программиста, GTM будет незаменимым диспетчером тегов. Ведь никаких особенных знаний для его использования не требуется. Достаточно базового понимая того, как устроены html и js.
При этом GTM будет полезен как обычным специалистам, маркетологам и рекламщикам, так и крупным компаниям и агентствам, которые занимаются интернет-рекламой».
**Денис Лисогоря, digital-аналитик в OWOX BI.**
«GTM — отличный способ упростить себе работу с аналитикой на сайте. Это незаменимая вещь для отслеживания и анализа поведения пользователей. С его помощью можно легко управлять процессом сбора данных с сайта, путем редактирования и настройки тегов.
Мне больше всего нравится, что обычно участие разработчика требуется один раз — установить код на сайте, а все остальные манипуляции можно делать в интерфейсе GTM. Это минимизирует вашу зависимость от разработчиков. GTM также позволяет использовать огромное количество готовых интеграций с другими сервисами, в нем есть режим тестирования и отладки, что дает возможность протестировать работу тегов прежде, чем добавлять их на сайт, а также еще множество разных плюшек.
Думаю, для что специалистов, которые занимаются сбором данных, хотят оперативно влиять на изменение требований к данным или изменениям на сайте, хотят сэкономить бюджет – стоит присмотреться к этому инструменту. Важно отметить, что по работе с GTM достаточно много разной информации, есть официальный форум и справка, где вы всегда сможете найти ответ на свой вопрос.
На данный момент есть [Галерея шаблонов](https://tagmanager.google.com/gallery/#/?page=1)) (Community Template Gallery), в которой вы найдете шаблоны тегов, помогающие решить практически любые задачи, например настроить сбор данных для расширенной электронной торговли. Короче говоря, GTM – это целый океан возможностей!».
От редакции
-----------
* Курс для новичков «[Старт в программировании](https://netology.ru/programs/startdevelopment?utm_source=habr&utm_medium=externalblog&utm_campaign=bdev_sd_ou_&utm_content=13112019_gtm)»
* Профессия «[Python-разработчик](https://netology.ru/programs/python?utm_source=habr&utm_medium=externalblog&utm_campaign=bdev_pd_ou_&utm_content=13112019_gtm)»
* Онлайн-курс «[Разработчик на Kotlin](https://netology.ru/programs/kotlindevelopment?utm_source=habr&utm_medium=externalblog&utm_campaign=bdev_kt_ou_&utm_content=13112019_gtm)» | https://habr.com/ru/post/475608/ | null | ru | null |
# Используем Twitter по назначению
Однажды мне было очень скучно. Настолько, что я решил достать все детали своего «конструктора» и собрать что-нибудь.
В закромах нашлось следующее: Arduino совместимая плата, роутер tp-link mr3020, модуль GPS, гироскоп\акселерометр, и куча всякой прочей ерунды.
Забегая вперед, чтобы не огорчать некоторых читателей, скажу, что модуль GPS и гироскоп не пригодились
.
Причем тут twitter. Мое отношение к сабжу балансирует на грани безразличия и негатива. Ну что можно такого интересного рассказать используя всего 140 символов без картинок и видео? Непонятная игрушка для тех, кто живет в социальных сетях и постит о том что он съел на завтрак. Это мое личное мнение, если оно не совпадает с вашим, я могу это понять. Поэтому прошу уважаемых читателей не холиварить на эту тему, хотя бы в комментариях к этой статье.
Все эти мысли меня натолкнули на идею для незаменимого девайса, который будет твитить при каждом посещении мной туалета! Ну чтобы все были в курсе. И не просто о посещении, а более подробно: что именно я там делал. Приступим.
Первое что придется сделать — определить критерии. Я считаю, что признаки нахождения меня в туалете — это закрытая дверь и включенный свет. Под рукой оказался какой-то датчик от автоматических ворот, из которого был извлечен светочувствительный элемент.
Поигравшись с мультиметром, я выяснил, что при изменении освещенности в нем возникает разность потенциалов. При максимальной освещенности «напряжометр» показал примерно 0,330 вольт. Цепляем его к «ардуине». Определять положение двери (открыта\закрыта) я решил просто замыканием контактов. Это кстати оказалось самым сложным, потому что подходящей кнопки у меня не нашлось.
Вот программка для «ардуины»:
```
#include // подключаем модуль
SoftwareSerial mySerial(2, 3); // RX, TX пины для передачи по rs323
int cnt = 0; // Счетчик секунд
void setup() {
mySerial.begin(115200); // инициализируем порт
mySerial.println("Halo world");
}
void loop() {
int lightValue = analogRead(A0); // считываем значения с датчика света
int doorValue = analogRead(A1); // считываем положение двери
boolean light = false;
boolean door = false;
if(lightValue > 60) light = true; // если значение больше 60 - значит свет включен. Порог определен экспериментально
if(doorValue > 500) door = true; // при разомкнутой сети значение должно быть 0, при замкнутой 1023.
//Но там всякие помехи, дрожание контактов... Так надежней
if(light && door) cnt++; // если я внутри - считаем секунды
else {
if(cnt>0) { // если только вышел
mySerial.print("<");
mySerial.print(cnt); // шлем в порт секунды пребывания
mySerial.println(">");
}
cnt = 0; // обнуляем счетчик
}
delay(1000);
}
```
Второе что нам понадобится — это роутер. Я взял tp-link mr3020. На него надо установить OpenWRT, настроить подключение к интеренту и установить php. Как это делается тут описано много раз, в том числе и мной. Поэтому не будем на этом задерживаться. Только важные моменты: вот мы слушаем порт и получаем нужные нам данные
```
php
//Отделяем дочерний процесс от основного
$child_pid = pcntl_fork();
if ($child_pid) {
exit();
}
posix_setsid();
// Тут функция постинга в твитер
include("post.php");
$filename = "/dev/ttyATH0"; // serial-порт роутера
$handle = fopen($filename, "r"); // открываем
while (!feof($handle)) {
$sym = fread($handle, 1); // читаем по одному байту за цикл
if($sym=='') {
$f=false;
echo "<<$cnt>>\n";
flush();
act($cnt);
$cnt='';
}
elseif($sym=='<') $f=true;
elseif($f) $cnt .= $sym;
}
fclose($handle);
function act($time) {
if($time<40) {echo "dunno\n";}
if(40<=$time && $time<150) { postMyPost("i was pee");}
if(150<=$time && $time<300) { postMyPost("i was poo");}
if(300<=$time && $time<900) { postMyPost("i take shower");}
}
?>
```
Постим с помощью этой библиотеки:
Третий важный момент — это возможность постить в твитер программно. Для этого нужно авторизоваться, зайти на [dev.twitter.com](https://dev.twitter.com/), навести курсор вверху справа на свой светлый лик, выбрать My Applications. Делее Create New Application, отвечаем на все вопросы. Потом в Settings обязательно указать Access: Read and Write. Затем в Details нажимаем Create my access token и запоминаем поля Consumer key, Consumer secret, Access token и Access token secret, они нам еще понадобятся. Качаем библиотеку для PHP: [github.com/abraham/twitteroauth/archive/master.zip](https://github.com/abraham/twitteroauth/archive/master.zip)
В config.php подставляем запомненные ранее данные:
```
define('CONSUMER_KEY', 'xxxxxxxxxxxxxxxxxxxxxxxxxx');
define('CONSUMER_SECRET', 'yyyyyyyyyyyyyyyyyyyyyyyyyy');
define('OAUTH_TOKEN', 'qwertyqwertyqwertyqwertyqwertyqwerty');
define('OAUTH_SECRET', 'sashagreysashagreysashagreysashagrey');
define('OAUTH_CALLBACK', 'http://example.com/twitteroauth/callback.php');
```
Ну и сам скрипт для отправки (post.php):
```
PHP
require_once('lib/twitteroauth/twitteroauth.php');
require_once('lib/config.php');
function postMyPost($status) {
$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET,OAUTH_TOKEN,OAUTH_SECRET);
$connection-format = 'xml';
$connection->post('statuses/update', array('status'=>$status));
}
?>
```
Процесс отладки:
Изделие в сборе:
Подключение:
Использование:
подключаемся к роутеру по SSH, запускаем скрипт:
```
root@OpenWrt:~# php-cgi /www/twitter/run.php
X-Powered-By: PHP/5.4.11
Content-type: text/html
root@OpenWrt:~#
```
При этом запускается фоновый процесс, а родительский завершается. Таким образом скрипт будет работать даже после отключения от консоли.
Чтобы остановить скрипт, нужно посмотреть ID процесса и сделать ему kill:
```
root@OpenWrt:~# ps | grep run.php
1665 root 10436 S php-cgi /www/twitter/run.php
1670 root 1492 S grep run.php
root@OpenWrt:~# kill 1665
```
Результат работы можно посмотреть тут: [twitter.com/kruz\_ivan](https://twitter.com/kruz_ivan)
Что в планах:
1) Прикрутить камеру, чтобы можно было еще и видеть фото самого процесса.
2) Сейчас активно развиваются технологии передачи запахов. С появлением первый серийных устройств, я обязательно задействую их в своем проекте.
3) Создание подобных устройств, интегрированных с соцсетями, которые будут твитить когда вы, например, открываете холодильник, или инстаграмить фото каждый раз, когда вы садитесь принимать пищу. | https://habr.com/ru/post/181852/ | null | ru | null |
# Вычисление выражений на Nemerle и Mono.
За weekend на хабре появились три статьи по разбору математических выражений: [Компилятор выражений](http://habrahabr.ru/blogs/development/50139), [Парсер математических выражений](http://habrahabr.ru/blogs/net/50158/) и [Вычисление значения выражения](http://habrahabr.ru/blogs/algorithm/50196/) и один [комментарий](http://habrahabr.ru/blogs/development/50139/#comment_1315967), в котором код на прологе по краткости и выразительности рвет примеры в этих статьях.
Ниже я покажу, как использовать стандартные средства платформы и языка для достижения того же результата, а именно вычислению выражений.
На конференции PDC2008 Anders Hejlsberg сделал доклад, в котором проследил эволюцию языка C#. Он рассмотрел уже существующие версии и сделал обзор будущих: в 4ой версии разработчиков ждет возможность разбавить строгую систему типов возможностями из динамических языков, а к пятой версии компилятор будет полностью переписан под управляемый код, и его можно будет использовать как сервис (compiler as a service).
Для тех программистов, которые мечтают опробовать эту идеологию (compiler as a service) уже сейчас, будет приятной новостью то, что они могут это сделать. Дело в том, что компилятор nemerle написан на nemerle, и его можно использовать как простую библиотеку. Стоит так же отметить то, что в этом случае в процессе его работы не будет создано на диске никаких файлов, только если Вы не хотите обратного. Ниже — пример кода, который использует компилятор как библиотеку и который эффективно решает проблему разбора/вычислений выражений=)
`using System;
using System.Console;
using Nemerle.Evaluation.Evaluator;
module Program
{
Main() : void
{
def function = EvaluateExpression("x => x + 1.0") :> double->double;
WriteLine(function(2.0));
}
}`
Думаю, что любому программисту, владеющим C# этот код понятен, отдельно отмечу только, что module — синоним static class, double->double — тип функции, аналог Func, а using System.Console раскрывает System.Console так, что его статические методы «превращаются» в глобальные функции/процедуры, то есть вызов WriteLine(function(2.0)) это на самом деле вызов Console.WriteLine(function(2.0)).
Другой возможностью попробовать будущее на вкус является платформа mono. Я долго ждал выхода версии 2.2 и удивлен, что на хабре про её выход еще никто не написал. Мои ожидания были основаны на заметке, которую Miguel De Icaza опубликовал в своем блоге в сентябре, в нем он анонсировал, что в следующей версии mono (теперь она уже текущая) добавиться REPL, который в свою очередь основан на идеологии compiler as service. Ниже — код на C# под mono, аналогичный коду на Nemerle:
`using System;
using Mono.CSharp;
public class Program
{
public static void Main(string[] args)
{
var function =
Evaluator.Evaluate ("new System.Converter(x=>x+1.0);")
as Converter<double,double>;
Console.WriteLine(function(2.0));
}
}`
P.S.
Отдельно хочется отметить, то что и Nemerle, и Mono являются open source проектами. Эту особенность я использовал при создании этой заметки, а именно, исчерпывающей документации по использования compile as a service в Nemerle и Mono я не нашел, но зато быстро смог найти всю интересующую меня информацию, изучая исходные коды. | https://habr.com/ru/post/48945/ | null | ru | null |
# DoH в картинках
Угрозы конфиденциальности и безопасности в интернете становятся серьёзнее. Мы в Mozilla внимательно их отслеживаем. Считаем своей обязанностью сделать всё возможное для защиты пользователей Firefox и их данных.
Нас беспокоят компании и организации, которые тайно собирают и продают пользовательские данные. Поэтому мы добавили [защиту от слежения](https://blog.mozilla.org/firefox/tracking-protection-always-on/) и создали [расширение контейнера Facebook](https://blog.mozilla.org/firefox/facebook-container-extension/). В ближайшие месяцы появится ещё больше защитных мер.
Сейчас мы добавляем в список ещё две технологии:
* DNS по HTTPS — новый стандарт IETF, в разработке которого мы приняли участие
* Trusted Recursive Resolver — новый безопасный способ резолвить DNS, предоставляется совместно с [Cloudflare](https://www.cloudflare.com/)
Благодаря двум этим инициативам устраняются утечки данных, которые являлись частью системы доменных имен с момента её создания 35 лет назад. И нам нужна ваша помощь в тестировании. Давайте посмотрим, как DNS по HTTPS и Trusted Recursive Resolver защищают наших пользователей.
Но сначала посмотрим, как веб-страницы передаются по интернету.
Если вы уже знаете, как работают протоколы DNS и HTTPS, можете перейти к разделу о том, [как помогает DNS по HTTPS](#1).
Краткий курс по HTTP
====================
Когда люди объясняют, как браузер загружает веб-страницу, то обычно объясняют это так:
1. Ваш браузер делает запрос GET на сервер.
2. Сервер отправляет ответ, который представляет собой файл, содержащий HTML.
Эта система называется HTTP.
Но эта схема слишком упрощена. Ваш браузер не разговаривает напрямую с сервером. Наверное потому что они не близки друг другу.
Сервер может быть за тысячи километров. И вероятно, между вашим компьютером и сервером нет прямой связи.
Таким образом, прежде чем запрос попадёт из браузера на сервер, он пройдёт через несколько рук. То же самое верно для ответа.
Я думаю об этом как о школьниках, передающих друг другу записки в классе. Снаружи в записке написано, кому она предназначена. Ребёнок, написавший записку, передаст её соседу. Затем тот следующий ребёнок передаёт её одному из соседей — вероятно, не конечному получателю, а тому, кто находится в нужном направлении.
*— Псст… передай это Сэнди*
Проблема в том, что любой по пути может открыть записку и прочитать её. И нет никакого способа узнать заранее, по какому пути будет проходить записка, поэтому неизвестно, какие люди получат доступ к ней.
Она может оказаться в руках людей, которые сделают вредные вещи…
Например, поделятся содержанием записки со всеми.
*— О, это пикантно…. Эй народ! Дэнни влюбился в Сэнди!*
Или изменят ответ.
*— Я тебе тоже нравлюсь?
— Хе-хе, подшучу над ним и напишу «Нет»...*
Чтобы устранить эти проблемы, создана новая безопасная версия HTTP. Она называется HTTPS: это словно замок на каждом сообщении.
Только браузер и сервер знают комбинацию для снятия блокировки. Даже если сообщения проходят через несколько маршрутизаторов, только вы и веб-сайт фактически можете прочитать содержимое.
Это решает многие вопросы безопасности. Но между вашим браузером и сервером всё еще есть незашифрованные сообщения. Значит, люди на пути всё ещё могут вмешиваться в ваши дела.
Например, данные по-прежнему открыты во время установки подключения. При отправке исходного сообщения на сервер вы также отправляете имя сервера в поле “Server Name Indication”. Это позволяет операторам сервера запускать несколько сайтов на одном компьютере и в то же время понимать, с кем вы хотите связаться. Этот первоначальный запрос — часть установки шифросвязи, но сам первоначальный запрос не шифруется.
Другое место, где данные открыты — это DNS. Но что такое DNS?
DNS: система доменных имён
==========================
В метафоре с передачей записок в классе я сказала, что имя получателя должно быть написано снаружи записки. Это верно и для HTTP-запросов… они должны объявить, куда собираются идти.
Но вы не можете использовать обычное имя сайта. Ни один из маршрутизаторов не понимает, о ком вы говорите. Вместо этого необходимо использовать IP-адрес. Вот как маршрутизаторы по пути понимают, на какой сервер вы хотите отправить запрос.
*— Пожалуйста, отправь это на 208.80.154.224*
Это вызывает проблемы. Пользователям неудобно запоминать цифры IP-адреса. Хочется дать сайту запоминающееся имя… которое отложится в памяти у людей.
Вот почему у нас есть система доменных имен (DNS). Ваш браузер использует DNS для преобразования имени сайта в IP-адрес. Этот процесс — преобразование доменного имени в IP-адрес — называется разрешением имени домена или резолвингом.
Как браузер решает задачу?
Один из вариантов — завести большой список вроде телефонного справочника в браузере. Но по мере того, как появляются новые веб-сайты или перемещаются на новые серверы, будет трудно поддерживать этот список в актуальном состоянии.
Таким образом, вместо одного списка для всех доменных имён существует много небольших списков, связанных друг с другом. Это позволяет им управляться независимо.
Для получения IP-адреса, соответствующего доменному имени, необходимо найти конкретный список, который содержит нужное доменное имя. Это похоже на поиск клада.
Как выглядит такой поиск клада для сайта вроде англоязычной Википедии, `en.wikipedia.org`?
Домен можно разделить на части.
С такими частями можно начать охоту на список, содержащий IP-адрес сайта. Но нам нужна помощь в поисках. Инструмент, который осуществляет эту охоту вместо нас и находит IP-адрес, называется резолвером.
Сначала резолвер обращается к так называемому корневому DNS-серверу. Он знает несколько различных корневых DNS-серверов, поэтому отправляет запрос одному из них. Резолвер спрашивает корневой DNS, где найти дополнительные сведения об адресах в доменной зоне верхнего уровня `.org`.
*— Вы не знаете, как пройти на en.wikipedia.org?
— Я не знаю ни о чём в зоне .org, но 5.6.7.8 может помочь*
Следующий сервер называется сервером имён домена верхнего уровня (TLD). Сервер TLD знает обо всех доменах второго уровня, которые заканчиваются на `.org`.
Впрочем, он ничего не знает о поддоменах `wikipedia.org`, поэтому тоже не знает IP-адрес `en.wikipedia.org`.
Сервер имён TLD посоветует резолверу задать этот вопрос серверу имён Википедии.
*— Вы не знаете, как пройти на en.wikipedia.org?
— Иди и спроси у 11.21.31.41, он знает о сайтах в домене wikipedia.org*
Резолвер почти закончил. Сервер имён Википедии — это то, что называется авторитативный сервер. Он знает обо всех поддоменах `wikipedia.org`. Таким образом, он знает и о `en.wikipedia.org`, и об остальных поддоменах, такие как немецкая версия `de.wikipedia.org`. Авторитативный сервер сообщает резолверу, по какому IP-адресу можно получить HTML-файлы для этого сайта.
*— Вы не знаете, как пройти на en.wikipedia.org?
— О да, просто иди на 208.80.154.224*
Резолвер вернёт операционной системе IP-адрес `en.wikipedia.org`.
Этот процесс называется рекурсивным разрешением, потому что приходится ходить туда и обратно, задавая разным серверам по сути один и тот же вопрос.
Я говорила, что нам нужен резолвер для помощи в поисках. Но как браузер находит этот резолвер? В общем, он спрашивает у операционной системы.
*— Мне нужен резолвер. Можешь помочь?
— Конечно, позволь познакомить тебя с резолвером, который я использую*
Как операционная система знает, какой резолвер использовать? Существует два возможных способа.
Вы *можете* настроить компьютер на использование определённого резолвера, которому доверяете. Но очень немногие люди делают это.
Вместо этого большинство просто использует настройки по умолчанию. И по умолчанию ОС будет использовать любой резолвер, какой скажет сеть. Когда компьютер подключается к сети и получает свой IP-адрес, то сеть рекомендует определённый резолвер.
*— Можно мне получить IP-адрес?
— Без проблем! А если тебе понадобится резолвер, рекомендую вот этот*
Это значит, что используемый резолвер может изменяться несколько раз в день. Если вы направляетесь в кафе поработать днём, то вероятно используете другой резолвер, чем утром. И так происходит даже если вы настроили свой собственный резолвер, потому что в протоколе DNS нет никакой безопасности.
Как можно эксплойтить DNS?
==========================
Так как эта система подвергает опасности пользователей?
Обычно резолвер сообщает каждому DNS-серверу, какой домен вы ищете. Этот запрос иногда включает ваш полный IP-адрес. А если не полный адрес, то всё чаще запрос включает в себя большую часть вашего IP-адреса, что можно легко объединить с другой информацией, чтобы установить вашу личность.
*Содержит большую часть вашего IP-адреса…
… и полный домен, который вы ищете*
Значит, каждый сервер, который вы попросите помочь с разрешением доменных имен, видит, какой сайт вы ищете. Более того, любой по пути к этим серверам тоже видит ваши запросы.
Существует несколько способов, как подобная система подвергает риску данные пользователей. Два основных — трекинг (отслеживание) и спуфинг (подмена).
### Трекинг
Как я говорила выше, по полной или частичной информацию об IP-адресе несложно определить личность того, кто просит доступ к конкретному сайту. Это означает, что DNS-сервер и любой пользователь на пути к этому DNS-серверу (маршрутизатор по пути) может создать профиль пользователя. Они могут составить список всех сайтов, которые вы просмотрели.
И это ценные данные. Многие люди и компании готовы немало заплатить, чтобы увидеть вашу историю посещённых страниц.
*Сколько вы готовы заплатить за информацию о том, на что смотрел Джон Доу?*
Даже если бы нам не пришлось беспокоиться о потенциально гнусных DNS-серверах или маршрутизаторах по пути, всё равно есть риск, что ваши данные соберут и продадут. Потому что сам резолвер — который вам дала сеть — может оказаться ненадёжным.
Даже если вы доверяете рекомендованному резолверу от сети, то вероятно используете его только дома. Как я уже упоминала, каждый раз в кафе, отеле или в любой другой сети вам, вероятно, дадут другой резолвер. И кто знает, какова его политика сбора данных?
Кроме того, что ваши данные собираются и затем продаются без вашего ведома или согласия, систему используют ещё более опасным способом.
### Спуфинг
При помощи спуфинга некто на пути между вами и DNS-сервером меняет ответ. Вместо реального IP-адреса мошенник сообщает вам неправильный IP-адрес для сайта. Таким образом, вам могут заблокировать доступ к реальному сайту или отправить не поддельную версию от мошенников.
*Отправь это на 1.6.6.6… это абсолютно правильный адрес, а вовсе не поддельный сайт, который я контролирую*
Опять же, здесь и сам резолвер может действовать гнусно.
Предположим, вы делаете покупку в магазине Megastore. Вы хотите сравнить цены и посмотреть, не продаётся ли такой товар дешевле в конкурирующем интернет-магазине big-box.com.
Но если вы пользуетесь Megastore WiFi у них в торговом зале, то вероятно используете их резолвер. Он может перехватить запрос к big-box.com и соврать вам, что сайт недоступен.
Как исправить ситуацию с помощью Trusted Recursive Resolver (TRR) и DNS over HTTPS (DoH)?
=========================================================================================
Мы в Mozilla твёрдо убеждены, что несём ответственность за защиту пользователей и их данных, и поэтому работаем над устранением данных уязвимостей.
Представляем две новые функции для исправления ситуации: это доверенный рекурсивный резолвер (Trusted Recursive Resolver, TRR) и DNS по HTTPS (DoH). Потому что на самом деле имеется три угрозы:
1. Вы можете в конечном итоге использовать ненадёжный резолвер, который отслеживает ваши запросы или подменяет ответы от DNS-серверов.
2. Маршрутизаторы по пути могут отслеживать запросы или вмешиваться таким же образом.
3. DNS-серверы могут отслеживать DNS-запросы.
Как этого избежать?
1. Избегать ненадёжных резолверов с помощью TRR.
2. Защищаться от прослушивания и спуфинга с помощью DNS по HTTPS.
3. Передавать как можно меньше данных, чтобы защитить пользователей от деанонимизации.
### Избегать ненадёжных резолверов с помощью TRR
Сети могут перестать рекомендовать ненадёжные резолверы, которые собирают данные пользователей или подделывают DNS-запросы, потому что очень немногие пользователи знают о рисках или о том, как защитить себя.
Даже для пользователей, которые знают о рисках, отдельному пользователю трудно договориться со своим провайдером или другой организацией о гарантиях, что с его DNS-запросами будут ответственно обращаться.
Тем не менее, мы изучили этих риски… и у нас есть определённое влияние. Мы долго искали компанию, которая поможет нам защитить DNS-данные пользователей. И нашли одну такую: [Cloudflare](https://www.cloudflare.com/).
Cloudflare предоставляет сервис рекурсивного резолвинга с политикой конфиденциальности для пользователей. Они обязались удалять все привязанные к конкретным людям данные (personally identifiable data) после 24 часов и никогда не передавать эти данные третьим лицам. Будут проводиться регулярные проверки, что данные действительно удаляются, как было обещано.
Благодаря этому у нас есть доверенный резолвер для защиты приватности пользователей. Это означает, что Firefox может игнорировать резолвер сети, а перейти сразу к Cloudflare. Теперь можно не беспокоиться, что злоумышленники используют резолвер для продажи данных пользователей или спуфинга DNS.
Почему мы выбрали один резолвер? Как и мы, Cloudflare озабочен созданием приватной службы DNS. Они вместе с нами разработали хороший прозрачный резолвер DoH. Компания с готовностью пошла на дополнительную защиту сервиса, поэтому мы рады сотрудничать с ними.
Но это не значит, что вы должны использовать Cloudflare. Пользователи могут настроить Firefox на использование любого рекурсивного резолвера с поддержкой DoH. По мере появления новых сервисов мы планируем реализовать простое обнаружение и переключение между ними.
### Защищаться от прослушивания и спуфинга с помощью DNS по HTTPS
Но резолвер — не единственная угроза. Маршрутизаторы на пути могут отслеживать и подделывать DNS-запросы, поскольку тоже видят содержимое запросов и ответов DNS. К счастью, в интернете уже есть технология для защиты от прослушивания со стороны маршрутизаторов на пути. Это шифрование, о котором я говорила.
Использование HTTPS для обмена DNS-пакетами защищает DNS-запросы наших пользователей от шпионажа.
### Передавать как можно меньше данных, чтобы защитить пользователей от деанонимизации
Вдобавок к доверенному резолверу, который работает по протоколу DoH, мы с компанией Cloudflare работаем над дополнительными мерами безопасности.
Обычно резолвер отправляет полное имя домена каждому серверу: корневому DNS, серверу имён доменов верхнего уровня, второго уровня и т. д. Но сервер Cloudflare будет поступать иначе. Он будет отправлять только ту часть, которая имеет отношение к конкретному DNS-серверу. Это называется [минимизация QNAME](https://datatracker.ietf.org/doc/rfc7816/?include_text=1).
*— Вы не знаете, как пройти на сервер .org?*
Часто резолвер также включает в запрос первые 24 бита вашего IP-адреса. Это помогает DNS-серверу узнать, где вы находитесь, и выбрать ближайший CDN. Но DNS-серверы могут использовать данную информацию для связывания друг с другом разрозненных запросов.
Вместо этого Cloudflare будет делать запрос с одного из собственных IP-адресов, который находится рядом с пользователем. Это обеспечивает геолокацию без привязки к конкретному человеку. Мы также изучаем, как реализовать ещё лучшую, тонкую балансировку нагрузки с учётом конфиденциальности.
Всё это — удаление ненужных частей домена и IP-адреса — означает, что DNS-сервер может собрать о вас гораздо меньше данных.
Что остаётся за рамками TRR с DoH?
==================================
Эти защитные меры сокращают количество людей, которые могут видеть историю посещённых вами страниц. Но они полностью не исключают утечки данных.
После выполнения поиска в DNS для получения IP-адреса по-прежнему необходимо подключиться к веб-серверу по этому адресу. Для этого необходимо отправить запрос. Запрос включает в себя SNI (server name indication) с указанием конкретного сайта на сервере. И этот запрос не шифруется.
То есть ваш интернет-провайдер по-прежнему способен выяснить, какие сайты вы посещаете, потому что они указаны прямо там, в SNI. Информация открыта и для маршрутизаторов, которые передают первоначальный запрос из вашего браузера на веб-сервер.
Но как только вы установили соединение с веб-сервером, всё зашифровано. И самое главное, что данное зашифрованное соединение можно использовать для любого сайта на этом сервере, а не только для того, который вы изначально запрашивали.
Это иногда называют слиянием соединения HTTP/2 (connection coalescing) или просто повторным использованием соединения. Когда вы открываете соединение с совместимым сервером, он сообщит, какие ещё сайты размещаются на нём. Затем вы можете посетить эти сайты, используя существующее зашифрованное соединение.
Почему это полезно? Потому что не нужно открывать новое соединение для подключения к этим другим сайтам. То есть вам не нужно отправлять ещё один незашифрованный первоначальный запрос с указанием SNI и раскрытием информации, на какой сайт вы идёте. Так вы можете посетить любой из других сайтов на том же сервере, не раскрывая их своему провайдеру и маршрутизаторам на пути.
С ростом популярности CDN всё больше отдельных сайтов обслуживаются одним сервером. И поскольку у вас может быть открыто несколько объединённых соединений, вы одновременно подключаетесь к нескольким общим серверам или CDN, посещая все сайты на разных серверах без утечки данных. Так что данная функция всё более эффективно работает как защитный экран.
Каков статус?
=============
Уже сейчас в Firefox вы можете включить DNS по HTTPS, и мы [рекомендуем сделать это](https://blog.nightly.mozilla.org/2018/06/01/improving-dns-privacy-in-firefox/).
Мы хотим включить DoH по умолчанию для всех пользователей, поскольку каждый человек заслуживает конфиденциальности и безопасности, независимо от того, знает он об утечках DNS или нет.
Но это значительное изменение, и его нужно сначала протестировать. Поэтому мы проводим исследование. Половину наших пользователей [Firefox Nightly](https://www.mozilla.org/firefox/channel/desktop/#nightly) мы просим помочь собрать данные о производительности.
В тестировании используется резолвер по умолчанию, как и сейчас, но также запросы отправляются на DoH-резолвер Cloudflare. Затем мы сравниваем результат для проверки, что всё работает как положено.
Для участников исследования ответ Cloudflare DNS пока не используется. Мы просто проверяем, что всё работает, а затем выбрасываем ответ Cloudflare.
Выражаем благодарность за поддержку пользователям Nightly, которые каждый день помогают тестировать Firefox. Надеемся, что вы тоже поможете нам. | https://habr.com/ru/post/413515/ | null | ru | null |
# Как я разрабатывал игру fly bird 2
Это гифка, которую я сделал, чтобы показать вступление и как началась история путешествия птички. У меня есть друг, который не боится рисовать, даже если он не обучался рисованию профессионально. Я общаясь с ним как то вдохновился желанием рисовать и не бояться. В google play у меня есть старая игра, которую я делал на unity, когда только начинал работать с движком.
[https://play.google.com/store/apps/details?id=com.xverizex.fly\_bird&hl=ru≷=US](https://play.google.com/store/apps/details?id=com.xverizex.fly_bird&hl=ru&gl=US)
Два комментария к старой игре дали мне желание сделать новую версию, но уже на C++ + SDL2 + OPENGL ES 3.2 + OPENSLES + glm. То есть я даже рад хотя бы двум комментариям о том что людям нравиться моё творчество, чтобы чувствовать себя прекрасно и продолжать делать игры.
Так как у меня нормального опыта не было делать игры полноценные на sdl2, то я использовал разные виды кода, которые как я думал, что они правильные. Но поработав на работе и изучая код, я увидел что есть помимо того что я знаю (я про очереди сообщений), есть ещё mqueue. И только потом я додумался, что можно с помощью очередей сообщений отправлять из одного потока в другой что-нибудь. Вот пример как выглядела реализация.
```
/* SDL поток */
static int general_thread (void *p)
{
SDL_Event ev;
while (SDL_WaitEvent (&ev)) {
case SDL_MOUSEBUTTON_DOWN:
{
struct event *event = new struct event();
event->type = BUTTON_DOWN;
event->x = ev.x; // здесь я сократил код, по настоящему здесь надо
event->y = ev.y; // преобразовать в нужный формат.
mq_send (mq, (const char *) &event, sizeof (void *), 0);
break;
}
}
}
int main (int argc, char **argv)
{
...
game ();
}
/* И где то в другом файле где находится функция game */
void game ()
{
...
mq_receive (mq, &event, nullptr);
}
```
Перед тем как использовать эту очередь, я удостоверился в том, что в android ndk есть заголовочный файл mqueue.
Я также посмотрел, есть ли OpenAL для android и оказалось, что она не входит в комплект и как почитал в интернете, что лучше писать для android на OpenSLES.
После того как были готовы рисунки для интро, я начал писать код для работы с загрузкой текстур и размещением вершин. В процессе работы я заметил, что можно отражать одну сторону в другую путем замены координат у вершинных буферов. Вот пример как выглядит начальная конфигурация вершин.
```
static void gen_vao_vbo (Link *link)
{
static float v[18] = {
-0.5f, -0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
-0.5f, 0.5f, 0.0f
};
#if 0
static float t[12] = {
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 1.0f,
1.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f
};
#else
static float t[12] = {
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
#endif
```
Я сначала думал что в unity делают правильно, что отсчитывают от центра и исходил из этого и определял экран как.
```
ortho = glm::ortho (-1.0f * aspect, 1 * aspect, 1.0f, -1.0f, 0.1f, 10.0f);
```
вроде такой был код.
Позже я понял неудобство и решил отсчитывать от левого верхнего угла и сделал так.
```
ortho = glm::ortho (0.0f, 2.0f * aspect * aspect, 2.0f, 0.0f, 0.1f, 10.0f);
```
Вообще из-за того, что у меня нет большого опыта в разработке движков, то я наверное делаю ошибки такие, какие делают начинающие разработчики. Например конструктор спрайта выглядит так.
```
Sprite::Sprite (Common &com)
{
aspect = (float) com.screen_width / (float) com.screen_height;
screen_width = com.screen_width;
screen_height = com.screen_height;
ortho = glm::ortho (0.0f, 2.0f * aspect * aspect, 2.0f, 0.0f, 0.1f, 10.0f);
//ortho = glm::ortho (0.0f, (float) com.screen_width, (float) com.screen_height, 0.0f, 0.1f, 10.0f);
pos = glm::translate (glm::mat4 (1.0f), glm::vec3 (0.0f, 0.0f, 0.0f));
program = get_shader (SHADER_MAIN);
glUseProgram (program);
uniform_cam = glGetUniformLocation (program, "cam");
uniform_pos = glGetUniformLocation (program, "pos");
uniform_ortho = glGetUniformLocation (program, "ortho");
uniform_tex = glGetUniformLocation (program, "s_texture");
cur_tex = 0;
play = -1;
}
```
Вообще когда говорят что глобальные переменные это зло, то я думаю что они просто это от кого то услышали и приняли для себя такое же мнение, но мне например не удобно как оказалось передавать объект Common в конструктор. Лучше бы я просто пробросил с помощью extern размеры экрана и всё было бы чище. Да и ещё я по рассуждал, что можно для каждого шейдера отдельный класс создать, чтобы каждый спрайт заново не получал с помощью glGetUniformLocation позиции в шейдере. То есть после компиляции шейдера можно было бы получить все позиции и для спрайта указать например интерфейс к шейдеру или что нибудь подобное, чтобы просто уже было работать. Да и класс шейдера можно было бы интегрировать со спрайтом так, чтобы в рендере спрайта не менять ничего, если ты сменил шейдер. Хотя может я ошибаюсь, но я проработаю этот вопрос.
Еще я столкнулся с проблемами неправильного размера картинки. Спрайты были, одни короче, другие длиннее. Но я путем проб и ошибок выработал правило.
```
as = (float) com.screen_width / (float) com.screen_height;
/* если ширина больше */
float aspect = w / h;
w = 0.42f;
h = w / aspect / as;
/* если высота больше */
aspect = h / w;
h = 0.8f;
w = h * aspect;
```
Вроде бы получилось правильно.
Для загрузки объектов я создал заголовок такого типа.
```
#pragma once
#define TO_STRING_FILENAME(name) name##_STRING
enum TO_DOWNLOADS {
LINK_BIRD,
LINK_INTRO,
LINK_BLOCK,
LINK_FLY_BIRD,
LINK_END_GAME,
LINK_LOGO,
LINKS_N
};
#ifdef __ANDROID__
#define LINK_BIRD_STRING "bird.res"
#define LINK_INTRO_STRING "intro.res"
#define LINK_BLOCK_STRING "block.res"
#define LINK_FLY_BIRD_STRING "fly_bird.res"
#define LINK_END_GAME_STRING "end_game.res"
#define LINK_LOGO_STRING "logo.res"
#else
#define LINK_BIRD_STRING "assets/bird.res"
#define LINK_INTRO_STRING "assets/intro.res"
#define LINK_BLOCK_STRING "assets/block.res"
#define LINK_FLY_BIRD_STRING "assets/fly_bird.res"
#define LINK_END_GAME_STRING "assets/end_game.res"
#define LINK_LOGO_STRING "assets/logo.res"
#endif
```
И если нужно загрузить какой то объект, то мы просто получаем на него ссылку, если он уже был загружен.
```
Link *downloader_load (const enum TO_DOWNLOADS file)
{
switch (file) {
case LINK_BIRD:
if (link[LINK_BIRD] == nullptr)
link[LINK_BIRD] = load_link (TO_STRING_FILENAME (LINK_BIRD));
break;
case LINK_INTRO:
if (link[LINK_INTRO] == nullptr)
link[LINK_INTRO] = load_link (TO_STRING_FILENAME (LINK_INTRO));
break;
case LINK_BLOCK:
if (link[LINK_BLOCK] == nullptr)
link[LINK_BLOCK] = load_link (TO_STRING_FILENAME (LINK_BLOCK));
break;
case LINK_FLY_BIRD:
if (link[LINK_FLY_BIRD] == nullptr)
link[LINK_FLY_BIRD] = load_link (TO_STRING_FILENAME (LINK_FLY_BIRD));
break;
case LINK_END_GAME:
if (link[LINK_END_GAME] == nullptr)
link[LINK_END_GAME] = load_link (TO_STRING_FILENAME (LINK_END_GAME));
break;
case LINK_LOGO:
if (link[LINK_LOGO] == nullptr)
link[LINK_LOGO] = load_link (TO_STRING_FILENAME (LINK_LOGO));
break;
}
return link[file];
}
```
Да, можно было с помощью текста указывать какой объект загружать, но мне так больше нравиться, и нравиться еще из-за того, что легко получить эту ссылку на объект, если он уже был загружен. В link содержится все vao, vbo[2] и номера всех текстур.
Главное меню игры я сделал из одного спрайта, но на экране изображено две птицы. В момент рендера я отражаю спрайт по горизонтали и рисую в разных частях экрана. Вот как я составил код.
```
void Sprite::mirror_right ()
{
glBindVertexArray (link->vao);
glBindBuffer (GL_ARRAY_BUFFER, link->vbo[0]);
float *b = (float *) glMapBufferRange (GL_ARRAY_BUFFER, 0, sizeof (float) * 18, GL_MAP_WRITE_BIT);
float ww = w;
float hh = h;
b[0] = 0;
b[1] = 0;
b[2] = 0;
b[3] = 0;
b[4] = hh;
b[5] = 0;
b[6] = ww;
b[7] = 0;
b[8] = 0;
b[9] = ww;
b[10] = 0;
b[11] = 0;
b[12] = ww;
b[13] = hh;
b[14] = 0;
b[15] = 0;
b[16] = hh;
b[17] = 0;
glUnmapBuffer (GL_ARRAY_BUFFER);
}
void Sprite::mirror_left ()
{
glBindVertexArray (link->vao);
glBindBuffer (GL_ARRAY_BUFFER, link->vbo[0]);
float *b = (float *) glMapBufferRange (GL_ARRAY_BUFFER, 0, sizeof (float) * 18, GL_MAP_WRITE_BIT);
float ww = w;
float hh = h;
b[0] = ww;
b[1] = 0;
b[2] = 0;
b[3] = ww;
b[4] = hh;
b[5] = 0;
b[6] = 0;
b[7] = 0;
b[8] = 0;
b[9] = 0;
b[10] = 0;
b[11] = 0;
b[12] = 0;
b[13] = hh;
b[14] = 0;
b[15] = ww;
b[16] = hh;
b[17] = 0;
glUnmapBuffer (GL_ARRAY_BUFFER);
}
```
Оказалось не так уж и сложно отражать объект. Также можно отразить по вертикали, например поменяв местами координаты текстуры.
По OpenAL писать нечего, я сделал музыку специально для 44100 частоты и 16 битного формата вроде. По OpenSLES я скачал спецификацию и почитал немного, понял что надо посмотреть примеры реализации и банально переписал код, чтобы заработало на android.
При портировании на android как оказалось, что там нет mqueue реализации. Я нашел только syscall от ядра linux. Но если был syscall для открытия mq\_open, то syscall для отправки не было и я подумал что надо искать другое решение. Так как я больше на C писал и на C++ опыта мало, то я конечно же не знал, что в C++ есть контейнер queue. И это было спасением, я сделал её глобальной рядом с функцией main и sdl потоке отправлял в нее event. А в game () файле я пробросил queue с помощью extern и получал события. И вуаля, всё работает.
Так как архитектуры различны, то я просто в ресурс добавил число 1. Если при прочитывании этой переменной, она не равно единице, то делаем смену из littleEngian в bigEngian.
```
static int swap_little_big_engian (int num)
{
return (((num >> 24) & 0xff) | ((num << 8) & 0xff0000) | ((num >> 8) & 0xff00) | ((num << 24) & 0xff000000));
}
static uint8_t **diff_file_to_textures (Link *link, const char *filename)
{
int lb = 0;
SDL_RWops *io = SDL_RWFromFile (filename, "rb");
SDL_RWseek (io, 0, RW_SEEK_END);
long pos = SDL_RWtell (io);
SDL_RWseek (io, 0, RW_SEEK_SET);
uint8_t *file = new uint8_t[pos];
SDL_RWread (io, file, pos, 1);
SDL_RWclose (io);
const int LTBE = 0;
const int COUNT = 1;
const int WIDTH = 2;
const int HEIGHT = 3;
int *pack[4];
for (int i = 0; i < 4; i++) {
pack[i] = (int *) &file[i * 4];
}
if (*pack[LTBE] != 1) {
for (int i = 1; i < 4; i++) {
*pack[i] = swap_little_big_engian (*pack[i]);
}
}
link->size_tex = *pack[COUNT];
link->width = *pack[WIDTH];
link->height = *pack[HEIGHT];
...
```
Насчет шрифта freetype2. Я использовал старую сборку freetype, которая у меня на github, потому что новую так и не смог собрать для android.
Также, чтобы скомпилировать с OpenGLESv3, надо обратить внимание, что в ndk библиотеки с такой версией есть не ниже 18 api. Чтобы решить все проблемы с компиляцией, нужно в каталоге app в файле build.gradle сделать типа такого.
```
android {
compileSdkVersion 31
defaultConfig {
if (buildAsApplication) {
applicationId "com.xverizex.fly_bird_2"
}
minSdkVersion 18
targetSdkVersion 31
...
ndkBuild {
arguments "APP_PLATFORM=android-18"
abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
}
```
Важно в ndkBuild тоже указать платформу назначение и тогда компиляция сработает.
Ну и указать в app/jni/Application.mk версию api не забыть.
Учитывая прошлый опыт, я не стал на каждую игру заводить отдельный паблик, а сделал один основной и назвал - игры от xverizex.
<https://vk.com/xverizex_games>
Игра, которую я написал, можно найти по кодовому названию в google play.
com.xverizex.fly\_bird\_2
Правда я всё ещё жду пока одобрят первую версию и пока она не доступна в маркете. Я хочу сделать её бесплатной в google play, а в huawei маркете, если это вообще возможно, то выставить цену на игру. Хотелось бы ещё зарабатывать на том что нравиться.
Игра по своей сути получилась относительно простой и поэтому её возможно было сделать за 5 дней. Да, на unity можно было бы за дня два или один сделать, но мне нравиться C и C++, разумеется я буду писать на том что мне нравиться.
Это были мои все заметки, которые я запомнил за прошедшие пять дней разработки. Я писал по 12 или более часов почти каждый день и не мог уснуть, потому что было интересно. Но теперь нужно отдохнуть перед следующим заходом. Возможно новый уровень в этой игре или новая игра. | https://habr.com/ru/post/662559/ | null | ru | null |
# Простая космическая симуляция с помощью Python и Box2D
Привет, Хабр.
На данную статью меня вдохновила недавняя публикация [Моделируем Вселенную](https://habr.com/ru/post/494546/), где автор показал весьма интересное моделирование разных космических явлений. Однако представленный там код непрост для начинающих. Я покажу как сделать физическое моделирование с помощью движка [Box2D](https://box2d.org/about/), написав всего лишь несколько строк кода.
Рискну ошибиться, но это первое описание Box2D для Python на Хабре, восполним этот пробел.
Для тех кому интересно как это работает, подробности под катом.
Box2D это бесплатная кроссплатформенная библиотека, созданная сотрудником Blizzard Erin Catto. Библиотека была представлена в 2007 году, и на сегодняшний день портирована на практически все платформы. Есть порт и для Python, его описание достаточно запутанное, но надеюсь, с помощью этой статьи все станет понятнее.
Введение
--------
Библиотека [pybox2d](https://github.com/pybox2d/pybox2d) состоит из двух компонентов — собственно Box2D, кроссплатформенной библиотеки для физического моделирования, и отдельного модуля отрисовки, называемого Framework. Отрисовка нужна, если мы хотим видеть создаваемые объекты на экране, что достаточно удобно для нашей симуляции. Класс Framework может использовать различные способы вывода (подробнее [здесь](https://github.com/pybox2d/pybox2d/tree/master/library/Box2D/examples/backends)), мы будем использовать pygame. Если библиотека pygame установлена, она «подхватывается» автоматически, и ничего больше делать не нужно. Для установки достаточно ввести команду **pip install Box2D pygame**.
Минимально работающая программа, использующая Box2D, показана ниже. Код является кроссплатформенным, и будет работать везде, и в Linux и в Windows.
```
from Box2D.examples.framework import Framework
from Box2D import *
class Simulation(Framework):
def __init__(self):
super(Simulation, self).__init__()
# Ground body
self.world.CreateBody(shapes=b2LoopShape(vertices=[(20, 0), (20, 40), (-20, 40), (-20, 0)]))
# Dynamic body
circle = b2FixtureDef(shape=b2CircleShape(radius=2), density=1, friction=1.0, restitution=0.5)
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0,30), fixtures=circle, linearVelocity=(5, 0))
def Step(self, settings):
super(Simulation, self).Step(settings)
if __name__ == "__main__":
Simulation().run()
```
Как можно видеть, мы создаем класс Simulation, наследуемый от уже упомянутого Framework. Далее мы создаем два объекта с помощью вызова метода **CreateBody**. Первый это статический объект, задающий границы нашего мира. Второй объект имеет тип b2\_dynamicBody, остальные параметры (форма, размер, плотность, коэффициент трения, начальная скорость) очевидны из кода. Функция **Step** вызывается каждый раз во время симуляции, мы воспользуемся этим в дальнейшем. Если UI не нужен, например мы делаем backend для сервера, то разумеется, класс Framework можно не использовать, но для нас это вполне удобно.
Собственно и все, запускаем программу и видим готовую симуляцию:
Как можно видеть, мы просто создали два объекта и указали их параметры. Все работает «из коробки» — сила тяжести, трение, упругость, взаимодействие тел и пр. На основе этого мы можем приступать к нашей «космической» симуляции.
Запускаем «спутник»
-------------------
К сожалению, встроенной поддержки Ньютоновской гравитации в Box2D нет, её придется добавить самостоятельно, дописав функцию Step. Для первого теста создадим два тела — планету, и вращающийся вокруг неё спутник.
Исходный код целиком:
```
from Box2D import *
from Box2D.examples.framework import Framework
class Simulation(Framework):
def __init__(self):
super(Simulation, self).__init__()
# Default gravity disable
self.world.gravity = (0.0, 0.0)
# Gravity constant
self.G = 100
# Planet
circle = b2FixtureDef(shape=b2CircleShape(radius=5), density=1, friction=0.5, restitution=0.5)
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0,0), fixtures=circle)
# Satellite
circle_small = b2FixtureDef(shape=b2CircleShape(radius=0.2), density=1, friction=0.5, restitution=0.2)
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0, 10), fixtures=circle_small, linearVelocity=(20, 0))
def Step(self, settings):
super(Simulation, self).Step(settings)
# Simulate the Newton's gravity
for bi in self.world.bodies:
for bk in self.world.bodies:
if bi == bk:
continue
pi, pk = bi.worldCenter, bk.worldCenter
mi, mk = bi.mass, bk.mass
delta = pk - pi
r = delta.length
if abs(r) < 1.0:
r = 1.0
force = self.G * mi * mk / (r * r)
delta.Normalize()
bi.ApplyForce(force * delta, pi, True)
if __name__ == "__main__":
Simulation().run()
```
Как можно видеть, мы «отключаем» стандартную гравитацию, установив параметр self.world.gravity в 0. Также мы добавляем параметр G, это «гравитационная постоянная» нашего виртуального мира, которая используется при расчете в методе Step. Также мы создали два объекта — спутник и планету. Здесь важно отметить параметры density (плотность) и radius. По этим параметрам библиотека Box2D сама рассчитывает массу, которая используется в расчете. Для вычисления силы взаимодействия используется обычная «школьная» формула [закона тяготения Ньютона](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%82%D1%8F%D0%B3%D0%BE%D1%82%D0%B5%D0%BD%D0%B8%D1%8F_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0):
Теперь запускаем симуляцию. Первой космической скорости мы не достигли, и хотя спутник все-таки обогнул всю планету, «полетом» это назвать сложно:
Увеличиваем скорость, изменив строчку кода на linearVelocity=(28, 0):
Наш «спутник» успешно вышел на орбиту вокруг «планеты»! Если еще увеличить скорость, орбита станет эллиптической:
Наконец, изобразим нечто, более похожее на нашу «солнечную систему», добавив три планеты разных размеров на разных орбитах:
```
circle_small = b2FixtureDef(shape=b2CircleShape(radius=0.2), density=1, friction=0.5, restitution=0.2)
circle_medium = b2FixtureDef(shape=b2CircleShape(radius=0.3), density=1, friction=1.0, restitution=0.5)
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0, 6), fixtures=circle_small, linearVelocity=(37, 0))
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0, 10), fixtures=circle_small, linearVelocity=(28, 0))
self.world.CreateBody(type=b2_dynamicBody, position=b2Vec2(0, 15), fixtures=circle_medium, linearVelocity=(22, 0))
```
Результат:
Мы видим, что чем дальше планета от «солнца», тем больше её период обращения (3й закон Кеплера). К сожалению, движок Box2D не позволяет рисовать на экране треки движения, так что 1й и 2й законы Кепплера «увидеть» сложно, но можно быть уверенными, что они также выполняются.
Заключение
----------
Как можно видеть, с помощью Box2D несложные симуляции можно делать с минимальными усилиями. Разумеется, движок этот все же игровой, а не научный, так что не стоит ожидать от него корректной симуляции столкновения галактик или разлета вещества при Большом взрыве. Но некоторые закономерности посмотреть вполне любопытно.
Все задуманное в одну часть не влезло. Если оценки будут положительны, во второй части можно будет рассмотреть более нетривиальные примеры. | https://habr.com/ru/post/500568/ | null | ru | null |
# Особенности тестирования Android без Google-сервисов
Привет! Меня зовут Мария Лещинская, я QA-специалист [в Surf](https://surf.ru/). Наша компания разрабатывает мобильные приложения с 2011 года. В этом материале поговорим о тестировании устройств Android, на которых нет поддержки Google Services.
Huawei без Google-сервисов начали массово выпускаться в 2019 году. Мы в Surf, разумеется, задумались о будущем: как сильно пострадают наши процессы и что нужно незамедлительно осваивать.
Я поделюсь впечатлениями от работы с Android без Google-сервисов и расскажу, какие возможности имеют такие мобильные устройства при тестировании.
> В начале статьи — общая информация про AppGallery и AppGallery Connect. Если вы всё это уже знаете, переходите сразу к сути — [к особенностям тестирования Android-платформы c поддержкой Huawei без Google-сервисов](#capabilities).
>
>
Что такое AppGallery, AppGallery Connect и почему Huawei — без поддержки Google
-------------------------------------------------------------------------------
Приложения под iOS- и Android-платформы можно встретить в официальных магазинах AppStore и Google Play. Туда мы идём в первую очередь, когда хотим установить новое мобильное приложение на телефон.
С 2018 года во всем мире (а в Китае — ещё раньше) появился другой магазин мобильных приложений — AppGallery, а с ним и AppGallery Connect.
AppGallery — это менеджер пакетов и платформа распространения приложений, разработанная Huawei для операционной системы Android. AppGallery Connect — универсальная платформа для поддержки всего жизненного цикла приложения: разработки, распространения, управления, тестирования и анализа.
За AppGallery последовал и выпуск устройств на базе Huawei: с 2019 года для них в принципе отсутствует возможность работать с Google-сервисами, поэтому работа с Android стала сложнее. Нужно было оперативно включиться в работу и придумать, как изменить процессы тестирования платформы.
Казалось бы, зачем менять процессы и подстраиваться под ещё один магазин? Как много багов может добавиться к уже существующим? Стоит ли тратить время и деньги? У нас есть два аргумента.
Во-первых, при разработке приложения автор ориентируется не только на качество ПО, но и на качество продукта. Если продукт доступен бОльшей части потенциальных клиентов, это говорит об ответственном подходе к приложению. Нам кажется, что работать с AppGallery можно и нужно, ведь пользователь — важное звено в разработке ПО.
Во-вторых, у AppGallery солидное количество пользователей. Магазин появился в 2018 году, к октябрю 2020 года приложение доступно в 170 странах мира, число уникальных пользователей – 700 миллионов человек. Как говорит статистика, ежемесячная аудитория составляет 490 миллионов активных пользователей.
При этом для Huawei написали всего 96 000 приложений. Для сравнения — в Play Store 2.9 миллиона приложений: это значит что более двух с половиной миллионов приложений отсутствуют в AppGallery.
В AppGallery нет, например, Instagram, Facebook и WhatsАpp. Их, конечно, можно скачать и установить вручную без ограничений: найти по отдельности в браузере или через какой-нибудь агрегатор. Также в сети появились сервисы, с помощью которых можно скачать самые популярные приложения. Но не каждый пользователь захочет выполнять дополнительные манипуляции.
Три вида Android-устройств
--------------------------
Как только к Android с Google-сервисами прибавились Huawei с сервисами HMS, некоторые устройства стали автоматически поддерживать оба вида сервисов (например, как Huawei до 2020 года выпуска).
Ниже представлено сравнение трёх типов устройств Android: с Google-cервисами, без них и с поддержкой обоих.
| | | | |
| --- | --- | --- | --- |
| | Android без Google-сервисов | Android только с Google-сервисами | Android с поддержкой Google-сервисов и App Gallery |
| .apk/.aab | Установочный файл может быть один — на все виды устройств Android, или их может быть два: отдельно с сервисами Huawei и отдельно с сервисами Google.Мы в Surf обычно делаем один .apk/.aab для обоих видов устройств Android. Логика работы приложений на разных устройствах определена внутри сборки. Но также могут быть два установочных файла одного приложения: один идёт в Google play, другой — в AppGallery.На мой взгляд, удобнее использовать именно один установочный файл для тестирования и релиза в различные магазины.Проще и быстрее сделать одну сборку, чем две, но как только подключается CI, разница минимизируется. Использование двух сборок теоретически может уменьшить вес приложения — особенно если в нем используются разные фреймворки для реализации фич на Android с Google Services и без. |
| инструменты | AppGallery Connect и сервисы, не использующие Google. | Сервисы, использующие google, — в том числе Firebase. | AppGallery Connect, сервисы, не использующие Google, и сервисы, использующие Google — в том числе Firebase.Какие инструменты выбрать, стоит продумать до начала разработки: проанализировать особенности проекта и устройств, потенциальную аудиторию, сервисы, необходимые для реализации фич. |
| При работе с Huawei без Google-сервисов всегда нужно помнить про отсутствие возможности работы с Google-сервисами. Как бы тавтологично это не звучало, бывают моменты, когда уже готовые решения, которые можно использовать в разработке определённого проекта, опираются на сервисы Google. Какие-то сразу об этом сообщают — тогда проблем нет. Какие-то используют их глубоко в фреймворке, и тогда приходится немного «покопаться» в реализации. Если такая библиотека случайно попадёт в приложение, используемое на Huawei без поддержки Google, могут возникнуть проблемы. Именно поэтому важно тестировать отдельно и на таких устройствах тоже. |
| баги | Баги по общей логике приложения, конечно, будут распространяться на оба вида устройств. Существенные отличия могут появиться при работе сервисов типа Google Pay, push-уведомлений, deep links и dynamic links и так далее. |
Устройства разные, особенности взаимодействия и тестирования — тем более. Казалось бы, все понятно: нужно знать, как с ними работать — и никаких проблем. Но ещё очень важно понимать, из чего составить этот рабочий процесс: как выбрать инструменты, чему обучить команду и к каким проблемам подойти с правильной стороны.
Возможности тестирования через AppGallery Connect
-------------------------------------------------
Проблемы начинаются при использовании разных библиотек на двух видах устройств Android. Мы в Surf пользуемся различными сервисами для работы с push-уведомлениями, аналитикой, dynamic или deep links, performance-мониторингом. Поэтому когда стали брать на вооружение работу с Huawei без Google-сервисов, волновались, насколько сильно изменится работа QA: получится ли тестировать push-уведомления и dynamic links в привычном ритме или придётся адаптироваться к абсолютно новому процессу? К счастью, сам процесс меняется несильно. Но есть вещи, о которых необходимо знать, прежде чем браться за работу с устройствами без поддержки Google.
Huawei без Google-сервисов не имеет доступа к инструментам, которые работают с Google, — например, Firebase. Сервисы для тестирования и работы мобильного приложения нужно настраивать через AppGallery (к счастью, AppGallery Connect имеет базовые возможности из коробки) или другие доступные инструменты. А возможно, придумывать и свои решения.
Ниже приведены базовые инструменты AppGallery Connect, позволяющие без особого труда наладить основные процессы по работе с пуш-уведомлениями, аналитикой, удалённой настройкой и прочими инструментами для удобства тестирования и поддержки.
### Аналитика
При тестировании аналитики полезно просматривать события в реальном времени — это помогает обеспечить качество реализации отправки событий в мобильном приложении. Проверять аналитику в AppGallery Connect в реальном времени можно, например, с помощью «Отладки приложения» (аналогично DebugView в Firebase).
«Отладка приложения» ([App Debugging](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/app-debugging-0000001051799712)) позволяет смотреть события, приходящие от МП, и их параметры в реальном времени.Чтобы подключить устройство к Отладке приложения в AppGallery Connect, нужно подключить устройство к компьютеру и в терминале выполнить команду:
```
adb shell setprop debug.huawei.hms.analytics.app
```
Чтобы отключить устройство от отладки, выполнить команду:
```
adb shell setprop debug.huawei.hms.analytics.app .none.
```
Чтобы быстрее найти , можно воспользоваться командой [adb](https://developer.android.com/studio/command-line/adb):
```
adb shell pm list packages
```
Общий сбор аналитики в AppGallery Connect тоже доступен. Он называется «Просмотр в реальном времени» (аналогично Events в Firebase)
«Просмотр в реальном времени» ([Real-Time Overview](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/real-time-dashboard-0000001078364350)) собирает все события с МП в одном месте. Можно строить графики по выбранным критериям, активировать фильтры и в целом проводить анализ по мобильному приложению.
### Удалённая настройка и параметры
«Удалённая настройка» ([Remote Configuration](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-Guides/agc-remoteconfig-introduction-0000001055149778)) позволяет управлять различными параметрами для приложения, и при необходимости обращаться к AppGallery Connect прямо из МП для работы с ними (аналогично RemoteConfig в Firebase).
### Push-уведомления
При работе с push-уведомлениями Surf использует разные инструменты: Flocktory, Mindbox, Firebase и другие. Не все инструменты пока ещё могут работать с Android без поддержки Google, но базовая возможность подключить push-уведомления для Huawei есть: это их фирменная реализация через AppGallery Connect. Настройка пyшей происходит в [PushKit](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/service-introduction-0000001050040060).
Важно отметить, что пушер бэкэнда обязательно должен уметь взаимодействовать с AppGallery PushKit. Иначе push-уведомления придётся отправлять вручную из AppGallery Connect.
### App Linking
[App Linking](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-Guides/agc-applinking-introduction-0000001054143215) — сервис для работы с dynamic links. На основании deep links App Linking предоставляет пользователям доступ к нужному контенту непосредственно на веб-страницах и в мобильных приложениях: это повышает конверсию пользователей (аналогично Dynamic Links в Firebase).
Dynamic Links vs Deep LinksDynamic links — это интеллектуальные URL-адреса, которые позволяют отправлять существующих и потенциальных пользователей в любое место в приложении iOS или Android. Dynamic links легко переводят пользователей с любого URL на контент в приложении. Если пользователь не установил приложение на устройство, он увидит контент, когда установит его.
Deep Links — это тип локальных ссылок: они направляют пользователей непосредственно в приложение — и только. Соответственно, если приложение не установлено, работа с deep links невозможна.
Простыми словами, dynamic links — ссылки, которые могут редиректить пользователя откуда угодно прямо в приложение или магазин, если оно не установлено (а после установки — и в приложение). Deep links — ссылки, которые привязаны к конкретному экрану внутри приложения и работают локально внутри МП.
На данный момент при работе с AppGallery Connect нет возможности создавать кастомные dynamic links: например, которые были бы одинаковыми и для обоих видов устройств Android (с поддержкой Google и без). Но c deep links всё в порядке.
### Crash
Чтобы ловить незаметные с первого взгляда баги, стоит мониторить crash-аналитику даже на debug-версиях. Это необходимо, когда приложение потенциально разрабатывается на большую аудиторию и релиз близко — не говоря уже о ситуации, когда МП уже доступно магазине и им пользуется много людей.
Нам было важно, чтобы такой инструмент был доступен и для Huawei без Google-сервисов. [Crash](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-Guides/agc-crash-introduction-0000001055732708) — плагин, позволяющий отслеживать и анализировать баги, краши и ошибки в приложении (аналогично Crashlytics в Firebase).
### APM
Чтобы обеспечить качество клиент-серверного взаимодействия, удобно использовать инструмент, который бы помогал анализировать ответы от сервера и отрисовку экранов и элементов в приложении. В AppGallery Connect такой инструмент — [APM](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-Guides/agc-apm-introduction-0000001052247254). Это сервис, который помогает искать и устранять проблемы производительности приложения и улучшать таким образом пользовательский интерфейс (аналогично Performance в Firebase).
Конечно, это не все необходимые сервисы, которые можно встретить в мобильных приложениях, но они — базовые. Всегда приятно понимать, что не приходишь на «пустое поле»: есть с чем работать и можно сделать приложение лучше и доступнее для всех пользователей.
Особенности тестирования Android-платформы c поддержкой Huawei без Google-сервисов
----------------------------------------------------------------------------------
В первое время при работе с устройствами Huawei без Google-сервисов мы тратили много времени на анализ и выстраивание процессов. Сейчас всё наладилось.
В целом можно выделить следующие проблемы и решения.
### Шаринг сборок
На проектах мы часто шарим сборки через Firebase, или напрямую скачиваем .apk из Jenkins, или собираем вручную из Android Studio. Проблем со скачиванием или ручной установкой .apk для Huawei без Google-сервисов нет. Проблем с App Tester — приложением Firebase для шаринга сборок — тоже нет. Использовать непосредственно приложение не получится, но пройти по invite из почты в браузер для скачивания сборки удастся.
> Лайфхак: сохраняйте страницу из браузера на рабочий стол телефона и не знайте горя.
>
>
### Устройства
Конечно, для тестирования необходимы устройства без Google-сервисов.
* Если на проекте планируется адаптация под AppGallery, можно отправить заявку Huawei. Они пришлют девайсы для тестирования. Правда, финальное слово всегда за самим Huawei: отправка запроса ничего не гарантирует. Но опция приятная.
* Неплохой вариант — использовать ферму устройств. Конечно, это не восполнит полную работу с реальным устройством, но может помочь в отдельных случаях.
+ Можно работать через [ферму устройств App Gallery](https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-Guides/agc-clouddebug-realtimedebug).
+ Можно установить [HMS Toolkit](https://developer.huawei.com/consumer/en/huawei-toolkit/) в Android Studio и работать с Huawei без Google-сервисов прямо из IDE.
### На что обратить внимание
Стоит отметить важные моменты, которые впоследствии помогут избежать проблем или продумать пути их решения заранее.
1. **Push-уведомления**. На Huawei без Google-сервисов не будут работать push-уведомления, реализованные на backend через Firebase (а такое встречается сейчас часто). Такие устройства имеют свой hms-токен, и для работы с ними нужна специальная реализация.
2. **Dynamic links**. Инструмент AppGallery Connect не поддерживает кастомный формат dynamic links, поэтому нельзя настроить унифицированную ссылку на оба вида конфигураций устройств Android. Решение: использовать deep links или другой инструмент по работе с ссылками, работающий без Google Services.
3. **Библиотеки с Google-сервисами.** Различия в реализации и потенциальное скопление багов в логике будут, если в проекте используются библиотеки с Google-сервисами. Для Huawei их придётся заменить на другие фреймворки или if-ответвления. Тогда понадобится более тщательно тестировать оба вида устройств.
* **Google Pay**. На Android без Google-сервисов можно столкнуться с окном «Оплата недоступна, так как для нее нужен доступ к Google-сервисам, которые ваше устройство не поддерживает». Аналогичную ошибку можно встретить при запуске других приложений, не предназначенных для Huawei без Google.
* **Google-карты**. Работа с Google-картами может содержать проблемы с кластеризацией, поиском, отрисовкой текущего местоположения и так далее.
* **Google-аккаунт.** Авторизация через Google-аккаунт на Huawei без поддержки Google недоступна. Но реализация авторизации-регистрации через Huawei-аккаунт была бы кстати.
* **Магазины.** Если мобильное приложение может отправить пользователя в магазин (для оценки, например), то необходимо проверить, что Android без Google Services отправляет в App Gallery, а Android с поддержкой Google — в Google Play. Если устройство поддерживает обе конфигурации, было бы здорово, если бы пользователь мог выбрать между магазинами.
4. **Сервисы с поддержкой Google.** Для Huawei без Google придётся найти аналоги или разработать их самостоятельно. Хорошо, что важные базовые инструменты, как упоминалось выше, доступны в AppGallery Connect из коробки.
Например, на Android-устройствах можно открывать ссылки из приложения тремя разными способами:
* WebView,
* CustomTabs (разработка Google),
* браузер.
Для Huawei без поддержки Google, по умолчанию доступны только два способа или дополнительная разработка вручную.
Android с Google и без: сколько времени понадобится на тестирование
-------------------------------------------------------------------
Базовые активности QA:
* планирование,
* ревью ТЗ и дизайна,
* написание проверок,
* прогоны по фиче, итоговые, регрессионные,
* написание отчётности
> *Это пример активностей QA «в среднем по больнице». Мы исключаем особенности компании и проектов и говорим немного в вакууме.*
>
>
При работе с Huawei без Google-сервисов точно добавляется время к каждой из активностей:
* **Ревью ТЗ и дизайна, написание проверок**. Будут дополнительные кейсы, отражающие особенности работы с такими устройствами. Можно смело увеличивать оценку временных затрат на это в 1,4–1,6 раза. Здесь время уйдёт либо на обработку дополнительных сценариев в ТЗ и дизайне, либо на анализ и подтверждение, что никакой особенной реализации для Android без Google-сервисов нет.
* **Прогоны**. Во время прогонов (по фиче, итоговых, регрессионных) рекомендуется проводить тестирования как на Android с Google-сервисами, так и без. Особое внимание — устройствам, где доступны оба вида сервисов. Здесь сокращение количества устройств может когда-нибудь неприятно «выстрелить». Время может увеличиться в 1,8–2 раза и уйдёт на осуществление прогона на всех трёх видах устройств.
* **Обратная связь.** Под «обратной связью» мы в Surf подразумеваем просмотр маленьких задач (которые не требует прогона по фиче — например, «Смену статичного текста») и исправленных багов. При работе с обратной связью, а также при анализе и просмотре импакта от багов и прочих задач, снова не стоит забывать про тот же список устройств (без и с Google-сервисами, а также с двумя видами сервисов) для тестирования. Время увеличивается примерно в 1,3 раза снова для того, чтобы осуществить ретест или проверку задачи на этих видах устройств.
* **Послерелизные активности.** При релизе приложения в AppGallery необходимо продолжать мониторить работу МП как минимум по crash-сервису, чтобы поддерживать качество и исправлять ошибки вовремя. Если в проекте не используется один инструмент мониторинга обоих видов устройств, то времени на работу с двумя инструментами и анализом багов будет уходить больше. Пожалуй, тут лучше увеличить время в 2 раза.
* **Тестируемые устройства.** И, конечно, на время может повлиять количество выбранных устройств для тестирования (автоматизированного или ручного). Подходить к выбору устройств стоит ответственно, проанализировав множественные факторы проекта и аудитории.
При тестировании на Android с Google Services хочется покрыть наибольшее количество устройств: разные операционные системы, оболочки, разрешения экранов, внутренние особенности и возможности. Устройств становится ещё больше, когда добавляются девайсы Huawei с HMS-сервисами.
Таким образом, необходимо покрыть бОльшее количество устройств: не забывая про Android с Google-сервисами, Android без их поддержки, и Android с поддержкой HMS-сервисов помимо Google.
> *На процесс и время могут повлиять особенности работы конкретной компании. Если у вас есть дополнительные задачи, активности, роли, рекомендуем провести предварительный анализ, чтобы не столкнуться с неожиданностями «в бою».*
>
>
Время общего тестирования фичи увеличится:
* в 1,8–2 раза в случае разных инструментов для реализации фичи;
* в 1,3–1,5 раза в случае одного инструмента для реализации фичи (в том числе при отсутствии отличий на первый взгляд);
* в 1,4–1,6 раза в случае дополнительных требований и отличительной части реализации.
#### Таблица-сравнение по тестированию фичи для устройств с Google и без
Мы оценили фичи по пунктам, о которых говорили выше ревью, написание проверок, прогоны по фиче, обратная связь.
| | | |
| --- | --- | --- |
| **Фича** | **Поддержка Android только с сервисами Google** | **Поддержка Android с Huawei и Google Services** |
| Авторизация по логину и паролю, а также через соц.сети | X | 1,5X |
| Push-уведомления (реализация через Firebase и AppGallery Connect) | X | 1,8X |
| Аналитика, около 15 событий (реализация через Firebase и AppGallery Connect) | X | 2X |
| Аналитика, около 15 событий (реализация через один сервис, например, Amplitude) | X | 1,4X |
*Значение Х — время на тестирование Android с Google-сервисами. Оценка Y\*X — время на тестирование Android с двумя видами сервисов, где Y — коэффициент увеличения времени на работу с Huawei с HMS-сервисами*
> *Все временные оценки — исходя из нашего опыта. Приводим их для примерного понимания.*
>
>
Что хотелось бы сказать в конце...
----------------------------------
Мы в Surf поддерживаем устройства Huawei без Google-сервисов на некоторых проектах и довольны процессами. Конечно, поработать головой иногда приходится чуть дольше: разработчикам — чтобы найти универсальное решение. QA — чтобы найти максимальное количество дефектов, широко покрыть фичи проверками и обеспечить качественное тестирование. И на мой взгляд, оно того стоит. | https://habr.com/ru/post/559106/ | null | ru | null |
# Создаём простую нейросеть
*Перевод [Making a Simple Neural Network](https://becominghuman.ai/making-a-simple-neural-network-2ea1de81ec20)*
Что мы будем делать? Мы попробуем создать простую и совсем маленькую нейронную сеть, которую мы **объясним** и **научим** что-нибудь различать. При этом не будем вдаваться в историю и математические дебри (такую информацию найти очень легко) — вместо этого постараемся объяснить задачу (не факт, что удастся) вам и самим себе рисунками и кодом.
Многие из терминов в нейронных сетях связаны с биологией, поэтому давайте начнем с самого начала:
Мозг — штука сложная, но и его можно разделить на несколько основных частей и операций:
Возбудитель может быть и **внутренним** (например, образ или идея):
А теперь взглянем на основные и упрощенные **части** мозга:
*Мозг вообще похож на кабельную сеть.*
**Нейрон** — основная единица исчислений в мозге, он получает и обрабатывает химические сигналы других нейронов, и, в зависимости от ряда факторов, либо не делает ничего, либо генерирует электрический импульс, или Потенциал Действия, который затем через синапсы подает сигналы соседним **связанным** нейронам:
Сны, воспоминания, саморегулируемые движения, рефлексы да и вообще все, что вы думаете или делаете — все происходит благодаря этому процессу: миллионы, или даже миллиарды нейронов работают на разных уровнях и создают связи, которые создают различные параллельные подсистемы и представляют собой биологическую нейронную **сеть**.
Разумеется, это всё упрощения и обобщения, но благодаря им мы можем описать простую
нейронную сеть:
И описать её формализовано с помощью графа:
Тут требуются некоторые пояснения. Кружки — это нейроны, а линии — это связи между ними,
и, чтобы не усложнять на этом этапе, **взаимосвязи** представляют собой прямое передвижение информации **слева направо**. Первый нейрон в данный момент активен и выделен серым. Также мы присвоили ему число (1 — если он работает, 0 — если нет). Числа между нейронами показывают **вес** связи.
Графы выше показывают момент времени сети, для более точного отображения, нужно разделить его на временные отрезки:
Для создания своей нейронной сети нужно понимать, как веса влияют на нейроны и как нейроны обучаются. В качестве примера возьмем кролика (тестового кролика) и поставим его в условия классического эксперимента.
Когда на них направляют безопасную струю воздуха, кролики, как и люди, моргают:
Эту модель поведения можно нарисовать графами:
Как и в предыдущей схеме, эти графы показывают только тот момент, когда кролик чувствует дуновение, и мы таким образом **кодируем** дуновение как логическое значение. Помимо этого мы вычисляем, срабатывает ли второй нейрон, основываясь на значении веса. Если он равен 1, то сенсорный нейрон срабатывает, мы моргаем; если вес меньше 1, мы не моргаем: у второго нейрона **предел** — 1.
Введем еще один элемент — безопасный звуковой сигнал:
Мы можем смоделировать заинтересованность кролика так:
Основное отличие в том, что сейчас вес равен **нулю**, поэтому моргающего кролика мы не получили, ну, пока, по крайней мере. Теперь научим кролика моргать по команде, смешивая
раздражители (звуковой сигнал и дуновение):
Важно, что эти события происходят в разные временные **эпохи**, в графах это будет выглядеть так:
Сам по себе звук ничего не делает, но воздушный поток по-прежнему заставляет кролика моргать, и мы показываем это через веса, умноженные на раздражители (красным).
**Обучение** сложному поведению можно упрощённо выразить как постепенное изменение веса между связанными нейронами с течением времени.
Чтобы обучить кролика, повторим действия:
Для первых трех попыток схемы будут выглядеть так:
Обратите внимание, что вес для звукового раздражителя растет после каждого повтора (выделено красным), это значение сейчас произвольное — мы выбрали 0.30, но число может быть каким угодно, даже отрицательным. После третьего повтора вы не заметите изменения в поведении кролика, но после четвертого повтора произойдет нечто удивительное — поведение изменится.
Мы убрали воздействие воздухом, но кролик все еще моргает, услышав звуковой сигнал! Объяснить это поведение может наша последняя схемка:
Мы обучили кролика реагировать на звук морганием.
*В условиях реального эксперимента такого рода может потребоваться более 60 повторений для достижения результата.*
Теперь мы оставим биологический мир мозга и кроликов и попробуем адаптировать всё, что
узнали, для создания искусственной нейросети. Для начала попробуем сделать простую задачу.
Допустим, у нас есть машина с четырьмя кнопками, которая выдает еду при нажатии правильной
кнопки (ну, или энергию, если вы робот). Задача — узнать, какая кнопка выдает вознаграждение:
Мы можем изобразить (схематично), что делает кнопка при нажатии следующим образом:
Такую задачу лучше решать целиком, поэтому давайте посмотрим на все возможные результаты, включая правильный:
*Нажмите на 3-ю кнопку, чтобы получить свой ужин.*
Чтобы воспроизвести нейронную сеть в коде, нам для начала нужно сделать модель или график, с которым можно сопоставить сеть. Вот один подходящий под задачу график, к тому же он хорошо отображает свой биологический аналог:
Эта нейронная сеть просто получает входящую информацию — в данном случае это будет восприятие того, какую кнопку нажали. Далее сеть заменяет входящую информацию на веса и делает вывод на основе добавления слоя. Звучит немного запутанно, но давайте посмотрим, как в нашей модели представлена кнопка:
*Обратите внимание, что все веса равны 0, поэтому нейронная сеть, как младенец, совершенно пуста, но полностью взаимосвязана.*
Таким образом мы сопоставляем внешнее событие с входным слоем нейронной сети и вычисляем значение на ее выходе. Оно может совпадать или не совпадать с реальностью, но это мы пока проигнорируем и начнем описывать задачу понятным компьютеру способом. Начнем с ввода весов (будем использовать JavaScript):
```
var inputs = [0,1,0,0];
var weights = [0,0,0,0];
// Для удобства эти векторы можно назвать
```
Следующий шаг — создание функции, которая собирает входные значения и веса и рассчитывает значение на выходе:
```
function evaluateNeuralNetwork(inputVector, weightVector){
var result = 0;
inputVector.forEach(function(inputValue, weightIndex) {
layerValue = inputValue*weightVector[weightIndex];
result += layerValue;
});
return (result.toFixed(2));
}
// Может казаться комплексной, но все, что она делает — это сопоставляет пары вес/ввод и добавляет результат
```
Как и ожидалось, если мы запустим этот код, то получим такой же результат, как в нашей модели или графике…
```
evaluateNeuralNetwork(inputs, weights); // 0.00
```
Живой пример: [Neural Net 001](http://codepen.io/k3no/pen/GWyJgP).
Следующим шагом в усовершенствовании нашей нейросети будет способ проверки её собственных выходных или результирующих значений сопоставимо реальной ситуации,
давайте сначала закодируем эту конкретную реальность в переменную:
Чтобы обнаружить несоответствия (и сколько их), мы добавим функцию ошибки:
```
Error = Reality - Neural Net Output
```
С ней мы можем оценивать работу нашей нейронной сети:
Но что более важно — как насчет ситуаций, когда реальность дает положительный результат?
Теперь мы знаем, что наша модель нейронной сети не работает (и знаем, насколько), здорово! А здорово это потому, что теперь мы можем использовать функцию ошибки для управления нашим обучением. Но всё это обретет смысл в том случае, если мы переопределим функцию ошибок следующим образом:
```
Error = **Desired Output** - Neural Net Output
```
Неуловимое, но такое важное расхождение, молчаливо показывающее, что мы будем
использовать ранее полученные результаты для сопоставления с будущими действиями
(и для обучения, как мы потом увидим). Это существует и в реальной жизни, полной
повторяющихся паттернов, поэтому оно может стать эволюционной стратегией (ну, в
большинстве случаев).
Далее в наш пример кода мы добавим новую переменную:
```
var input = [0,0,1,0];
var weights = [0,0,0,0];
var desiredResult = 1;
```
И новую функцию:
```
function evaluateNeuralNetError(desired,actual) {
return (desired — actual);
}
// After evaluating both the Network and the Error we would get:
// "Neural Net output: 0.00 Error: 1"
```
Живой пример: [Neural Net 002](http://codepen.io/k3no/pen/dvaGpX).
**Подведем промежуточный итог**. Мы начали с задачи, сделали её простую модель в виде биологической нейронной сети и получили способ измерения её производительности по сравнению с реальностью или желаемым результатом. Теперь нам нужно найти способ исправления несоответствия — процесс, который как и для компьютеров, так и для людей можно рассматривать как обучение.
**Как обучать нейронную сеть?**
Основа обучения как биологической, так и искусственной нейронной сети — это повторение
и **алгоритмы обучения**, поэтому мы будем работать с ними по отдельности. Начнем с
обучающих алгоритмов.
В природе под алгоритмами обучения понимаются изменения физических или химических
характеристик нейронов после проведения экспериментов:
Драматическая иллюстрация того, как два нейрона меняются по прошествии времени в коде и нашей модели «алгоритм обучения» означает, что мы просто будем что-то менять в течение какого-то времени, чтобы облегчить свою жизнь. Поэтому давайте добавим переменную для обозначения степени облегчения жизни:
```
var learningRate = 0.20;
// Чем больше значение, тем быстрее будет процесс обучения :)
```
**И что это изменит?**
Это изменит веса (прям как у кролика!), особенно вес вывода, который мы хотим получить:
Как кодировать такой алгоритм — ваш выбор, я для простоты добавляю коэффициент обучения к весу, вот он в виде функции:
```
function learn(inputVector, weightVector) {
weightVector.forEach(function(weight, index, weights) {
if (inputVector[index] > 0) {
weights[index] = weight + learningRate;
}
});
}
```
При использовании эта обучающая функция просто добавит наш коэффициент обучения к вектору веса **активного нейрона**, до и после круга обучения (или повтора) результаты будут такими:
```
// Original weight vector: [0,0,0,0]
// Neural Net output: 0.00 Error: 1
learn(input, weights);
// New Weight vector: [0,0.20,0,0]
// Neural Net output: 0.20 Error: 0.8
// Если это не очевидно, вывод нейронной сети близок к 1 (выдача курицы) — то, чего мы и
хотели, поэтому можно сделать вывод, что мы движемся в правильном направлении
```
Живой пример: [Neural Net 003](http://codepen.io/k3no/pen/qrJoXO).
Окей, теперь, когда мы движемся в верном направлении, последней деталью этой головоломки будет внедрение **повторов**.
Это не так уж и сложно, в природе мы просто делаем одно и то же снова и снова, а в коде мы просто указываем количество повторов:
```
var trials = 6;
```
И внедрение в нашу обучающую нейросеть функции количества повторов будет выглядеть так:
```
function train(trials) {
for (i = 0; i < trials; i++) {
neuralNetResult = evaluateNeuralNetwork(input, weights);
learn(input, weights);
}
}
```
Ну и наш окончательный отчет:
```
Neural Net output: 0.00 Error: 1.00 Weight Vector: [0,0,0,0]
Neural Net output: 0.20 Error: 0.80 Weight Vector: [0,0,0.2,0]
Neural Net output: 0.40 Error: 0.60 Weight Vector: [0,0,0.4,0]
Neural Net output: 0.60 Error: 0.40 Weight Vector: [0,0,0.6,0]
Neural Net output: 0.80 Error: 0.20 Weight Vector: [0,0,0.8,0]
Neural Net output: 1.00 Error: 0.00 Weight Vector: [0,0,1,0]
// Chicken Dinner !
```
Живой пример: [Neural Net 004](http://codepen.io/k3no/pen/dvBZLe?editors=0012).
Теперь у нас есть вектор веса, который даст только один результат (курицу на ужин), если входной вектор соответствует реальности (нажатие на третью кнопку).
**Так что же такое классное мы только что сделали?**
В этом конкретном случае наша нейронная сеть (после обучения) может распознавать входные данные и говорить, что приведет к желаемому результату (нам всё равно нужно будет программировать конкретные ситуации):
Кроме того, это масштабируемая модель, игрушка и инструмент для нашего с вами обучения. Мы смогли узнать что-то новое о машинном обучении, нейронных сетях и искусственном интеллекте.
Предостережение пользователям:
* Механизм хранения изученных весов не предусмотрен, поэтому данная нейронная сеть забудет всё, что знает. При обновлении или повторном запуске кода нужно не менее шести успешных повторов, чтобы сеть полностью обучилась, если вы считаете, что человек или машина будут нажимать на кнопки в случайном порядке… Это займет какое-то время.
* Биологические сети для обучения важным вещам имеют скорость обучения 1, поэтому нужен будет только один успешный повтор.
* Существует алгоритм обучения, который очень напоминает биологические нейроны, у него броское название: **правило widroff-hoff**, или **обучение widroff-hoff**.
* Пороги нейронов (1 в нашем примере) и эффекты переобучения (при большом количестве повторов результат будет больше 1) не учитываются, но они очень важны в природе и отвечают за большие и сложные блоки поведенческих реакций. Как и отрицательные веса.
Заметки и список литературы для дальнейшего чтения
--------------------------------------------------
Я пытался избежать математики и строгих терминов, но если вам интересно, то мы построили [перцептрон](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD), который определяется как алгоритм контролируемого обучения ([обучение с учителем](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC)) [двойных классификаторов](https://en.wikipedia.org/wiki/Binary_classification) — тяжелая штука.
Биологическое строение мозга — тема не простая, отчасти из-за неточности, отчасти из-за его сложности. Лучше начинать с Neuroscience (Purves) и Cognitive Neuroscience (Gazzaniga). Я изменил и адаптировал пример с кроликом из Gateway to Memory (Gluck), которая также является прекрасным проводником в мир графов.
Еще один шикарный ресурс An Introduction to Neural Networks (Gurney), подойдет для всех ваших нужд, связанных с ИИ.
А теперь на Python! Спасибо Илье Андшмидту за предоставленную версию на Python:
```
inputs = [0, 1, 0, 0]
weights = [0, 0, 0, 0]
desired_result = 1
learning_rate = 0.2
trials = 6
def evaluate_neural_network(input_array, weight_array):
result = 0
for i in range(len(input_array)):
layer_value = input_array[i] * weight_array[i]
result += layer_value
print("evaluate_neural_network: " + str(result))
print("weights: " + str(weights))
return result
def evaluate_error(desired, actual):
error = desired - actual
print("evaluate_error: " + str(error))
return error
def learn(input_array, weight_array):
print("learning...")
for i in range(len(input_array)):
if input_array[i] > 0:
weight_array[i] += learning_rate
def train(trials):
for i in range(trials):
neural_net_result = evaluate_neural_network(inputs, weights)
learn(inputs, weights)
train(trials)
```
А теперь на GO! За эту версию благодарю Кирана Мэхера.
```
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println("Creating inputs and weights ...")
inputs := []float64{0.00, 0.00, 1.00, 0.00}
weights := []float64{0.00, 0.00, 0.00, 0.00}
desired := 1.00
learningRate := 0.20
trials := 6
train(trials, inputs, weights, desired, learningRate)
}
func train(trials int, inputs []float64, weights []float64, desired float64, learningRate float64) {
for i := 1; i < trials; i++ {
weights = learn(inputs, weights, learningRate)
output := evaluate(inputs, weights)
errorResult := evaluateError(desired, output)
fmt.Print("Output: ")
fmt.Print(math.Round(output*100) / 100)
fmt.Print("\nError: ")
fmt.Print(math.Round(errorResult*100) / 100)
fmt.Print("\n\n")
}
}
func learn(inputVector []float64, weightVector []float64, learningRate float64) []float64 {
for index, inputValue := range inputVector {
if inputValue > 0.00 {
weightVector[index] = weightVector[index] + learningRate
}
}
return weightVector
}
func evaluate(inputVector []float64, weightVector []float64) float64 {
result := 0.00
for index, inputValue := range inputVector {
layerValue := inputValue * weightVector[index]
result = result + layerValue
}
return result
}
func evaluateError(desired float64, actual float64) float64 {
return desired - actual
}
``` | https://habr.com/ru/post/423647/ | null | ru | null |
# Github actions и кросс-платформенное построение
Привет, Хабр. Это статья о том как настроить построение на всех платформах с помощью github actions.
Предыстория
-----------
Написал я простенькое приложение на electron, сам я пользовался linux-ом но мой друг предпочитал macos. Когда я попытался скомпилировать на своём компьютере для macos и передал моему другу pkg — Оно не запустилось. В итоге оказалось единственным вариантом скомпилировать приложение для macos это скомпилировать его на macos. Для максимального упрощения задачи я сделал три скрипта: build:linux, build:mac, build:win. В результате после компиляции получались файлы: linux.deb, linux.AppImage, mac.pkg, win.exe. Но оставалось одна проблема нужно было компилировать на разных системах. И тут спасение gihub actions.
Как всё должно будет работать
-----------------------------
Я нажимаю кнопку new release на github, а затем магия запускается workflow на github actions он компилирует на всех операционных системах и добавляя бинарники к релизу
Для добавления файлов к release я использовал <https://github.com/JasonEtco/upload-to-releas>, однако было одна загвоздка с этим действием. Это действие контейнерное, а в github actions контейнерные действия доступны только в linux. Поэтому было решено использовать четыре job-а, 3 для компиляции и 1 для загрузки. Так как для каждой job-ы окружение не сохраняется, по этому для обмена между ними используются артефакты
Практика
--------
Для начала в папке .github/workflows/workflow.yml с содержимым
```
name: CI
on: release
```
Ну я думаю понятно что это workflow CI и запускаться он по релизу, а теперь самое важное job
```
jobs:
build-linux:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v1
- name: Install bluetooth
run: sudo apt-get install -y build-essential libbluetooth-dev
- name: Install dependencies
run: npm install
- name: Build linux
run: npm run build:linux
- name: Creating out
run: |
mkdir out
cp dist/linux.AppImage out/
cp dist/linux.deb out/
- name: Upload build
uses: actions/upload-artifact@master
with:
name: linux
path: out
```
По шагам jobs: это все работы, build-linux: это работа с названием build-linux, runs-on: ubuntu-latest говорит что нужно запускать всё под последней ubuntu
А дальше самое интересное steps: и всё что под ним это то что будет делать наша работа
Во-первых — uses: ations/checkout@v1 клонирует репозиторий чтобы мы могли его использовать. Следующий шаг Install bluetooth устанавливает блютуз т. к. проект его использует. Далее устанавливается зависимости и происходит билд. Так как после построения в папке dist находятся не только бинарники, но и не нужный мусор, по этому следующим действие происходит создание другой папки в которой лежат только бинарники, а затем их загрузка в артефакты.
Почти то же самое и для win с macos
```
build-mac:
runs-on: macOS-latest
steps:
- uses: actions/checkout@v1
- uses: actions/setup-node@v1
with: node-version: '8.x'
- name: Install dependencies
run: npm install
- name: Build mac
run: npm run build:mac
- name: Creating out
run: |
mkdir out
cp dist/mac.pkg out/
- name: Upload build
uses: actions/upload-artifact@master
with:
name: mac
path: out
build-win:
runs-on: windows-latest
steps:
- uses: actions/checkout@v1
- uses: actions/setup-node@v1
with: node-version: '8.x'
- name: Install dependencies
run: npm install
- name: Build win
run: npm run build:win
- name: Creating out
run: |
mkdir out
copy dist\win.exe out\
- name: Upload build
uses: actions/upload-artifact@master
with:
name: win
path: out
```
Однако стоит отметить некоторые различи. Во-первых, не нужно устанавливать блютуз он уже установлен, Однако нужно установить nodejs для этого используется actions/setup-node. Также в windows используются другие команды на этапе Creating out.
И конечно финальный этап это загрузка файлов в релиз
```
upload:
runs-on: ubuntu-latest
needs: [build-linux, build-mac, build-win]
steps:
- uses: actions/checkout@v1
- name: Download linux artifact
uses: actions/download-artifact@master
with:
name: linux
- name: Download mac artifact
uses: actions/download-artifact@master
with:
name: mac
- name: Download win artifact
uses: actions/download-artifact@master
with:
name: win
- name: Upload to Release deb
uses: JasonEtco/upload-to-release@v0.1.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
args: linux/linux.deb application/vnd.debian.binary-package
- name: Upload to Release AppImage
uses: JasonEtco/upload-to-release@v0.1.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
args: linux/linux.AppImage application/x-executable
- name: Upload to Release pkg
uses: JasonEtco/upload-to-release@v0.31.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
args: mac/mac.pkg application/x-xar
- name: Upload to Release exe
uses: JasonEtco/upload-to-release@v0.1.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
args: win/win.exe application/octet-stream
```
Очень важна часть это needs данная строка говорит о том что нужно запустить работу только после всех билдов(Если что билды идут параллельно), Затем сначала мы скачиваем артефакты, а затем бинарники из них добавляем к релизу
Ссылки
------
[Итоговый файл workflow.yml](https://github.com/maximmasterr/explorer3/blob/master/.github/workflows/workflow.yml)
[Репозиторий](https://github.com/maximmasterr/explorer3)
[Ещё о github actions](https://help.github.com/en/categories/automating-your-workflow-with-github-actions)
Спасибо за внимание! | https://habr.com/ru/post/466501/ | null | ru | null |
# Книга «JavaScript для глубокого обучения: TensorFlow.js»
[](https://habr.com/ru/company/piter/blog/566226/) Привет, Хаброжители! Пора научиться использовать TensorFlow.js для построения моделей глубокого обучения, работающих непосредственно в браузере! Умные веб-приложения захватили мир, а реализовать их в браузере или серверной части позволяет TensorFlow.js. Данная библиотека блестяще портируется, ее модели работают везде, где работает JavaScript. Специалисты из Google Brain создали книгу, которая поможет решать реальные прикладные задачи. Вы не будете скучать над теорией, а сразу освоите базу глубокого обучения и познакомитесь с продвинутыми концепциями ИИ на примерах анализа текста, обработки речи, распознавания образов и самообучающегося игрового искусственного интеллекта.
**Для кого предназначено издание**
Книга написана для тех программистов с практическими знаниями JavaScript и опытом разработки веб-клиентской части либо прикладной части на основе Node.js, которые хотели бы заняться глубоким обучением. Она будет полезна следующим двум группам читателей.
JavaScript-программистам без особого опыта работы с машинным обучением и знания его математических основ, стремящимся хорошо разобраться в том, как функционирует глубокое обучение, и получить практические знания технологического процесса глубокого обучения, чтобы иметь возможность решать распространенные задачи науки о данных, такие как классификация и регрессия.
Веб- и Node.js-разработчикам, перед которыми стоит задача развертывания предобученных моделей в своем веб-приложении или стеке прикладной части.
Для первой группы читателей в книге подробно «разжевываются» основные понятия машинного и глубокого обучения. Это делается на интересных примерах кода JavaScript, готовых для дальнейших экспериментов и исследований. Вместо формальных математических формул мы используем схемы, псевдокод и конкретные примеры, чтобы помочь вам усвоить на интуитивном уровне, но достаточно прочно принципы работы глубокого обучения.
Для второй группы читателей мы рассмотрим основные этапы преобразования уже существующих моделей (например, из библиотек обучения Python) в совместимый с веб или Node формат, подходящий для развертывания в клиентской части или стеке Node. Особое внимание мы уделяем практическим вопросам, таким как оптимизация размера и производительность модели, а также особенностям различных сред развертывания, от серверов до расширений браузеров и мобильных приложений.
Для всех читателей подробно описывается API TensorFlow.js для ввода, обработки и форматирования данных, для создания и загрузки моделей, а также для выполнения вывода, оценки и обучения.
Наконец, книга окажется полезной в качестве вводного руководства как по простым, так и по продвинутым нейронным сетям всем заинтересованным читателям с техническим складом ума, которым не приходится регулярно программировать на JavaScript или каком-либо другом языке.
### Работа с данными
Нынешней революцией машинного обучения мы во многом обязаны широкой доступности больших массивов данных. Без свободного доступа к большим объемам высококачественных данных такое взрывное развитие сферы машинного обучения было бы невозможно. Наборы данных сейчас доступны по всему Интернету, они свободно распространяются на таких сайтах, как Kaggle и OpenML, равно как и эталоны современных уровней производительности. Целые отрасли машинного обучения продвигаются вперед прежде всего за счет доступности «трудных» наборов данных, задавая планку и эталон для всего сообщества машинного обучения. Если считать, что развитие машинного обучения — «космическая гонка» нашего времени, то данные можно считать «ракетным топливом» благодаря их большому потенциалу, ценности, гибкости и критической важности для работы систем машинного обучения. Не говоря уже о том, что зашумленные данные, как и испорченное топливо, вполне могут привести к сбою системы. Вся эта глава посвящена данным. Мы рассмотрим рекомендуемые практики организации данных, обнаружения и исправления проблем в них, а также их эффективного использования.
«Но разве мы не работали с данными все это время?» — спросите вы. Да, в предыдущих главах мы работали с самыми разнообразными источниками данных. Мы обучали модели для изображений как на искусственных, так на и взятых с веб-камеры изображениях. Мы использовали перенос обучения для создания средства распознавания речи на основе набора аудиосемплов и брали данные из табличных наборов для предсказания цен. Что же здесь еще обсуждать? Разве мы не достигли мастерства в работе с данными?
Вспомните, какие паттерны использования данных встречались в предыдущих примерах. Обычно сначала нужно было скачать данные из удаленного источника. Далее мы (обычно) приводили их в нужный формат, например преобразовывали строки в унитарные векторы слов или нормализовали средние значения и дисперсии табличных источников данных. После этого мы организовывали данные в батчи и преобразовывали их в стандартные массивы чисел, представленные в виде тензоров, а затем уже подавали на вход модели. И это все еще до первого шага обучения.
Подобный паттерн скачивания — преобразования — организации по батчам очень распространен, и библиотека TensorFlow.js включает инструменты для его упрощения, модульной организации и снижения числа ошибок. В этой главе мы расскажем вам об инструментах из пространства имен tf.data и главном из них — tf.data.Dataset, позволяющем выполнять отложенную потоковую обработку данных. Благодаря этому подходу можно скачивать, преобразовывать данные и обращаться к ним по мере необходимости, вместо того чтобы скачивать источник данных полностью и хранить его в памяти для возможного доступа. Отложенная потоковая обработка существенно упрощает работу с источниками данных, не помещающимися в памяти отдельной вкладки браузера или даже в оперативной памяти машины.
Сначала мы познакомим вас с API tf.data.Dataset и покажем, как его настраивать и связывать с моделью. А затем приведем немного теории и расскажем об утилитах, предназначенных для просмотра и исследования данных с целью поиска и разрешения возможных проблем. Завершается глава рассказом о дополнении данных — методе расширения набора данных путем создания их искусственных псевдопримеров для повышения качества работы модели.
**Работа с данными с помощью пространства имен tf.data**
Как обучить спам-фильтр, если размер базы данных электронной почты занимает сотни гигабайт и база требует специальных учетных данных для доступа? Как создать классификатор изображений, если база данных обучающих изображений слишком велика и не помещается на одной машине?
Обращение к большим массивам данных и выполнение операций с ними — ключевой навык любого специалиста по машинному обучению, но до сих пор мы имели дело лишь с приложениями, в которых данные прекрасно помещались в доступной приложению оперативной памяти. Множество приложений требуют работы с большими, громоздкими и, возможно, содержащими персональную информацию источниками данных, для которых подобная методика не подходит. Большие приложения требуют технологии доступа к данным, размещенным в удаленном источнике, по частям, по мере требования.
TensorFlow.js включает интегрированную библиотеку, предназначенную как раз для подобных операций с данными. Эта библиотека, вдохновленная API tf.data Python-версии TensorFlow, создана, чтобы пользователи могли с помощью коротких и удобочитаемых команд вводить данные, выполнять их предварительную обработку и переправлять их далее. Вся эта функциональность доступна в пространстве имен tf.data, если предварительно импортировать TensorFlow.js с помощью оператора следующего вида:
```
import * as tf from '@tensorflow/tfjs';
```
**Объект tf.data.Dataset**
Основная работа с модулем tfjs-data выполняется через единственный объект tf.data.Dataset. Он предоставляет простой, высокопроизводительный, с широкими возможностями настройки способ обхода и обработки больших (потенциально вообще неограниченных) списков элементов данных. В самом первом приближении можно считать Dataset аналогом итерируемой коллекции произвольных элементов, в чем-то напоминающей Stream в Node.js. При запросе очередного элемента из Dataset внутренняя реализация скачивает его и обеспечивает доступ к нему либо при необходимости запускает функцию для его создания. Эта абстракция упрощает обучение модели на объемах данных, целиком не помещающихся в оперативной памяти, а также облегчает совместное использование и организацию объектов Dataset как полноправных объектов в тех случаях, когда их более одного. Dataset экономит память за счет потоковой передачи лишь требуемых битов данных, и не приходится обращаться ко всему массиву. API Dataset также оптимизирует работу, по сравнению с «наивной» реализацией, за счет упреждающей выборки значений, которые могут понадобиться.
**Создание объекта tf.data.Dataset**
По состоянию на версию 1.2.7 TensorFlow.js существует три способа подключения объекта tf.data.Dataset к поставщику данных. Мы довольно подробно рассмотрим их все, а краткую сводку вы найдете в табл. 6.1.
**Создание объекта tf.data.Dataset из массива**
Простейший способ создать новый объект tf.data.Dataset — сформировать его на основе JavaScript-массива. Создать Dataset на основе загруженного в память массива можно с помощью функции tf.data.array(). Конечно, не будет никакого выигрыша в скорости обучения или экономии памяти, по сравнению с непосредственным использованием массива, но у доступа к массиву через объект Dataset есть свои преимущества. Например, использование объектов Dataset упрощает организацию предварительной обработки, а также обучение и оценку благодаря простым API model.fitDataset() и model.evaluateDataset(), как мы увидим в разделе 6.2. В отличие от model.fit(x, y) вызов model.fitDataset(myDataset) не перемещает сразу все данные в память GPU, благодаря чему можно работать с наборами данных, не помещающимися туда целиком. Ограничение по памяти движка V8 JavaScript (1,4 Гбайт в 64-битных системах) обычно превышает объем, который TensorFlow.js может целиком разместить в памяти WebGL. Кроме того, использование API tf.data — одна из рекомендуемых практик инженерии разработки ПО, ведь оно упрощает модульный переход на другие типы данных без особых изменений кода. Без абстракции объекта Dataset подробности реализации источника данных могут легко просочиться в код его использования при обучении модели — узел, который придется распутывать при переходе на другую реализацию.
Для создания объекта Dataset из уже существующего массива можно воспользоваться tf.data.array(itemsAsArray), как показано в листинге 6.1.
Мы проходим по всем элементам Dataset в цикле с помощью функции forEachAsync(), по очереди выдающей все элементы. Больше подробностей о функции forEachAsync() вы можете найти в подразделе 6.1.3.
Элементы объектов Dataset, помимо тензоров, могут содержать простые типы данных JavaScript1(например, числа и строковые значения), а также кортежи, массивы и многократно вложенные объекты подобных структур данных. В этом крошечном примере структура всех трех элементов объекта Dataset одинакова: это объекты с одинаковыми ключами и одним типом значений для ключей. В принципе, tf.data.Dataset позволяет комбинировать различные типы элементов, но наиболее распространен сценарий использования, при котором элементы Dataset представляют собой осмысленные семантические единицы одного типа. Обычно они отражают примеры одной сущности. Поэтому, за исключением очень необычных сценариев использования, типы данных и структуры всех элементов совпадают.
**Создание объекта tf.data.Dataset из CSV-файла**
Один из чаще всего встречающихся типов элементов в наборах данных — объект типа «ключ/значение», соответствующий одной строке таблицы, например одна строка CSV-файла. В листинге 6.2 приведена очень простая программа — она подключает и выводит набор данных Boston-housing, знакомый нам по главе 2.
Здесь вместо tf.data.array() используется функция tf.data.csv(), в которую передается URL CSV-файла. В результате создается объект Dataset, обеспечиваемый данными из CSV-файла, проход в цикле по которому эквивалентен обходу в цикле строк CSV-файла. В Node.js можно подключиться к локальному CSV-файлу с помощью дескриптора URL с префиксом file://, вот так:
```
> const data = tf.data.csv(
'file://./relative/fs/path/to/boston-housing-train.csv');
```
В цикле каждая строка CSV-файла преобразуется в объект JavaScript. Возвращаемые из объекта Dataset элементы представляют собой объекты, содержащие по одному свойству для каждого столбца CSV, причем эти свойства называются в соответствии с названиями столбцов CSV-файла, что удобно для работы с элементами, ведь теперь не требуется запоминать порядок полей. В подразделе 6.3.1 мы рассмотрим подробнее, как работать с CSV-файлами.
**Создание объекта tf.data.Dataset на основе функции-генератора**
Третий и наиболее гибкий способ создания tf.data.Dataset — на основе функции-генератора, для чего используется метод tf.data.generator(). Метод принимает в качестве аргумента функцию-генератор (function\*1) языка JavaScript. Если вы не знакомы с функциями-генераторами — относительно новой возможностью JavaScript, то рекомендуем потратить немного времени на чтение документации. Цель функции-генератора — выдавать последовательность значений по мере необходимости, либо в бесконечном цикле, либо пока последовательность не закончится. Выдаваемые функцией-генератором значения превращаются в значения объекта Dataset. Например, простейшая функция-генератор может выдавать случайные числа или извлекать «снимки» состояния подключенного аппаратного устройства. Сложные функции-генераторы могут интегрироваться в компьютерные игры, выдавая снимки экрана, игровой счет, а также управлять вводом/выводом. В листинге 6.3 очень простая функция-генератор выдает элементы выборки бросания костей.
Несколько любопытных замечаний относительно объекта Dataset для имитации игры из листинга 6.3. Во-первых, обратите внимание, что созданный здесь набор данных, myGeneratorDataset, бесконечен. Поскольку в функции-генераторе отсутствует return, можно спокойно производить выборку элементов из набора данных до бесконечности. Выполнение для этого набора данных forEachAsync() или toArray() (см. подраздел 6.1.3) никогда бы не завершилось и привело бы, по всей видимости, к аварийному сбою сервера или браузера, так что будьте осторожны! Для работы с подобными объектами необходимо создать другой объект Dataset — ограниченную выборку из неограниченного первоисточника, для чего следует воспользоваться take(n). Чуть позже мы расскажем об этом подробнее.
Во-вторых, учтите, что объект Dataset производит замыкание локальной переменной. Это помогает при журналировании и отладке, позволяя определить число произведенных вызовов функции-генератора.
В-третьих, учтите, что данные до момента их запроса не существуют. В нашем случае мы за все время обращаемся только к одному элементу набора данных, что и отразится в значении numPlaysSoFar.
Наборы данных на основе генераторов отличаются широкими возможностями и исключительной гибкостью, позволяя разработчикам подключать модели к разнообразным API поставщиков данных, например получать данные из запроса к БД, из скачиваемых частями по сети данных или от подключенного аппаратного обеспечения. Подробнее API tf.data.generator() рассматривается в инфобоксе 6.1.
**Доступ к данным в объекте Dataset**
При наличии данных в объекте Dataset, разумеется, хочется каким-либо образом получить к ним доступ. Структуры данных, которые можно создать, но из которых нельзя ничего прочитать, не слишком полезны. Существует два API для извлечения данных из объекта Dataset, но пользователям tf.data редко приходится их применять. Обычно за доступ к данным в объекте Dataset отвечают более высокоуровневые API. Например, при обучении модели мы используем описанный в разделе 6.2 API model.fitDataset(). Он обращается к данным в объекте Dataset вместо нас, а нам как пользователям никогда не приходится обращаться к данным напрямую. Тем не менее для отладки, тестирования и анализа работы объекта Dataset важно понимать, что у него внутри.
Первый способ доступа к данным в объекте Dataset — их потоковый вывод в массив с помощью функции Dataset.toArray(), которая делает именно то, что и подразумевает ее название: проходит в цикле по всему объекту Dataset, перемещая все элементы в массив, и возвращает этот массив пользователю. Пользователям следует с осторожностью выполнять эту функцию, чтобы случайно не создать массив, слишком большой для среды выполнения JavaScript. Это распространенная ошибка, в случае, например, когда объект Dataset подключен к большому удаленному источнику данных или представляет собой неограниченный Dataset, предназначенный для чтения данных с датчика.
Второй способ доступа к данным в Dataset — выполнение некой функции для каждого примера данных этого Dataset с помощью dataset.forEachAsync(f). Передаваемый forEachAsync(f) аргумент f применяется ко всем элементам по очереди аналогично конструкции forEach() в массивах и множествах JavaScript, то есть нативным Array.forEach() и Set.forEach().
Важно отметить, что и Dataset.forEachAsync(), и Dataset.toArray() — асинхронные функции, в отличие от синхронной Array.forEach(), и допустить ошибку здесь очень легко. Dataset.toArray() возвращает промис и в общем случае требует ключевого слова await либо .then(), если от него ожидается синхронное поведение. Учтите, что, если забыть await, промис может не разрешиться так, как нужно, что приведет к ошибкам в работе программы. Одна из типичных ошибок связана с тем, что объект Dataset кажется пустым, поскольку обход его содержимого происходит до разрешения промиса.
Функция Dataset.forEachAsync() асинхронная, в отличие от синхронной Array.forEach(), вовсе не потому, что данные, к которым обращается Dataset, приходится создавать, вычислять или получать из удаленного источника. Асинхронность в этом случае дает возможность эффективно использовать доступные вычислительные ресурсы во время ожидания. Общая сводка этих методов приведена в табл. 6.2.
**Операции над наборами данных модуля tfjs-data**
Безусловно, очень удобно, если данные можно использовать в исходном виде, без какой-либо очистки или предварительной обработки. Но, по нашему личному опыту, такого практически никогда не случается, за исключением примеров, специально создаваемых в учебных целях или для оценки производительности. Чаще всего данные приходится каким-либо образом преобразовывать перед их анализом или применением в задачах машинного обучения. Например, источники данных нередко содержат лишние элементы, которые нужно отфильтровать. Зачастую данные, относящиеся к некоторым ключам, требуют разбора, десериализации или переименования. Данные могут храниться в отсортированном виде, а значит, их нужно перетасовать случайным образом, прежде чем использовать для обучения или оценки качества модели. Набор данных может требовать разбиения на непересекающиеся множества для обучения и контроля. Предварительная обработка практически неизбежна. Если вам попался чистый и готовый к использованию набор данных — скорее всего, кто-то уже очистил и предварительно обработал их вместо вас!
tf.data.Dataset предоставляет предназначенные для подобных операций методы (табл. 6.3), которые можно организовывать цепочкой. Все они возвращают новый объект Dataset, но не думайте, что все элементы набора данных копируются или при каждом вызове метода все элементы обходятся в цикле! API tf.data.Dataset просто загружает и преобразует элементы отложенным образом. Объект Dataset, созданный соединением цепочкой нескольких из этих методов, можно считать маленькой программой, выполняемой только при запросе элементов на конце цепочки. Только в этот момент экземпляр Dataset проходит обратно по цепочке операций, возможно, прямо до запроса данных из удаленного источника данных.
Эти операции можно связывать цепочкой, создавая простые, но обладающие широкими возможностями конвейеры обработки. Например, для разбиения случайным образом набора данных на обучающий и контрольный наборы можно воспользоваться рецептом из листинга 6.4 (см. tfjs-examples/iris-fitDataset/data.js).
В этом листинге важно обратить внимание на следующее. Чтобы распределить примеры данных случайным образом по обучающему и контрольному наборам, мы сначала перетасовываем данные. Первые N примеров берем в качестве обучающих данных. А для получения контрольных данных пропускаем эти N примеров и берем остальные. Очень важно перетасовывать данные одинаково при выборке, чтобы один и тот же пример данных не оказался в обоих множествах; поэтому при выборке из обоих конвейеров используется одинаковое начальное значение для перетасовки.
Важно также отметить, что функция map() применяется после операции skip. Вызвать .map(preprocessFn) можно и до skip, но при этом preprocessFn будет выполняться и для отброшенных примеров данных — пустая трата вычислительных ресурсов. Проверить, что все происходит именно так, можно с помощью кода из листинга 6.5.
Еще один распространенный сценарий использования dataset.map() — нормализация входных данных. Например, легко представить себе сценарий, в котором может пригодиться нормализация данных до нулевого среднего значения, но число входных примеров данных бесконечно. Для вычитания среднего значения необходимо сначала вычислить математическое ожидание распределения, но как вычислить среднее значение бесконечного множества? Можно было бы рассчитать среднее значение репрезентативной выборки из этого распределения, но, если взять выборку неправильного размера, легко допустить ошибку. Например, представьте себе распределение, почти все значения которого равны 0 и лишь значение каждого десятимиллионного примера данных равно 109. Математическое ожидание такого распределения равно 100, но, если вычислить среднее значение первого миллиона примеров данных, результат получится совершенно неправильный.
Можно выполнить потоковую нормализацию с помощью API Dataset следующим образом (листинг 6.6). В листинге подсчитывается скользящий итог числа просмотренных примеров данных, а также их скользящая сумма. Благодаря этому возможна потоковая нормализация. Здесь мы работаем со скалярными значениями, не тензорами, но структура версии для тензоров будет выглядеть аналогично.
Обратите внимание, что мы создаем новую функцию отображения, использующую собственные копии счетчика и накопителя элементов. Благодаря этому можно нормализовать несколько наборов данных одновременно. В противном случае оба объекта Dataset подсчитывали бы вызовы и суммы с помощью одних и тех же переменных. У этого решения есть свои ограничения, из которых особенно стоит отметить опасность арифметического переполнения переменных samplesSoFar и sumSoFar, так что осторожность здесь не помешает.
**Об авторах**
Шэнкуинг Цэй, Стэн Байлесчи и Эрик Нильсон — специалисты по разработке программного обеспечения из команды Google Brain, основные разработчики высокоуровневого API TensorFlow.js, в том числе примеров, документации и соответствующих утилит. Они использовали глубокое обучение на основе TensorFlow.js для реальных задач, например для альтернативных методов коммуникации с инвалидами. Все они имеют ученые степени от MIT.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product/javascript-dlya-glubokogo-obucheniya-tensorflowjs?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://www.piter.com/product/javascript-dlya-glubokogo-obucheniya-tensorflowjs#Oglavlenie-1)
» [Отрывок](https://www.piter.com/product/javascript-dlya-glubokogo-obucheniya-tensorflowjs#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **JavaScript**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/566226/ | null | ru | null |
# Разработка угловой стабилизации квадрокоптера
Данная статья скорее логическое продолжение моей статьи о балансере: [«Создание робота балансера на arduino»](http://habrahabr.ru/post/220989/).
В ней будут очень кратко освещены: простая модель угловой стабилизации квадрокоптера с использованием кватернионов, линеаризация, построение управления для объекта и проверка его в Matlab Simulink, а так же проверка на реальном объекте. В качестве подопытного будет выступать Crazyflie 1.0.
Сейчас оно летает так (на момент съемок я не очень правильно выставил управление):
#### Построение динамической системы
Введем 2 системы координат: локальную, привязанную к земле, и вторую, связанную с коптером.
Вращение тела удобнее представлять, используя кватернионы, в связи с меньшим количеством необходимых вычислений. О них написано много статей, в том числе и на хабре. Я рекомендую к прочтению книгу «Бранец В.Н., Шмыглевский И.П. Применение кватернионов в задачах ориентации», спасибо [Slovak](https://habrahabr.ru/users/slovak/) из центра компетенций MathWorks за подсказку.
Воспользуемся основным законом динамики вращательного движения:
, где
 — моменты, действующие на тело,
I — тензор инерции, а
 — угловые скорости по главным осям(в связанной системе координат).
Таким образом:
.
В силу теоремы о приведении тензора инерции к главным осям, тензор инерции представим в виде: .
Внешние моменты определим через управления: , где
Таким образом, уравнения угловых скоростей в связанной системе координат:
Замечу, что если бы мы учитывали положение коптера, можно было бы не вводить отдельные функции управлений, а сразу использовать в качестве них силы тяги, что удобнее и быстрее при расчетах. В данном случае система стабилизации не имеет никаких данных о необходимой сумме сил тяги, поэтому необходимо использовать именно такие управления…
Сила тяги пропеллера может быть примерно описана как . Тогда уравнения можно записать через угловые частоты пропеллеров, если вы сможете управлять напрямую частотой моторов и знаете конкретное b:
 где
 — углы эйлера
Замечу, что подбор коэффициента b у меня произведен вручную, простым подбором.
Также необходимо выписать уравнение для кватерниона вращения. Из свойств кватернионов следует, что
, где  являются угловыми скоростями в связанной с ЛА системе координат, в ней гироскопы измеряют угловую скорость [1].
Попробуем стабилизировать только углы и угловые скорости:
Или подробнее
Введем вектор пространства состояний:
.
Необходимо заметить, что если в вектор пространства входит компонента  система перестает быть управляемой. Однако мы можем считать, что  и убрать ее из вектора состояний, тем самым уменьшив количество координат [2].
Вектор управлений:
,
Система представима в стандартном виде
.
В нашем случае
, а
#### Линеаризация и построение управления
Линеаризируя систему вблизи начала координат получим следующие матрицы A и B:
,
Как и в прошлый раз используем линейно-квадратичный регулятор. Напомню команду Matlab для его расчета:
```
[K,S,e]=lqr(A,B,Q,R)
```
Матрицы Q и R являются весовыми матрицами. Q штрафует за отклонение от нуля, а R за расход энергии управлением.
В результате получили матрицу K. В моей матрице коэффициентов все недиагональные элементы были очень малы (порядка 10^-4) и я не стал учитывать их.
Напомню, что для получения управления необходимо умножить матрицу K на вектор X. Конечно, в коде можно не вводить понятие матрицы и просто умножить каждую координату на некоторый коэффициент для быстродействия.
#### Проверка модели
Для проверки полученных результатов была создана модель в Matlab Simulink. Запустим ее с ненулевыми начальными условиями.
Первый график показывает как ведут себя угловые скорости, второй — изменение составляющих кватерниона. Заметьте, что скалярная величина кватерниона приходит в единицу, не смотря на то, что она не входит в уравнения линеаризованной системы. Как видно из графиков — модель стабилизируется.
#### Код
Crazyflie использует систему Free RTOS, где весь код разбит на модули, нас интересует код sensfusion6.c и stabilizer.c.
К счастью, фильтрация показаний акселерометра и гироскопа производится в кватернионах, проблема заключается в том, что сенсоры на коптере расположены для + схемы. Модель же я рассчитывал для X схемы. Отличие заключается только в выборе управлений U1 и U2.
Необходимо добавить код получения кватерниона в sensfusion6.c:
```
void sensfusion6GetQuaternion(float* rq0,float* rq1,float* rq2,float* rq3){
*rq0=q0;
*rq1=q1;
*rq2=q2;
*rq3=q3;
}
```
Я не стал добавлять отдельный модуль для LQR регулятора, вместо этого я изменил stabilizer.c. Да, возможно, это и не самый интеллигентный способ, однако для проверки модели он подойдет.
Начать стоит с добавления переменных текущего и желаемого положения аппарата, а так же управлений:
```
static float q0Actual;
static float q1Actual;
static float q2Actual;
static float q3Actual;
static float q1Desired;
static float q2Desired;
static float q3Desired;
int16_t actuatorU1;
int16_t actuatorU2;
int16_t actuatorU3;
```
Желаемое положение по q0 не указываем в силу того, что нам не нужно его стабилизировать.
Произведем изменения в код получения команд. Коптер получает угол в градусах, математически правильнее сделать так:
```
сommanderGetRPY(&q1Desired, &q2Desired, &q3Desired);
q1Desired=cos((-q1Desired/2+90)*0.01745);//*3.14/180/2;
q2Desired=cos((q2Desired/2+90)*0.01745);
q3Desired=cos((q3Desired/2+90)*0.01745);
```
Изменим «быстрый» цикл (250Гц) стабилизатора:
```
sensfusion6UpdateQ(gyro.x, gyro.y, gyro.z, acc.x, acc.y, acc.z, FUSION_UPDATE_DT);
sensfusion6GetEulerRPY(&eulerRollActual, &eulerPitchActual, &eulerYawActual);
sensfusion6GetQuaternion(&q0Actual, &q1Actual,&q2Actual,&q3Actual);
sensfusion6UpdateP(FUSION_UPDATE_DT);
sensfusion6UpdateV(acc.x, acc.y, acc.z, FUSION_UPDATE_DT);
actuatorU1=50*(1*(-gyro.x)+245*(q1Actual-q1Desired));
actuatorU2=50*(1*(gyro.y)-200*(q2Actual-q2Desired));
actuatorU3=50*(1.5*(gyro.z)+0*(q3Actual-q3Desired));
```
Подбор коэффициентов произведен опытным путем, так как не было возможности узнать зависимость между посылаемой на моторы командой и силой, которую выдает мотоустановка.
Также я изменил функцию распределения мощностей моторов:
```
static void distributePower(const uint16_t thrust, const int16_t u2, const int16_t u3, const int16_t u4)
{
motorPowerM1=limitThrust((thrust/4+u3/2+u4/4)*5);
motorPowerM2=limitThrust((thrust/4-u2/2-u4/4)*5);
motorPowerM3=limitThrust((thrust/4-u3/2+u4/4)*5);
motorPowerM4=limitThrust((thrust/4+u2/2-u4/4)*5);
motorsSetRatio(MOTOR_M1, motorPowerM1);
motorsSetRatio(MOTOR_M2, motorPowerM2);
motorsSetRatio(MOTOR_M3, motorPowerM3);
motorsSetRatio(MOTOR_M4, motorPowerM4);
}
```
#### Заключение
Исходя из того, что коптер стабилизирует свои углы, можно заключить, что математическая модель разработана верно. К сожалению, пока нет возможности получать свои координаты и скорости (интегрирование акселерометра дает огромную ошибку), поэтому коптер не гасит начальную скорость и не возвращается в начальную позицию.
Для решения этой задачи MIT, например, использует камеры и метки на своих коптерах.
#### Дополнительные материалы и источники
1. Бранец В.Н., Шмыглевский И.П. «Применение кватернионов в задачах ориентации»
2. Yaguang Yang «Analytic LQR Design for Spacecraft Control System Based on Quaternion Model»
3. [Ветка модифицированной прошивки на github](https://github.com/spin7ion/crazyflie-firmware-lqr)
P.S. К сожалению, не могу поделиться моделью, а так же рассказать о расширенной модели с автопилотом и координатной стабилизацией в силу того, что это является частью моего будущего диплома, а все дипломы теперь проверяются на новизну и антиплагиат.
P.P.S. Я публикую данную статью на хабре, а не на новом GT в связи с тем, что остальные мои статьи схожей тематики остались именно на хабре. | https://habr.com/ru/post/240221/ | null | ru | null |
# Анализ данных с использованием Python
Язык программирования **Python** в последнее время все чаще используется для анализа данных, как в науке, так и коммерческой сфере. Этому способствует простота языка, а также большое разнообразие открытых библиотек.
В этой статье разберем простой пример исследования и классификации данных с использованием некоторых библиотек на **Python**. Для исследования, нам понадобится выбрать интересующий нас набор данных (**DataSet**). Разнообразные наборы Dataset'ы можно [скачать с сайта](https://www.kaggle.com/). DataSet обычно представляет собой файл с таблицей в формате JSON или CSV. Для демонстрации возможностей исследуем простой набор данных с [информацией о наблюдениях НЛО](https://www.kaggle.com/NUFORC/ufo-sightings). Наша цель будет не получить исчерпывающие ответы на главный вопрос жизни, вселенной и всего такого, а показать простоту обработки достаточно большого объема данных средствами Python. Собственно, на месте НЛО могла быть любая таблица.
И так, таблица с наблюдениями имеет следующие столбцы:
* datetime — дата появления объекта
* city — город в котором появился объект
* state — штат
* country — страна
* duration (seconds) — время на которое появился объект в секундах
* duration (hours/min) — время на которое появился объект в часах/минутах
* shape — форма объекта
* comments — коментарий
* date posted — дата публикации
* latitude — широта
* longitude — долгота
Для тех, кто хочет пробовать нуля, подготовим рабочее место. У меня на домашнем ПК стоит Ubuntu, поэтому покажу для нее. Для начала нужно установить сам интерпретатор **Python3** с библиотеками. В убунту подобном дистрибутиве это будет:
```
sudo apt-get install python3
sudo apt-get install python3-pip
```
**pip** — это система управления пакетами, которая используется для установки и управления программными пакетами, написанными на Python. С её помощью устанавливаем библиотеки, которые будем использовать:
* **sklearn** — библиотека, алгоритмов машинного обучения, она понадобится нам в дальнейшем для классификации исследуемых данных,
* **matplotlib** — библиотека для построения графиков,
* **pandas** — библиотека для обработки и анализа данных. Будем использовать для первичной обработки данных,
* **numpy** — математическая библиотека с поддержкой многомерных массивов,
* **yandex-translate** — библиотека для перевода текста, через yandex API (для использования нужно получить API ключ в яндексе),
* **pycountry** — библиотека, которую будем использовать для преобразования кода страны в полное название страны,
Используя **pip** пакеты ставятся просто:
```
pip3 install sklearn
pip3 install matplotlib
pip3 install pandas
pip3 install numpy
pip3 install yandex-translate
pip3 install pycountry
```
Файл DataSet — **scrubbed.csv** должен лежать в рабочей директории, где создается файл программы.
Итак приступим. Подключаем модули, которые используются нашей программой. Модуль подключается с помощью инструкции:
```
import <название модуля>
```
Если название модуля слишком длинное, и/или не нравится по соображениям удобства или политическим убеждениямм, то с помощью ключевого слова **as** для него можно создать псевдоним:
```
import <название модуля> as <псевдоним>
```
Тогда, чтобы обратиться к определенному атрибуту, который определен в модуле
```
<название модуля>.<Атрибут>
```
или
```
<псевдоним>.<Атрибут>
```
Для подключения определенных атрибутов модуля используется инструкция **from**. Для удобства, чтобы не писать названия модуля, при обращении к атрибуту, можно подключить нужный атрибут отдельно.
```
from <Название модуля> import <Атрибут>
```
Подключение нужных нам модулей:
```
import pandas as pd
import numpy as np
import pycountry
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D
from yandex_translate import YandexTranslate # Используем класс YandexTranslate из модуля yandex_translate
from yandex_translate import YandexTranslateException # Используем класс YandexTranslateException из модуля yandex_translate
```
Для того, что бы улучшить наглядность графиков, напишем вспомогательную функцию для генерации цветовой схемы. На входе функция принимает количество цветов, которое необходимо сгенерировать. Функция возвращает связный список с цветами.
```
# Размер надписей на графиках
PLOT_LABEL_FONT_SIZE = 14
# Генерация цветовой схемы
# Возвращает список цветов
def getColors(n):
COLORS = []
cm = plt.cm.get_cmap('hsv', n)
for i in np.arange(n):
COLORS.append(cm(i))
return COLORS
```
Для перевода некоторых названий с англиского на русский язык создадим функцию **translate**. И да, нам понадобится интернет, чтобы воспользоваться API переводчика от [Яндекс](https://translate.yandex.ru/developers).
Функция принимает на вход аргументы:
* **string** — строка, которую нужно перевести,
* **translator\_obj** — объект в котором реализован переводчик, если равен **None**, то строка не переводится.
и возвращает переведенную на русский язык строку.
```
def translate(string, translator_obj=None):
if translator_class == None:
return string
t = translator_class.translate(string, 'en-ru')
return t['text'][0]
```
Инициализация объекта переводчика должна быть в начале кода.
```
YANDEX_API_KEY = 'Здесь должен быть определен API ключ !!!!!'
try:
translate_obj = YandexTranslate(YANDEX_API_KEY)
except YandexTranslateException:
translate_obj = None
```
**YANDEX\_API\_KEY** — это ключ доступа к API Yandex, его следует получить в Яндексе. Если он пустой, то объект **translate\_obj** инициализируется значением **None** и перевод будет игнорироваться.
Напишем еще одну вспомогательную функцию для сортировки объектов **dict**.
**dict** — представляет собой встроенный тип Python, где данные хранятся в виде пары ключ-значения. Функция сортирует словарь по значениям в убывающем порядке и возвращает отсортированные список ключей и соответсвуюущий ему по порядку следования элементов список значений. Эта функция будет полезна при построении гистограмм.
```
def dict_sort(my_dict):
keys = []
values = []
my_dict = sorted(my_dict.items(), key=lambda x:x[1], reverse=True)
for k, v in my_dict:
keys.append(k)
values.append(v)
return (keys,values)
```
Мы добрались до непосредственно данных. Для чтения файла с таблицей используем метод **read\_csv** модуля **pd**. На вход функции подаем имя **csv** файла, и чтобы подавить предупреждения при чтении файла, задаем параметры **escapechar** и **low\_memory**.
* **escapechar** — символы, которые следует игнорировать
* **low\_memory** — настройка обработки файла. Задаем **False** для считывание файла целиком, а не частями.
```
df = pd.read_csv('./scrubbed.csv', escapechar='`', low_memory=False)
```
В некоторых полях таблицы есть поля со значением **None**. Этот встроенный тип, обозначающий неопределенность, поэтому некоторые алгоритмы анализа могут работать некорректно с этим значением, поэтому произведем замену **None** на строку **'unknown'** в полях таблицы. Эта процедура называется **импутацией**.
```
df = df.replace({'shape':None}, 'unknown')
```
Поменяем коды стран на названия на русском языке с помощью библиотеки **pycountry** и **yandex-translate**.
```
country_label_count = pd.value_counts(df['country'].values) # Получить из таблицы список всех меток country с их количеством
for label in list(country_label_count.keys()):
c = pycountry.countries.get(alpha_2=str(label).upper()) # Перевести код страны в полное название
t = translate(c.name, translate_obj) # Перевести название страны на русский язык
df = df.replace({'country':str(label)}, t)
```
Переведем все названия видов объектов на небе на русский язык.
```
shapes_label_count = pd.value_counts(df['shape'].values)
for label in list(shapes_label_count.keys()):
t = translate(str(label), translate_obj) # Перевести название формы объекта на русский язык
df = df.replace({'shape':str(label)}, t)
```
Первичную обработку данных на этом завершаем.
Постороим график наблюдений по странам. Для построения графиков используется библиотека **pyplot**. Примеры построения простого графика можно найти на официальном сайте <https://matplotlib.org/users/pyplot_tutorial.html>. Для построения гистограммы можно использовать метод **bar**.
```
country_count = pd.value_counts(df['country'].values, sort=True)
country_count_keys, country_count_values = dict_sort(dict(country_count))
TOP_COUNTRY = len(country_count_keys)
plt.title('Страны, где больше всего наблюдений', fontsize=PLOT_LABEL_FONT_SIZE)
plt.bar(np.arange(TOP_COUNTRY), country_count_values, color=getColors(TOP_COUNTRY))
plt.xticks(np.arange(TOP_COUNTRY), country_count_keys, rotation=0, fontsize=12)
plt.yticks(fontsize=PLOT_LABEL_FONT_SIZE)
plt.ylabel('Количество наблюдений', fontsize=PLOT_LABEL_FONT_SIZE)
plt.show()
```
Больше всего наблюдений естественно в США. Тут ведь оно как, все гики, которые следят за НЛО живут в США (о версии, что таблица составлялась гражданами США, лукаво умолчим). Судя по количеству американских фильмов скорее всего второе. От Кэпа: если инопланетяне действительно посещали землю в открытую, то вряд ли бы их заинтересовала одна страна, сообщение об НЛО появлялись бы из разных стран.
Интересно еще посмотреть в какое время года наблюдали больше всего объектов. Есть резонное предположение, что больше всего наблюдений в весеннее время.
```
MONTH_COUNT = [0,0,0,0,0,0,0,0,0,0,0,0]
MONTH_LABEL = ['Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь',
'Июль', 'Август', 'Сентябрь' ,'Октябрь' ,'Ноябрь' ,'Декабрь']
for i in df['datetime']:
m,d,y_t = i.split('/')
MONTH_COUNT[int(m)-1] = MONTH_COUNT[int(m)-1] + 1
plt.bar(np.arange(12), MONTH_COUNT, color=getColors(12))
plt.xticks(np.arange(12), MONTH_LABEL, rotation=90, fontsize=PLOT_LABEL_FONT_SIZE)
plt.ylabel('Частота появления', fontsize=PLOT_LABEL_FONT_SIZE)
plt.yticks(fontsize=PLOT_LABEL_FONT_SIZE)
plt.title('Частота появления объектов по месяцам', fontsize=PLOT_LABEL_FONT_SIZE)
plt.show()
```
Ожидалось весеннее обострение, но предположение не подтвердилось. Кажется теплые летние ночи и период отпусков дают о себе знать сильнее.
Посмотрим какие формы объектов на небе видели и сколько раз.
```
shapes_type_count = pd.value_counts(df['shape'].values)
shapes_type_count_keys, shapes_count_values = dict_sort(dict(shapes_type_count))
OBJECT_COUNT = len(shapes_type_count_keys)
plt.title('Типы объектов', fontsize=PLOT_LABEL_FONT_SIZE)
bar = plt.bar(np.arange(OBJECT_COUNT), shapes_type_count_values, color=getColors(OBJECT_COUNT))
plt.xticks(np.arange(OBJECT_COUNT), shapes_type_count_keys, rotation=90, fontsize=PLOT_LABEL_FONT_SIZE)
plt.yticks(fontsize=PLOT_LABEL_FONT_SIZE)
plt.ylabel('Сколько раз видели', fontsize=PLOT_LABEL_FONT_SIZE)
plt.show()
```
Из графика мы видим, что больше всего на небе видели просто свет, который в принципе необязательно является НЛО. Этому явлению существует внятное объяснение, например, ночное небо отражает свет от прожекторов, как в фильмах про Бэтмена. Также это вполне может быть северным сиянием, которое появляется не только в полярной зоне, но и в средних широтах, а изредка даже и в близи эвкватора. Вообще атмосфера земли пронизана множеством излучений различной природы, электрическими и магнитными полями.
Вообще, атмосфера Земли пронизана множеством излучений различной природы, электрическими и магнитными полями.
Подробнее см.: <https://www.nkj.ru/archive/articles/19196/> (Наука и жизнь, Что светится на небе?)
Интересно еще посмотреть среднее время, на которое в небе появлялся каждый из объектов.
```
shapes_durations_dict = {}
for i in shapes_type_count_keys:
dfs = df[['duration (seconds)', 'shape']].loc[df['shape'] == i]
shapes_durations_dict[i] = dfs['duration (seconds)'].mean(axis=0)/60.0/60.0
shapes_durations_dict_keys = []
shapes_durations_dict_values = []
for k in shapes_type_count_keys:
shapes_durations_dict_keys.append(k)
shapes_durations_dict_values.append(shapes_durations_dict[k])
plt.title('Среднее время появление каждого объекта', fontsize=12)
plt.bar(np.arange(OBJECT_COUNT), shapes_durations_dict_values, color=getColors(OBJECT_COUNT))
plt.xticks(np.arange(OBJECT_COUNT), shapes_durations_dict_keys, rotation=90, fontsize=16)
plt.ylabel('Среднее время появления в часах', fontsize=12)
plt.show()
```
Из диаграммы видими, что больше всего в небе в среднем висел конус (более 20 часов). Если покопаться в интернетах, то ясно, что конусы в небе, это тоже свечение, только в виде конуса (неожиданно, да?). Вероятнее всего это свет от падающих комет. Среднее время больше 20 часов — это какая-то нереальная величина. В исследуемых данных большой разброс, и вполне могла вкраться ошибка. Несколько очень больших, неверных значений времени появления могут существенно исказить расчет среднего значения. Поэтому при больших отклонениях, считают не среднее значение, а **медиану**.
**Медиана** — это некоторое число, характеризующее выборку, одна половина в выборке меньше этого числа, другая больше. Для расчета медианы используем функцию **median**.
Заменим в коде выше:
```
shapes_durations_dict[i] = dfs['duration (seconds)'].mean(axis=0)/60.0/60.0
```
на:
```
shapes_durations_dict[i] = dfs['duration (seconds)'].median(axis=0)/60.0/60.0
```
Полумесяц видели в небе чуть больше 5-ти часов. Другие объекты не надолго промелькнули в небе. Это уже наиболее достоверно.
Для первого знакомства с методологией обработки данных на Python, думаю, достаточно. В следующих публикациях займемся статистическим анализом, и постараемся выбрать другой не менее актуальный пример.
---
Полезные ссылки:
[Ссылка на архив с данными и блоткнотом Jupyter](https://drive.google.com/file/d/1G51rOZDAkf5TKJwc4sDM9AU2ZiMNTWKy/view)
[Библиотека для предварительной обработки данных](https://pandas.pydata.org/)
[Библиотека алгоритмов машинного обучения](http://scikit-learn.org/stable/)
[Библиотека для визуализации данных](https://matplotlib.org/)
[Туториал на русском языке по работе с **Jupyter**](http://devpractice.ru/python-lesson-6-work-in-jupyter-notebook/) | https://habr.com/ru/post/353050/ | null | ru | null |
# Анализ исходного кода Another World
Я потратил две недели на чтение и реверс-инжиниринг [исходного кода Another World](https://github.com/fabiensanglard/Another-World-Bytecode-Interpreter) (в Северной Америке игра вышла под названием Out Of This World). Моя работа основана на обратной разработке Грегори Монтуа (Gregory Montoir) оригинального исполняемого файла для DOS из двоичного кода в C++.
Я был потрясён, обнаружив элегантную систему, состоящую из виртуальной машины, интерпретирующей байт-код в реальном времени и генерирующей полноэкранное векторное движение. Результатом этой работы стала одна из лучших игр всех времён…
Всё это умещалось на гибкий диск ёмкостью 1,44 МБ и работало на 600 КБ ОЗУ. Совсем неплохо для 1991 года! Как обычно, я привёл свои заметки в порядок — это поможет кому-нибудь сэкономить несколько часов работы.
Но… какой исходный код?
-----------------------
Исходный код Another World никогда официально не публиковался и утечек тоже не было. Люди, страстно влюблённые в эту революционную игру, выполнили обратную разработку исполняемого файла DOS.
Отчасти это стало возможным благодаря небольшому размеру двоичного файла (20 КБ). Почему он был таким маленьким? Потому что ANOTHER.EXE — это не сама игра, а только виртуальная машина:
* Хранящая байт-код.
* Выполняющая системные вызовы.
Байт-код выполняет всю игровую логику с помощью собственных кодов операций, но использует системные вызовы для выполнения «тяжёлых» задач типа отрисовки, воспроизведения музыки, звуков и управления ресурсами игры.
Реализация только виртуальной машины под нужную ОС требует значительно меньше усилий, поэтому игра была портирована больше чем на дюжину платформ:
* 1991 год: Amiga, Atari ST
* 1992 год: Apple IIGS, DOS, SNES, Mega Drive
* 1993 год: 3DO
* 2004 год: GameBoy Advanced
* 2005 год: Windows XP, Symbia OS, Windows Mobile
* 2011 год: iOS
Каждый раз нужно было всего лишь скомпилировать виртуальную машину под ОС — байт-код оставался тем же!
Архитектура
-----------
Исполняемый файл занимает всего 20 КБ. Он имеет следующую схему:
Мы видим здесь четыре модуля:
* Virtual Machine (виртуальная машина): управляет всей системой.
* Resource Manager (менеджер ресурсов): загружает ресурсы с гибкого диска, когда их запрашивает виртуальная машина.
* Sound/Music mixer (микшер звука/музыки): микширует шумы при запросе ВМ.
* Renderer (рендерер): считывает и рендерит вершины по запросу ВМ. Считывает вершины из сегментов памяти.
**Интересный факт:** сегмент памяти палитр на самом деле содержит несколько палитр, используемых для красивых эффектов постепенного изменения цвета.
При запуске исполняемый файл устанавливает значение «0» для программного счётчика потока виртуальной машины (`0x00`) и начинает интерпретирование. После этого всё управляется байт-кодом.
Объяснение процесса визуализации
--------------------------------
На предыдущей схеме показаны три буфера кадров (framebuffer). Два нужны, потому что Another World реализует [двойную буферизацию](http://en.wikipedia.org/wiki/Multiple_buffering#Double_buffering_in_computer_graphics) программно, а третий используется как умная оптимизация:
Третий буфер кадра используется только один раз для композитинга фона и сцены, а потом повторно применяет его кадр за кадром с помощью простого `memcpy`:
В этом видео замедлена визуализация легендарного экрана первого уровня Another World, чтобы можно было заметить процесс отрисовки. Всё отрисовывается с помощью полигонов и пиксигонов. Количество перерисовок очень значительное, но поскольку сцена генерируется только один раз, то это не так уж и плохо.
**Интересный факт:** этот знаменитый фон состоит из 981 полигона.
Для визуалиации полной картины я замедлил и отрендерил три буфера кадра и то, что отображается на экране:
Здесь очень чётко видны:
* Двойная буферизация с визуализацией, выполняемой по очереди в переднем/заднем буфере.
* Буфер фона генерируется один раз и хранится в верхнем левом буфере. Затем он копируется в начале каждого кадра.
* Если фон изменяется (например, в случае с остановкой автомобиля), буфер фона обновляется, чтобы сэкономить ещё больше места и времени.
Если вы хотите проанализировать отрисовку подробнее, то вот [полное видео](http://fd.fabiensanglard.net/anotherWorld_code_review/carFull.mov).
Виртуальная машина Another World
--------------------------------
На [странице](http://www.anotherworld.fr/anotherworld_uk/another_world.htm) Эрика Шайи (Eric Chahi) подробно объясняется структура ВМ.
В коде [на github](https://github.com/fabiensanglard/Another-World-Bytecode-Interpreter/blob/master/vm.cpp) можно увидеть, как реализуется каждый код операции. Все их довольно просто понять, за исключением операций визуализации. Хитрость в том, что исходный код сегмента полигонов, в котором должны считываться вершины, встроен с идентификатором кода операции.
Вот несколько скриншотов из редактора байт-кода ВМ (его создал Эрик Шайи и дал ему название «script editor»):
Здесь заметно, как теряется метка: `setvec 21 nag1` устанавливает счётчик инструкций потока 21 на смещение метки «nag1». В байт-коде видно только жёстко заданное смещение.
Случаи использования кодов операций
-----------------------------------
На схемах ниже показан вызов кодов операций виртуальной машиной, который на самом деле является системным вызовом менеджеру ресурсов для загрузки четырёх сегментов памяти. Это обычно случается в начале части игры (вся игра разделена на 10 частей):
На следующей схеме код операции также является системным вызовом рендера, запрашивающим отрисовку и получение вершин. Коды операций визуализации немного более сложны, потому что они содержат указания на адреса, из которых нужно считывать вершины. Выбор целевого буфера кадра — это совершенно независимый код операции:
Примечание: выбор того, откуда рендерер должен считывать вершины (из сегмента кинематических полигонов или из сегмента анимаций), кодируется с помощью opcodeId.
Управление ресурсами
--------------------
Ресурсы идентифицируются уникальным целочисленным идентификатором. При запуске менеджер ресурсов открывает MEMLIST.BIN и получает из него записи следующим образом:
```
typedef struct memEntry_s
{
int bankId;
int offset;
int size;
int unpackedSize;
} memEntry_t;
```
Если ВМ запрашивает resourceId, то менеджер ресурсов:
* Находит его, открывая файл банка (по bankId).
* Пропускает `offset` и считывает `size` байт в ОЗУ.
* Если `size` != `unpackedSize`, то ресурс должен быть распакован.
Немного статистики о сжатии:
```
Общее количество ресурсов: 146
Сжатых : 120
Несжатых : 28
Примечание: 82% ресурсов сжато.
Общий размер (несжатый) : 1820901 байт.
Общий размер (сжатый) : 1236519 байт.
Примечание: экономия при сжатии : 32%.
Total RT_SOUND несжатый размер: 699868 (38% от общего несжатого размера) сжатый размер 585052 (47% пространства на гибком диске) экономия: (16%)
Total RT_MUSIC несжатый размер: 33344 (2% от общего несжатого размера) сжатый размер 3540 (0% пространства на гибком диске) экономия: (89%)
Total RT_POLY_ANIM несжатый размер: 384000 (21% от общего несжатого размера) сжатый размер 106676 (9% пространства на гибком диске) экономия: (72%)
Total RT_PALETTE несжатый размер: 18432 (1% от общего несжатого размера) сжатый размер 11032 (1% пространства на гибком диске) экономия: (40%)
Total RT_BYTECODE несжатый размер: 203546 (11% от общего несжатого размера) сжатый размер 135948 (11% пространства на гибком диске) экономия: (33%)
Total RT_POLY_CINEMATIC несжатый размер: 365960 (20% от общего несжатого размера) сжатый размер 291008 (24% пространства на гибком диске) экономия: (20%)
Примечание: чёртов коэффициент сжатия звука!
Всего файлов банков: 148
Файлов Total RT_SOUND: 103
Файлов Total RT_MUSIC: 3
Файлов Total RT_POLY_ANIM: 12
Файлов Total RT_PALETTE: 9
Файлов Total RT_BYTECODE: 9
Файлов Total RT_POLY_CINEMATIC: 9
```
Я не стал тратить время на обратную разработку алгоритма сжатия. Тот факт, что звук сжался не очень хорошо, навёл меня на мысль, что алгоритм чувствителен к энтропии… поэтому, возможно, это вариация алгоритма Хаффмана?
Из 146 ресурсов 120 сжаты:
* Векторная визуализация плюс сжатие поверх него давали ОГРОМНУЮ выгоду (экономия до 62% места!).
* Сжатие звука очень неэффективно: экономия мала, и ресурсы занимают 47% пространства гибкого диска.
**Интересный факт:** начальная заставка (ресурс [0x1C](http://fabiensanglard.net/anotherWorld_code_review/fullResourceStats.txt)) длительностью 3 минуты занимает после сжатия всего 57 510 байт.
Управление памятью
------------------
Как и во всех играх 90-х во время игрового процесса память не распределялась. При запуске движок игры получал 600 КБ памяти (кто-нибудь ещё помнит 640 КБ базовой памяти DOS?). Эти 600 КБ использовались как стековый распределитель:
Свободная память: менеджер памяти имел возможность освобождать память на один цикл назад ИЛИ освобождать всю память. На практике вся память освобождалась в конце каждой из 10 частей игры.
**Интересный факт:** изначально во всех 600 КБ хранились байт-код и вершины. Но после двух лет генерирования фонов из полигонов/пиксигонов игра по-прежнему была далека от завершения. Для ускорения разработки Эрик Шайи решил внедрить в свою замечательную архитектуру хак (ценой ему стало снижение производительности): менеджер ресурсов может загружать битовое изображение фона с гибкого диска в буфер фона (`void copyToBackgroundBuffer(const uint8 *src);`). Поэтому в конце базовой памяти были зарезервированы 32КБ (320x200/2).
**Интересный факт:** этот хак применили при выпуске Another World под Windows XP в 2005 году. Все фоны были нарисованы вручную и загружались напрямую с жёсткого диска без использования рендерера и его пиксигонов:
Уголок пуриста
--------------
Если вы пурист и хотите играть только в оригинальную версию, то Another World замечательно работает в DosBOX:
Или можно поиграть в версию для Windows XP. Рекомендую купить [Collector's edition](http://www.gog.com/en/gamecard/another_world_15th_anniversary_edition), потому что в ней содержится множество дополнительной информации, в том числе и технические заметки Эрика Шайи:
И ещё кое-что
-------------
Я много работал над кодом, чтобы сделать его проще для понимания. Вот пример того, насколько он стал яснее.
До:
```
void Logic::runScripts() {
for (int i = 0; i < 0x40; ++i) {
if (_scriptPaused[0][i] == 0) {
uint16 n = _scriptSlotsPos[0][i];
if (n != 0xFFFF) {
_scriptPtr.pc = _res->_segCode + n;
_stackPtr = 0;
_scriptHalted = false;
debug(DBG_LOGIC, "Logic::runScripts() i=0x%02X n=0x%02X *p=0x%02X", i, n, *_scriptPtr.pc);
executeScript();
_scriptSlotsPos[0][i] = _scriptPtr.pc - _res->_segCode;
debug(DBG_LOGIC, "Logic::runScripts() i=0x%02X pos=0x%X", i, _scriptSlotsPos[0][i]);
if (_stub->_pi.quit) {
break;
}
}
}
}
}
```
После:
```
void VirtualMachine::hostFrame() {
// Выполнение ВМ для каждого активного потока (один кадр ВМ).
// Неактивные потоки помечаются указателем инструкции потока 0xFFFF (VM_INACTIVE_THREAD).
// Поток должен иметь код операции прерывания, чтобы интерпретатор смог перейти к следующему потоку.
for (int threadId = 0; threadId < VM_NUM_THREADS; threadId++) {
if (!vmIsChannelActive[CURR_STATE][threadId])
continue;
uint16 pcOffset = threadsData[PC_OFFSET][threadId];
if (pcOffset != VM_INACTIVE_THREAD) {
// Установка указателя скрипта в нужное положение.
// pc скрипта используется для выполнения executeThread по порядку
// для получения следующего кода операции.
_scriptPtr.pc = res->segBytecode + pcOffset;
_stackPtr = 0;
gotoNextThread = false;
debug(DBG_VM, "VirtualMachine::hostFrame() i=0x%02X n=0x%02X *p=0x%02X", threadId, n, *_scriptPtr.pc);
executeThread();
//Поскольку .pc будет изменён этой следующей итерацией цикла, нам нужно сохранить его.
threadsData[PC_OFFSET][threadId] = _scriptPtr.pc - res->segBytecode;
debug(DBG_VM, "VirtualMachine::hostFrame() i=0x%02X pos=0x%X", threadId, threadsData[0][threadId]);
if (sys->input.quit) {
break;
}
}
}
}
```
* Я использовал MACROS, чтобы избавиться от запутанных жёстко заданных значений.
* Переименовал переменные.
* Добавил МНОЖЕСТВО комментариев.
[Здесь](https://github.com/fabiensanglard/Another-World-Bytecode-Interpreter) выложен «человекочитаемый» исходный код! Успешного хакинга. | https://habr.com/ru/post/324550/ | null | ru | null |
# Снижение производительности SharePoint при увеличении уникальных Security Scopes на больших списках
Всем привет!
В этой статье мы решили поделиться своими жизненными наблюдениями за проблемой производительности больших списков в SharePoint.
Итак, мы достаточно часто сталкиваемся с ситуациями, когда есть список на портале SharePoint, в котором хранятся и обрабатываются, например, заявки пользователей. Дополнительно всегда возникает желание сделать так, чтобы все заявки хранились в одном месте, с другой стороны — чтобы права на эти элементы были только у пользователя, подавшего заявку, и у группы или групп пользователей, которые участвуют в ее обработке.
Сначала немного терминологии:
[ACL (Access Control List)](http://technet.microsoft.com/en-us/library/cc962007.aspx) – упорядоченный список принципалов, которые определяют права на элемент или группу элементов.
[Security Scopes](http://sharingthepoint.blogspot.ru/2010/09/sharepoint-security-model.html) – набор пар групп или пользователь + ACL.
##### Рекомендации Microsoft
Microsoft [рекомендует](http://technet.microsoft.com/en-us/library/cc262787.aspx) соблюдать достаточно простые правила: избегать количества одновременных Security Scopes более 5 000 на одну библиотеку документов или на один список.
Почему так? Откуда взялось ограничение? Для начала ответим на вопрос, каким образом MS SharePoint обрабатывает запрос к списку.
1. Делает обращение к БД содержимого и читает:
a. Метаданные списка, т.е. определение списков полей и т.п.
b. Computed fields, определения обработчиков событий и много чего еще.
c. Все scope списка (точнее представления).
2. На стороне front-end определяет: в scope попадает пользователь.
3. Вытаскивает уже непосредственно данные.
Такому подходу есть объяснения, и связаны они с поддержкой модели внешних поставщиков членства и ролей в первую очередь (AD, т.е. AD является наиболее широко распространенным поставщиком членства и ролей).
На практике можно видеть, что проблемы начинаются уже с 1000 элементов с уникальными правами.
С помощью [этих](http://reality-tech.com/2012/03/19/clarifying-the-security-scope-limits-in-sharepoint-lists/) SQL-запросов можно посчитать, сколько сейчас у вас Security Scopes:
```
SELECT [SiteId], [ScopeId], [RoleDefWebId], [WebId], [ScopeUrl], [Acl]
FROM [your Content DB].[dbo].[Perms] order by scopeurl
```
An even better query exposes the web URL
```
SELECT [fullurl],perms.[SiteId] , perms.[ScopeId], [RoleDefWebId], [WebId], [ScopeUrl], [Acl]
FROM [dbo].[Perms],[dbo].allwebs
where perms.WebId = allwebs.id
order by scopeurl
```
As an aside, you can see the number of security principals per scope, using this SQL:
```
select COUNT(ra.PrincipalId) as [Count],p.ScopeUrl from RoleAssignment ra with(nolock)
join Perms p with(nolock)
on p.SiteId = ra.SiteId and p.ScopeId = ra.ScopeId
group by p.ScopeUrl
order by p.ScopeUrl desc
```
Как Microsoft предлагает решать проблему:
1. Использовать папки для инкапсуляции прав доступа на группы элементов с похожими правами.
2. Разбивать на разные списки или библиотеки документов и использовать наследованные права.
3. Никогда не выходить за лимит 5 000 уникальных права на листе.
К чему приводит нарушение этих рекомендаций:
1. Снижение производительности на 20% на каждые 1 000 уникальных прав на листе.
2. Программные ошибки при попытках разорвать права на элементе и выдать уникальные.
Для решений на базе MS SharePoint критически важно, чтобы ферма держала нагрузку, и вот почему.
Для разработчика нет поддержки транзакций. И наборы операций вида (создать элемент, разорвать права, выдать на него права в MS SharePoint):
```
var item = list.AddItem(...);
// ...
item.Update();
item.BreakRoleInheritance(false);
item.RoleAssignments.Add(new SPRoleAssignment(...));
```
будут прерываться в неожиданных местах, просто потому что ферма не выдерживает нагрузки (т.е. не из-за логических ошибок).
Понятно, что рекомендации 2 и 3 носят более камерный характер и не решают задачу хранения элементов вместе и уникальных прав, поэтому остановимся на первом как самом действенном способе – использование папок.
##### Наш пример
Для примера возьмем список из реально работающей системы, в которой на текущий момент 132 073 элементов:
В ней 3 590 Security Scopes – выглядит примерно вот так:
Внутри списка 721 папка...:
… на которые выданы права следующим образом:
По данным Google Analytics, среднее время загрузки страницы менее секунды — при уровне посещений именно этого списка за этот период порядка 968 в день, в рабочее время.
##### Наш подход
В соответствии с нашим подходом права раздаются вот так:
```
public static void ProcessItem(SPListItem item, SPFolder folder)
{
var file = item.Web.GetFile(item.UniqueId);
// Внимание не используйте item.File т.к. он во многих случаях будет null
// http://msdn.microsoft.com/ru-ru/library/microsoft.sharepoint.splistitem.file.aspx
file.MoveTo(string.Format("{0}/{1}", folder.Url, item[SPBuiltInFieldId.LinkFilename]));
}
```
Также хочется добавить, что если наборы прав различаются не разрешениями на чтение видимости, а возможностью изменения, можно использовать Event Handler, который будет запрещать изменения.
```
class PermissionEventHandler : SPItemEventReceiver
{
public override void ItemUpdating(SPItemEventProperties properties)
{
var updatingAllowed = CheckUserHasPermission(properties.Web.CurrentUser, properties.ListItem);
// определить может ли пользователь изменять элемент
if (!updatingAllowed)
{
properties.Cancel = true;
properties.ErrorMessage = "Access denied";
}
}
public override void ItemAdding(SPItemEventProperties properties)
{
//...
}
//...
}
```
До изобретения этого подхода нам пришлось в течение 5 лет плотно заниматься SharePoint, съесть немало собак и кактусов. У него есть свои нюансы, но он абсолютно точно работает — опробовано уже на двух порталах.
Как всегда, рады были поделиться опытом! | https://habr.com/ru/post/211735/ | null | ru | null |
# Ускоряем восстановление бэкапов в PostgreSQL
*Мои ощущения от процесса работы*
Недавно я решил заняться ускорением восстановления нашей базы данных в dev-окружении. Как и во многих других проектах, база вначале была небольшой, но со временем значительно выросла. Когда мы начинали, ее размер было всего несколько мегабайт. Теперь упакованная база занимает почти 2 ГБ (несжатая — 30 ГБ ). Мы восстанавливаем dev-окружение в среднем раз в неделю. Старый способ проведения операции перестал нас устраивать, а вовремя подвернувшаяся в Slack-канале картинка “[DB restore foos?](https://xkcd.com/303/)” побудила меня к действию.
Ниже описано, как я ускорял операцию восстановления базы данных.
Простой способ
--------------
Ниже описывается наша первая версия процедуры резервного копирования и восстановления. Мы начали с запуска `pg_dump` и направления его вывода в `gzip`. Для восстановления базы в dev-окружении мы копировали архив с помощью `scp`, распаковывали его, а затем загружали командой `psql`.
```
$ pg_dump db | gzip > dump.gz
real 7m9.882s
user 5m7.383s
sys 2m56.495s
$ gunzip dump.gz
real 2m27.700s
user 1m28.146s
sys 0m41.451s
$ psql db < dump
real 30m4.237s
user 0m21.545s
sys 0m44.331s
```
*Общее время при простом способе: 39 минут 41 секунда (32,5 минуты на восстановление в dev-окружении).*
Такой подход был прост в понимании, элементарен в настройке и отлично работал, пока размер БД не превышал несколько сотен мегабайт. Однако 32,5 минуты на восстановление базы в dev-окружении — это совершенно неприемлемо.
Восстановление и распаковка одной командой
------------------------------------------
Первое, что пришло в голову, — просто направить запакованный файл напрямую в `psql` с помощью [zcat](http://linux.die.net/man/1/zcat), которую можно считать аналогом [cat](http://linux.die.net/man/1/cat) для сжатых файлов. Эта команда распаковывает файл и выводит его в `stdout`, который, в свою очередь, можно направить в `psql`.
```
$ pg_dump db | gzip > dump.gz
real 7m9.882s
user 5m7.383s
sys 2m56.495s
$ zcat dump.gz | psql db
real 26m22.356s
user 1m28.850s
sys 1m47.443s
```
*Общее время: 33 минуты 31 секунда (26,3 минут на восстановление в dev-окружении, что на 20% быстрее).*
Отлично, нам удалось ускорить процесс на 16%, выиграв 20% при восстановлении. Поскольку ввод/вывод был основным ограничивающим фактором, отказавшись от распаковки файла на диск, мы сэкономили более 6 минут. Но мне показалось, что этого недостаточно. Терять на восстановлении базы 26 минут — все равно плохо. Я должен был придумать что-то еще.
Настраиваемый формат
--------------------
Углубившись в [документацию по pg\_dump](http://www.postgresql.org/docs/9.5/static/app-pgdump.html), я обнаружил, что pg\_dump создает простой текстовый SQL-файл. Затем мы сжимаем его gzip-ом, чтобы сделать меньше. У Postgres есть настраиваемый (custom) формат, который по умолчанию использует zlib для сжатия. Я подумал, что можно будет добиться выигрыша в скорости создания бэкапа, сразу упаковывая данные в Postgres вместо направления простого текстового файл в gzip.
Поскольку psql не понимает настраиваемый формат, мне пришлось перейти на [pg\_restore](http://www.postgresql.org/docs/current/static/app-pgrestore.html).
```
$ pg_dump -Fc db > dumpfc.gz
real 6m28.497s
user 5m2.275s
sys 1m16.637s
$ pg_restore -d db dumpfc.gz
real 26m26.511s
user 0m56.824s
sys 0m15.037s
```
*Общее время 32 минуты 54 секунды (26,4 минуты на восстановление в dev-окружении).*
Я оказался прав, считая, что создание бэкапа будет быстрее, если нам не придется направлять вывод в gzip. К сожалению, восстановление из настраиваемого формата на локальной машине не ускоряет процесс. Пришлось придумывать что-нибудь еще.
Распараллеливание
-----------------
Когда я начинаю разбираться с какой-либо проблемой, первым делом читаю документацию и исходный код. У Postgres отличная документация, где в том числе ясно и подробно расписаны опции командной строки. Одна из опций команды pg\_restore определяет количество параллельных потоков, которые запускаются во время выполнения наиболее затратных по времени задач, загрузки данных, создания индексов или ограничений.
Документация по pg\_restore говорит, что лучше начинать с количества потоков, равного количеству ядер. У моей виртуальной машины 4 ядра, но я хотел поэкспериментировать с разными значениями этой опции.
```
$ pg_dump -Fc db > dumpfc.gz
real 6m28.497s
user 5m2.275s
sys 1m16.637s
$ pg_restore -d db -j 2 dumpfc
real 25m39.796s
user 1m30.366s
sys 1m7.032s
```
*Общее время 32 минуты 7 секунд (25,6 минут на восстановление в dev-окружении, что на 3% быстрее, чем однопоточный запуск pg\_restore).*
Хорошо, немного выиграли. Можем ли мы еще ускориться?
```
$ pg_dump -Fc db > dumpfc.gz
real 6m28.497s
user 5m2.275s
sys 1m16.637s
$ pg_restore -d db -j 4 dumpfc.gz
real 22m6.124s
user 0m58.852s
sys 0m34.682s
```
*Общее время 28 минут 34 секунды (22,1 минуты на восстановление в dev-окружении, что на 14% быстрее, чем с двумя потоками).*
Отлично! Четыре потока быстрее двух на 14%. Да данный момент в dev-окружении мы ускорились с 32,5 до 22,1 минуты: время улучшено на 32%!
Я решил выяснить, к чему приведет дальнейшее увеличение количества ядер.
```
$ pg_dump -Fc db > dumpfc.gz
real 6m28.497s
user 5m2.275s
sys 1m16.637s
$ pg_restore -d db -j 8 dumpfc.gz
real 16m49.539s
user 1m1.344s
sys 0m39.522s
```
*Общее время 23 минуты 17 секунд (16,8 на восстановление в dev-окружении, что на 24% быстрее четырех потоков).*
Итак, увеличив количество потоков до удвоенного количества ядер, нам удалось уменьшить время с 22,1 до 16,8 минут. Сейчас мы ускорились на 49%, что просто чудесно.
А еще можно что-нибудь выжать?
```
$ pg_dump -Fc db > dumpfc.gz
real 6m28.497s
user 5m2.275s
sys 1m16.637s
$ pg_restore -d db -j 12 dumpfc.gz
real 16m7.071s
user 0m55.323s
sys 0m36.502s
```
*Общее время 22 минуты 35 секунд (16,1 минуты на восстановление в dev-окружении, что на 4%, чем 8 потоков).*
Указав 12 потоков, мы еще немного ускорились, но CPU виртуальной машины во время восстановления был загружен настолько, что никакие другие действия в системе выполнить было невозможно. В этом вопросе я решил остановиться на 8 потоках (количество ядер \* 2).
Заключение
----------
В итоге нам удалось сократить время почти вдвое: с 30 до 16 минут. **Это экономит нам 72 часа времени восстановления в год** (6 разработчиков на 52 запуска процедуры восстановления на 14 минут). Я очень доволен этими результатами. В будущем планирую заняться восстановлением только данных, а не базы целиком. Посмотрим, насколько это будет быстрее.
Ссылки:
1. Оригинал: [Speeding up Postgres Restores](https://medium.com/g-adventures-technology/speeding-up-postgres-restores-de575149d17a).
2. Вторая часть: [Ускоряем восстановление бэкапов в Postgres](https://habrahabr.ru/company/centosadmin/blog/328058/). | https://habr.com/ru/post/328056/ | null | ru | null |
# Тестирование флеш СХД. Violin 6232 Series Flash Memory Array
Продолжаем тему, начатую в статьях "[Тестирование флеш СХД. Теоретическая часть](http://itg-td.blogspot.com/2014/04/ibm-ramsan-flashsystem-820.html)" и "[Тестирование флеш СХД. IBM RamSan FlashSystem 820"](http://itg-td.blogspot.com/2014/05/ibm-ramsan-flashsystem-820.html). Сегодня мы рассмотрим возможности одной из наиболее «массовых» моделей компании Violin Memory. Стартап, основанный выходцами из [Fusion-io](http://en.wikipedia.org/wiki/Fusion-io "Fusion-io"), стал первопроходцем и духовным лидером идеологии построения систем хранения данных исключительно на основе флеш-памяти. Массив [Violin 6232](http://www.violin-memory.com/products/6000-flash-memory-array/) был выпущен в сентябре 2011 года и пробыл флагманом вплоть до выхода модели 6264 в августе 2013 года.
[](https://habrastorage.org/getpro/habr/post_images/cd8/69d/68b/cd869d68bf2bd03882bfb20b88c43afb.gif)
Нас, как технических специалистов, в большей мере, заинтересовала архитектура массивов Violin Memory, являющаяся их отличительной особенностью и несомненным преимуществом по сравнению с конкурентами. Каждый компонент — это [собственная разработка компании](http://www.violin-memory.com/products/technology-architecture/):
* Собственные flash модули (VIMM);
* Собственная операционная система VMOS, оптимизированная для работы с flash;
* Собственный запатентованный RAID (vRAID), лишенный недостатков стандартных RAID 5,6;
Система без единой точки отказа, где все компоненты продублированы. Где замена компонентов или обновление прошивки ни только не требуют остановки работы, но и не снижают производительности: 4 контроллера, отсутствие внутреннего кэша, запись полными «страйпами», оптимальные алгоритмы «сбора мусора». Такая архитектура позволяет получить высочайшую производительность, минимизировать задержки и побочные явления (Write Cliff), обеспечивает доступность данных уровня 99,9999 и нивелирует потери производительности при возможном выходе компонентов из строя. Богатый, продуманный интерфейс управления гармонично добавляет удобства работы с оборудованием Violin. Многие технологические преимущества обеспечиваются за счет совместной разработки с Toshiba, которая является основным инвестором компании.
**Методика тестирования**
-------------------------
В ходе тестирования решались следующие задачи:
* исследовать процесс деградации производительности СХД при длительной нагрузке на запись (Write Cliff) и чтение;
* исследовать производительность СХД Violin 6232 при различных профилях нагрузки;
* исследование влияния размера блока LUN на производительность.
#### Конфигурация тестового стенда
| |
| --- |
| |
| Рисунок 1. Структурная схема тестового стенда |
Тестовый стенд состоит из сервера, подключенного через FC фабрику четырьмя соединениями 8Gb FC к СХД Violin 6232. Характеристики сервера и массива следующие: Сервер IBM 3630 M4 (7158-AC1); СХД Violin Memory 6232
В качестве дополнительного программного обеспечения на тестовый сервер установлен Symantec Storage Foundation 6.1, реализующий:
* функционал логического менеджера томов (Veritas Volume Manager);
* функционал отказоустойчивого подключения к дисковым массивам (Dynamic Multi Pathing). (Для тестов группы 1 и 2. Для тестов группы 3 используется нативный Linux DMP)
**Посмотреть утомительные подробности и всякие умные слова.**На тестовом сервере выполнены настройки, направленные на снижение латентности дискового ввода-вывода:
* изменен планировщик ввода-вывода с `cfq` на `noop` через присвоение значения noop параметру `/sys/<путь_к_устройству_Symantec_VxVM>/queue/scheduler`
* добавлен параметр в `/etc/sysctl.conf` минимизирующий размер очереди на уровне логического менеджера томов Symantec: `vxvm.vxio.vol_use_rq = 0`;
* увеличен предел одновременных запросов ввода-вывода на устройство до 1024 через присвоение значения 1024 параметру `/sys/<путь_к_устройству_Symantec_VxVM>/queue/nr_requests`
* отключена проверка возможности слияния операций в/в (iomerge) через присвоение значения 1 параметру `/sys/<путь_к_устройству_Symantec_VxVM>/queue/nomerges`
* увеличен размер очереди на FC адаптерах путем добавления в конфигурационный файл `/etc/modprobe.d/modprobe.conf` опции `ql2xmaxqdepth=64 (options qla2xxx ql2xmaxqdepth=64)`;
На СХД выполнены конфигурационные настройки по разбиению дискового пространства: для всех тестов создаётся 8 LUN одинакового объема. Их суммарный объемом покрывает всю полезную емкость дискового массива. Для тестов группы 2 размер блока LUN устанавливается 512B, для тестов группы 3 размер блока LUN устанавливается 4KB. Созданные LUN презентуются тестовому серверу.
#### Программное обеспечение, используемое в процессе тестирования
Для создания синтетической нагрузки (выполнения синтетических тестов) на СХД используется утилита Flexible IO Tester (fio) версии 2.1.4. При всех синтетических тестах используются следующие конфигурационные параметры fio секции [global]:
* thread=0
* direct=1
* group\_reporting=1
* norandommap=1
* time\_based=1
* randrepeat=0
* ramp\_time=10
Для снятия показателей производительности при синтетической нагрузке применяются следующие утилиты:
* iostat, входящая в состав пакета sysstat версии 9.0.4 с ключами `txk`;
* vxstat, входящая в состав Symantec Storage Foundation 6.1 c ключами `svd`;
* vxdmpadm, входящая в состав Symantec Storage Foundation 6.1 c ключами `-q iostat`;
* fio версии 2.1.4, для формирования сводного отчета по каждому профилю нагрузки.
Снятие показателей производительности во время выполнения теста утилитами iostat, vxstat, vxdmpstat производится с интервалом 5с.
### Программа тестирования.
Тестирование состояло из 3-х групп тестов. Тесты выполнялись путем создания синтетической нагрузки программой fio на блоковое устройство (block device), представляющее собой логический том типа «stripe» с расслоением по 8 дискам, размером блока данных — 1MiB, созданный с использованием Veritas Volume Manager или Native Linux LVM (в 3 группе) из 8-ми LUN, презентованных с тестируемой системы.
**Поинтересоваться подробностями**##### Группа 1: Тесты, реализующие длительную нагрузку типа random write с изменением размера блока операций ввода/вывода (в/в).
При создании тестовой нагрузки используются следующие дополнительные параметры программы fio:
* rw=randwrite
* blocksize=4K
* numjobs=64
* iodepth=64
Группа тестов состоит из четырёх тестов, отличающихся суммарным объемом LUN, презентуемых с тестируемой СХД, размером блока операций в/в и направлением в/в (write или read):
* тест на запись, выполняемый на полностью размеченном СХД, — суммарный объем презентуемых LUN равен полезной емкости СХД, длительность теста — 7.5 часов;
* тесты на запись с изменяющимся размером блока (4,32,1024K), выполняемый на полностью размеченном СХД, длительность каждого теста — 4.5 часа. Пауза между тестами — 2 часа.
По результатам тестов на основании данных выводимых командой vxstat формируются графики, совмещающие результаты тестов:
* IOPS как функция времени;
* Latency как функция времени.
Проводится анализ полученной информации и делаются выводы о:
* наличии деградации производительности при длительной нагрузке на запись и на чтение;
* производительности сервисных процессов СХД (Garbage Collection), ограничивающих производительность дискового массива на запись при длительной пиковой нагрузке;
* степени влияния размера блока операций в/в на производительность сервисных процессов СХД;
* объеме пространства, резервируемом на СХД для нивелирования сервисных процессов СХД.
##### Группа 2: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, созданного средствами Symantec Volume Manager (VxVM) при размере блока LUN — 512байт.
В ходе тестирования исследуются следующие типы нагрузок:
* профили нагрузки (изменяемые параметры ПО fio: randomrw, rwmixedread):
1. случайная запись 100%;
2. случайная запись 30%, случайное чтение 70%;
3. случайное чтение 100%.
* размеры блока: 1КБ, 8КБ, 16КБ, 32КБ, 64КБ, 1МБ (изменяемый параметр ПО fio: blocksize);
* способы обработки операций ввода-вывода: синхронный, асинхронный (изменяемый параметр ПО fio: ioengine);
* количество процессов, генерирующих нагрузку: 1, 2, 4, 8, 16, 32, 64, 128, 160, 192 (изменяемый параметр ПО fio: numjobs);
* глубина очереди (для асинхронных операций ввода-вывода): 32, 64 (изменяемый параметр ПО fio: iodepth).
Группа тестов состоит из набора тестов, представляющего собой все возможные комбинации перечисленных выше типов нагрузки. Для нивелирования влияния сервисных процессов СХД (Garbage Collection) на результаты тестов, между тестами реализуется пауза равная отношению объема записанной в ходе теста информации к производительности сервисных процессов СХД (определяется по результатам выполнения 1-ой группы тестов).
По результатам тестов на основании данных, выводимых ПО fio по завершению каждого из тестов, формируются следующие графики для каждой комбинации следующих типов нагрузки: профиля нагрузки, способа обработки операций ввода-вывода, глубины очереди, совмещающие в себе тесты с разными значениями блока ввода-вывода:
* IOPS — как функция от количества процессов, генерирующих нагрузку;
* Bandwidth — как функция от количества процессов, генерирующих нагрузку;
* Latеncy (clat) — как функция от количества процессов, генерирующих нагрузку;
Проводится анализ полученных результатов, делаются выводы о нагрузочных характеристиках дискового массива при latency<1ms.
##### Группа 3: тесты производительности дискового массива при синхронном способе в/в, разных типах нагрузки, исполняемые на уровне блокового устройства, созданного средствами Linux LVM, при размере блока LUN — 4KiB.
Тесты проводятся аналогично тестам группы 2, но исследуется только синхронный способ в/в из-за ограниченного времени тестирования. По окончании каждого теста строятся графики, отображающие разницу в % полученных показателей производительности (iops, latency) от показателей, полученных при тестировании с размером блока LUN 512байт (группа тестов 2). Делаются выводы о влиянии размера блока LUN на производительность дискового массива.
**Результаты тестирования**
---------------------------
##### Группа 1: Тесты, реализующие длительную нагрузку типа random write с изменением размера блока операций ввода/вывода (в/в).
1. При длительной нагрузке на запись в определенный момент времени фиксируется значимая деградация производительности СХД. Падение производительности ожидаемо и является особенностью работы SSD (Write Cliff), связанной с включением процессов Garbage Collection (GC) и ограниченной производительностью обозначенных процессов. Производительность дискового массива, фиксируемую при работающих процессах GC, можно рассматривать как максимальную среднюю производительность дискового массива.
**Графики**
| |
| --- |
| |
| Изменение скорости операций в/в (iops) и задержек (Latency) при длительной записи блоком 4K |
2. Размер блока при длительной нагрузке на запись не влияет на производительность процесса GC. CG работает на скорости порядка 600Mib/s.
3. Разница в значениях максимального времени работы СХД на пиковой производительности, фиксируемой при первом длительном тесте и последующем эквивалентном тесте с блоком 4К, обусловлена не полной заполненностью СХД перед началом тестирования.
**График**
| |
| --- |
| |
| Изменение скорости в/в (iops) при длительной записи блоками 4K, 32K |
4. Максимальное время работы СХД на пиковой производительности значительно отличается при блоке 4K и всех остальных блоках, что с большой вероятностью обусловлено архитектурной оптимизации СХД под обозначенный блок (СХД Violin всегда пишет полными stripe размером 4K, используя конфигурацию flash модулей RAID5(4+P), stripe unit size 1K).
**График и таблица**
| |
| --- |
| |
| Изменение скорости передачи данных (bandwidth) при длительной запись различными размерами блока. |
| |
| --- |
| |
| Зависимость показателей СХД от размера блока при длительной нагрузке на запись. |
##### Группа 2: Тесты производительности дискового массива при разных типах нагрузки, исполняемые на уровне блокового устройства, созданного средствами Symantec Volume Manager (VxVM) при размере блока LUN — 512байт.
**Таблицы производительности блочного устройства.**
| |
| --- |
| |
| Производительность СХД при одном процессе, генерирующем нагрузку (jobs=1) |
| |
| --- |
| |
| Максимальная производительность СХД при задержках меньше 1мс |
| |
| --- |
| |
| Максимальная производительность СХД при различном профиле нагрузки. |
**Графики производительности блочного устройства.** (Все картинки кликабельны)
| | | | |
| --- | --- | --- | --- |
| | Синхронным способом в/в | Асинхронным способом в/в с глубиной очереди 32 | Асинхронным способом в/в с глубиной очереди 64 |
| При случайном чтении |
|
|
|
| При случайной записи |
|
|
|
| При смешанной нагрузке (70% чтение, 30% запись) |
|
|
|
* Получена приблизительно одинаковая производительность массива на чтение и запись.
* Не удалось получить заявленную производителем производительность на операциях чтения (заявляется максимально 500 000IOPS).
* При смешанном вводе-выводе массив показывает производительность меньшую, чем отдельно при записи и чтении практически при любом профиле ввода-вывода.
* Фиксируется значимое снижение производительности при блоке 8K на смешенном профиле нагрузки при увеличении количества потоков ввода-вывода. (Причина обнаруженного феномена на текущий момент не понятна).
#### Максимально зафиксированные параметры производительности для Violin 6232
Запись:
* 307000 IOPS при latency 0.8ms (блок 4KB async qd32)
* Bandwidth: 2224МБ/c для больших блоков
Чтение:
* 256000 IOPS при latency 0,7ms (блок 4KB sync);
* 300000 IOPS при latency 6,7ms (блок 4KB async qd 32);
* Bandwidth: 2750МБ/с для средних блоков (16-32K).
Смешанная нагрузка (70/30 rw)
* 256000 IOPS при latency 0.7ms (блок 4KB sync);
* 305000 IOPS при latency 6,7ms (блок 4KB async qd 64);
* Bandwidth 2700МБ/с для средних блоков (16-32K)
Минимально зафиксированная latency:
* При записи – 0,146ms для блока 4K jobs=1
* При чтении — 0,21ms для блока 4K jobs=1
##### Группа 3: тесты производительности дискового массива при синхронном способе в/в, разных типах нагрузки, исполняемые на уровне блокового устройства, созданного средствами Linux LVM при размере блока LUN — 4KiB.
**Графики** (Все картинки кликабельны)
| |
| --- |
| |
| Разница IOPS и Latency между устройством с размером блока LUN 4КБ и 512Б при случайном чтении (показатели при размере блока LUN = 512Б приняты за 0) |
| |
| --- |
| |
| Разница IOPS и Latency между устройством с размером блока LUN 4КБ и 512Б при случайной записи (показатели при размере блока LUN = 512Б приняты за 0) |
| |
| --- |
| |
| Разница IOPS и Latency между устройством с размером блока LUN 4КБ и 512Б при смешанной нагрузке (70/30 r/w)(показатели при размере блока LUN = 512Б приняты за 0) |
1. Влияние размера блока LUN на производительность при количестве jobs до 64 отсутствует.
2. При jobs > 64 на операциях записи наблюдается увеличение производительности до 20% по сравнению с размером блока LUN 512B
3. При jobs > 64 на операциях чтения средними и большими блоками наблюдается уменьшение производительности до 10-15%
4. При смешанной нагрузке маленькими и средними блоками (до 32K) массив показывает одинаковую производительность при обоих размерах блока LUN. Но при больших блоках (64К и 1М) производительность улучшается до 50% при использовании блока LUN 4KiB
**Выводы**
----------
В целом, массив произвел впечатление полноценного устройства high-end уровня. Нам удалось получить очень неплохие результаты, тем не менее, осталось впечатление, что весь ресурс системы все же выбрать не удалось. Для создания нагрузки использовался один сервер с двумя процессорами, которые оказались перегружены в процессе тестирования. С большой вероятностью можно сказать, что мы скорее достигли предела возможностей нагрузочного сервера, чем испытываемой системы хранения. Отдельно следует отметить:
* Очень хорошее отношение IOPS/занимаемоеместо в стойке (3U). Что в сравнении с традиционными дисковыми массивами, по сути, является конкурентным решением способным заменить набор шкафов High-End системы на несколько полок Violin при значимом увеличением производительности.
* Наличие Enterprise функционала, такого как Snapshot, может быть полезным для совмещения задач Test/Development и Production в рамках одной дисковой системы .
* Отсутствие penalty на запись при формирование RAID-5 (запись только полными stripe), приводит к лучшим результатам на операциях записи.
* Наличие 4-х RAID-контроллеров и отсутсвие кэша (в SSD он не нужен) гарантирует стабильную производительность при отказах. На традиционных, 2-х контроллерных Mid-range системах, при отказе одного контроллера производительность может проседать в 3-4 раза, т.к. отказ контроллера выключает весь кэш на запись.
P.S. Автор выражает сердечную благодарность Павлу Катасонову, Юрию Ракитину и всем другим сотрудникам компании участвовавшим в подготовке данного материала. | https://habr.com/ru/post/231057/ | null | ru | null |
# Квантификаторы в регулярных выражениях
Регулярные выражения — это арифметика для алгоритмов. Они доступны во многих языках программирования, редакторах и настройках приложений. Как и сложение с умножением они просты в использовании.
Но для правильного и эффективного использования regexp-ов нужно понимание того, как они работают. Я постараюсь описать принцип работы регулярных выражений, покажу в каких случаях бывают проблемы и как их решать.
В продолжение [общих советов](http://habrahabr.ru/blogs/regex/67158/).
Не хочу писать банальное описание метасимволов или какой-то справочник. Я хочу показать те грабли, которые мне памятны. Наметить путь по ним к самовыражению через регулярные структуры. И попробовать передать некий способ мышления, естественным образом порождающий эффективные регэкспы.
Я повторюсь, но научиться можно только на собственном опыте. Поэтому, если Вы не написали хотя бы десяток, лучше сотню регэкспов, думаю что стоит пока просто почитать документацию или книжки и экспериментировать.
Для отличия и удобства я несколько раскрасил регулярные выражения, встречающиеся в тексте. Синим — символы, зеленым — квантификаторы, серым — скобки и прочие служебные символы, каштановым — метасимволы, красным — точку ( что-бы не потерялась ) и ограничивающие регулярное выражение слэши.
### Немного теории
Не буду формалистом и попробую описать теоретическую основу простыми словами. Желающие могут найти точные формулировки в [wiki](http://ru.wikipedia.org/wiki/Регулярное_выражение).
Регулярные выражения, помимо алфавита, имеют три свойства:1. ##### сцепление, когда два выражения a и b могут, сцепившись, образовать выражение ab
Другими словами, сначала выполняется выражение а, потом, на оставшейся строке, выражение b. Можно сказать что между ними как условиями, логическое И.
В применении это дает нам очень простой и основной метод: делим строку для поиска на последовательные части и для каждой строим свое выражение, а потом «сцепляем» — просто пишем их подряд.
2. ##### чередование, когда два выражения a и b могут, с помощью оператора | образовывать выражение a|b
Разница со сцеплением в том что между условиями a и b стоит логические ИЛИ и для проверки используется одна и та-же строка.
В применении это позволяет нам легко добавлять простые ветвления в готовое выражение.
3. ##### замыкание, когда для выражения a\* проверяются все варианты (пусто),a,aa,aaa,… и так далее
Другими словами, мы рекурсивно пытаемся применить выражение а, пока оно применяется. В реальности парсер так и делает и это порождает проблемы с производительностью, но об этом ниже, когда, собственно, будем рассматривать работу квантификаторов.
При своей простоте, регулярные выражения позволяет алгоритмизировать существенную часть задач, в первую очередь поиск текста. Надо лишь обозначить то что ищем, добавить варианты и зациклить если необходимо. Понятно?
Отлично! Но легко сделать выражение, которое совпадет, с нужным нам шаблоном. Труднее его модифицировать так, что бы он не совпал с тем что нам не нужно.
В этом месте менторское описание должно закончиться словами: Эффективность к тебе со временем придет, юный падаван ...
### Ничего подобного !
Говорят что регулярные выражения появились как воплощение работы нервной системы. Не знаю насколько это правда, но достаточно легко научиться думать регулярными выражениями. Ключ к этому — иерархия. Представьте себе не просто варианты строк, которые надо найти, а структуру, состоящую из более мелких элементов. И тогда регулярка — просто описание этой структуры.
Сначала надо поговорить о символах. Символ — это некая минимальная составляющая нашей структуры, но надо различать голый текст, состоящий из **литеральных** символов и, например, строку в каком-нибудь языке программирования: пусть строка ограничивается кавычками и для указания кавычек внутри строки используется экранирование ( escape ) с помощью специального символа или повторением. Также, обычно, есть возможность указывать непечатаемые символы — перевод строки или табуляция. Все это расширяет литеральные символы до символа строки. И если надо разобрать строку, в первую очередь надо подняться на эту ступеньку — надо описать символы нашего алфавита.
Пусть у нас экранирующий символ — "\". Тогда символы строки это чередование обычных символов "." и экранированных "\.". Тут надо сказать что в чередовании выражения не равноправны, а имеют приоритет в порядке следования. То есть, если мы напишем .|\., то точка, как любой символ будет находится всегда, поэтому поставим ее последней: \.|.. Замкнув все это с помощью квантификатора \* и сцепив с кавычкой в начале и в конце мы получим выражение для описания строки. Но тут есть еще один подводный камень — точка в подвыражении символа. Хотя, учитывая приоритеты, точка стоит последней, парсер каждый раз, видя варианты, ставить так называемые точки возврата. К которым может вернуться, если последующее выражение не выполнится. В каком-то тексте кавычки могут быть непарными и, не найдя последнюю, парсер будет откручивать по точкам возврата выражение назад. Если же у нас встретится экранированная кавычка, то парсер ее разложит на два символа и довольный этим неправильным результатом продолжит работу. Из этого можно сделать простой вывод, верный для всех регулярок, — **неопределенность надо устранять**. В нашем случае это просто — вместо точки поставим символьный класс [^\"], убрав все неоднозначности.
Не забудьте что в строке которую вы отдаете компилятору или интерпретатору, некоторые символы также надо экранировать, поэтому в тексте программы это будет выглядеть так
> `/"(\\.|[^\\"])\*"/`
### Составляем выражение
Поняв и описав символы, можно подниматься по иерархии выше, используя сцепление или замыкание и, если надо варианты, чередование.
Например, для описания URL, мы должны сначала разбить его на части: протокол, иногда пользователь и пароль, имя сервера, путь к файлу и так далее. После чего нужно разделить части на элементарные куски, например имя сервера — это слова, разделенные точкой, при этом эти слова имеют свои разрешенные символы и самым правым должен быть tld. Для каждой элементарной части нужно аккуратно прописать свой алфавит символов и сцеплять их в выражение для структуры следующего уровня.
Например имя состоит из [-a-z0-9]+, разделенных точкой [-a-z0-9]+\.[a-z]{2,4} ( в более строгом случае можно в правой части описать разрешенные tld: com|net|org|ru|info ), при этом в левой части могут быть несколько уровней имен через точку ([-a-z0-9]+\.)+[a-z]{2,4}
Протокол может быть https?:// или ftp://, после которого могут идти имя \w+ и пароль .+?
вместе
> `/(https?:\/\/|ftp:\/\/(\w+(:.+?)?@)?)([-a-z0-9]+\.)+[a-z]{2,4}/`
и так далее...
в общем легко описывать формальные структуры, поскольку всю работу уже сделали до нас, четко указав поля, разделители и предусмотрев вариативность. Главное не ошибиться нужным символом :)
Хочу повторить заезжую истину — **преждевременная оптимизация вредна**. Не ленитесь и повторите блок чередованием, если нужен несколько другой вариант. Опциональные или повторяющиеся части должны иметь «якоря» — литеральные символы в начале или в конце. Если что-то добавляете — не ленитесь — разберите структуру снова, добавьте нужное и соберите обратно. Непонятная мешанина внутри выражения — верный путь к ошибке. Проверьте как на покрытие нужных так и на игнорирование ненужных вариантов. И только потом оптимизируйте. А лучше не надо — хорошо структурирование выражение и работает быстро, хотя иногда выглядит страшно и на первый взгляд запутанно.
### Жадные (greedy) квантификаторы
В современных регулярных выражениях есть несколько разновидностей замыканий. *Stephen Cole Kleene*, который ввел это понятие, описал два таких: \* и +. Как было описано выше, поведение их «жадное» — они пытаются покрыть все что можно — до конца строки. Но дальше в нашем выражении идет следующий оператор или символ, а мы уже в конце строки. Тут парсер откручивает наш квантификатор обратно по точкам возврата, пока не выполнится условие последующего подвыражения.
Очевидно что подобное поведение легко порождает проблемы с производительностью. Вот время выполнения для нескольких вариантов:
Последний случай с двумя звёздочками на самом деле отрабатывает на порядок медленнее. Это связано с особенностью работы парсера. Как было сказано, выражение «любой символ много раз» выполняется дословно и фактически парсер сначала покрывает этим выражением всю строку, сохраняя на каждом символе точку возврата. Увидев что наше выражение не закончено, парсер возвращается обратно, пока не найдет совпадение. Наличие двух звездочек увеличивает количество точек возврата на порядок, трех — еще на порядок. Легко увидеть что такой путь может «простое выражение» сделать ощутимо медленным.
но есть несколько способов улучшить эффективность:* ##### интервал со стоп-символом
Например, если мы ищем теги от '<' до '>', то можно указать интервал вместо произвольного символа:
> `/<[^>]+>/`
Парсер остановится, увидев символ вне диапазона и сразу же сработает последующий литеральный символ '>'.
* ##### использовать интервал повторений {min,max}
Хорошо работает, если нам известно сколько должно быть символов, например при первичной проверке uid или md5 сигнатур.
### Нежадные (non-greedy) или ленивые (lazy) квантификаторы
В свое время Perl ввёл это понятие. Такой квантификатор действует наоборот — покрывает минимальный набор символов и расширяет его, если последующие сцепленные выражения не выполняются.
С точки зрения производительности очень хорошо работает для вложенных необязательных выражений, но также как и жадный квантификатор может вызвать существенное замедление, поскольку если в хорошем случае ( когда наше выражение выполняется ) все более-менее быстро, то в плохом случае парсер пытается увеличить покрытие для нежадного квантификатора, пока не дойдет до очевидного конца. Что-бы избежать этого, желательно максимально сузить покрываемые символы интервалом и сразу после него поставить простое выражение — фиксированные символы, например.
Как я уже сказал, выражения с ленивыми квантификаторами покрывают минимально возможную подстроку. Это позволяет просто избежать проблем с излишним покрытием, например
> `/\(.+\)/`
подгребет под себя все от первой встретившейся до последней скобки в тексте. В тоже время
> `/\(.+?\)/`
остановится на первой закрывающей скобке.
Почему не стоп-символ? Потому что не всегда его можно применить. Следующий символ может сложным или быть частью подвыражения с перечислением или вообще нельзя четко описать границу. Также ленивый квантификатор эффективен, если мы знаем что будет немного символов. Очень рекомендую ставить ленивые + и \* после точки, которая соответствует произвольному символу, иначе парсер прогуляется до конца строки. Но помните что парсеру надо указать где остановиться.
Сравним скорость:
У ленивых «звездочек» и «плюсов» есть еще один недостаток — они могут и очень часто покрывают слишком мало символов, если границу не обозначить последующим подвыражением. Например, если вы разбираете слова так: `\w+?` то можете обнаружить что без последующего литерального символа ( в конце большого выражения ), это комбинация покроет только одну букву и в данном случае эффективнее «жадный» вариант. Также жадные эффективнее если четко известно что следующим будет другой символ \w+ так можно описать слово или параметр, ленивый тут просто менее эффективный.
Кроме ленивых и жадных есть еще ### супер жадные или ревнивые квантификаторы
Их существенное отличие в том что они не откатываются обратно. Это свойство можно использовать, если есть неоднозначность. Правда, повторюсь, неоднозначность — враг эффективного регулярного выражения. Я лично не использовал их, хотя имею мнение что в хорошее выражение вместо жадного можно спокойно поставить ревнивый. Хороший, хоть и не очень жизненный пример применения ревнивого квантификатора [подробно описан тут](http://habrahabr.ru/blogs/regex/55863/).
### В заключение
покажу несколько плохих случаев из кода:
(\w\*)\* — внешняя жадная звездочка работать просто не будет.
Самое замечательное что некоторые парсеры просто проигнорируют такое выражение — сработает защита на зацикливание.
([^>]+)\* — почти тоже самое.
По смыслу это внутренности тега после его имени и они не обязательные. Так что + меняем на \* и внешнюю просто убираем
.\*;?.\*?\r? — после жадной \* стоит целый ряд необязательных символов.
Они никогда не будут иметь значения, поскольку необязательные выражения для парсера не повод вернуться и уменьшить покрытие жадного квантификатора. Скорее всего жертва изменений. После первой звезды остальное можно просто убрать.
\.([a-z\.]{2,6}) — разделитель внутри структуры.
Просто скажу что это покроет например несколько точек вместо tld, как задумывалось.
### В продолжении
* метасимволы \s \d \w \b и unicode
* тонкости multiline
* позиционирование и предпросмотр
* … и прочая | https://habr.com/ru/post/68345/ | null | ru | null |
# Глубокое обучение и Raspberry PI
> «Что у нас есть?» — спросил горбоносый поворачиваясь.
>
> «Алдан-3», — сказал бородатый.
>
> «Богатая машина, — сказал я.”[1]
Недавно я решил заняться изучением глубокого обучения. На работе мне выдали новую карточку с поддержкой CUDA и шеф выразил пожелание что эта вершина инженерной мысли позволит нашей лаборатории сделать рывок вперёд, ну или по крайней мере, не отстать от массы конкурентов. У меня уже был некоторый опыт общения с Tensor Flow, но в этот раз я решил попробовать Torch. Привлекало что он написан на языке Lua и C, является достаточно легковесным и легко расширяемым через FFI. И ещё мне не нравится Python.
Недавно на Хабрахабр я наткнулся на статью, в процессе обсуждения которой я вспомнил что где-то в тумбочке у меня пилится Raspberry Pi, модель B+ и мне захотелось посмотреть — а смогу ли я поднять на ней torch и запустить что-нибудь несложное.
Естественно первым делом я захотел посмотреть как на моем десктопе с новой карточкой GPU будет тренироваться alexnet и другие известные сети. На гитхабе есть небольшой проект в котором несколько популярных сетей реализованы на [Torch](https://github.com/soumith/imagenet-multiGPU.torch.git). Поигравшись с ними, я перешёл на решение своих задач, но про них я тут говорить не буду.
А теперь переходим к малинке (Raspberry PI модель B+).
Установка
---------
Копируем инсталлятор torch на [малинку](http://torch.ch/docs/getting-started.html#_):
```
apt-get install git-core
git clone https://github.com/torch/distro.git ~/torch --recursive
```
Первым делом, я решил что мне не хочется ждать пока стандартный установщик Torch скомпилирует OpenBLAS и установит QT со всеми зависимостями, поэтому я решил проделать это вручную:
```
apt-get install -y build-essential gcc g++ curl cmake libreadline-dev libjpeg-dev libpng-dev ncurses-dev imagemagick libzmq3-dev gfortran libopenblas-base libopenblas-dev
```
Запускаем компиляцию torch:
```
cd ~/torch;
./install.sh
```
У меня компиляция всего занимает примерно час.
> — А что это там у вас за лампа? — подозрительно спросил Фарфуркис. [1]
И тут нас ждёт первый облом: создатели torch: не предполагали что его будут компилировать на архитектуре arm, но без поддержки NEON:
```
[ 6%] Building C object lib/TH/CMakeFiles/TH.dir/THVector.c.o
In file included from /home/pi/torch/pkg/torch/lib/TH/THVector.c:2:0:
/home/pi/torch/pkg/torch/lib/TH/generic/THVectorDispatch.c: In function ‘THByteVector_vectorDispatchInit’:
/home/pi/torch/pkg/torch/lib/TH/generic/simd/simd.h:64:3: error: impossible constraint in ‘asm’
asm volatile ( "cpuid\n\t"
```
Пришлось [пофиксить это дело](https://github.com/torch/torch7/pull/868). И после этого, всё заработало! Если вам лень делать это всё самому и хочется быстро попробовать пример, я сделал архив с пред-компилированным torch для Raspberry PI -B (без поддержки NEON): <https://github.com/vfonov/deep-pi/releases/download/v1/torch_intstall_raspbian_arm6l_20161218.tar.gz>, распаковывается в /home/pi
Тестирование
------------
Для проверки я решил посмотреть скорость тренировки распознавания рукописных цифр [MNIST](http://yann.lecun.com/exdb/mnist/), соответствующий пример есть в [наборе демок](https://github.com/torch/demos) для Torch:
```
th train-on-mnist.lua
set nb of threads to 4
using model:
nn.Sequential {
[input -> (1) -> (2) -> (3) -> (4) -> (5) -> (6) -> (7) -> (8) -> (9) -> (10) -> output]
(1): nn.SpatialConvolutionMM(1 -> 32, 5x5)
(2): nn.Tanh
(3): nn.SpatialMaxPooling(3x3, 3,3, 1,1)
(4): nn.SpatialConvolutionMM(32 -> 64, 5x5)
(5): nn.Tanh
(6): nn.SpatialMaxPooling(2x2, 2,2)
(7): nn.Reshape(576)
(8): nn.Linear(576 -> 200)
(9): nn.Tanh
(10): nn.Linear(200 -> 10)
}
only using 2000 samples to train quickly (use flag -full to use 60000 samples)
loading only 2000 examples
done
loading only 1000 examples
done
on training set:
online epoch # 1 [batchSize = 10]
[===================>.................... 471/2000 ....................................] ETA: 2m20s | Step: 92ms
```
В общем неплохо, для сравнения — на десктопе с i5-4590 CPU @ 3.30GHz, без использования GPU:
```
[=======================>................ 571/2000 ....................................] ETA: 27s613ms | Step: 19ms
```
Т.е в этом примере малинка работает примерно в 5 раз медленнее чем современный десктоп.
Распознавания изображений
-------------------------
> одушевлённый теперь «Алдан» иногда печатал на выходе: «Думаю. Прошу не мешать» [1]
Теперь настал черёд заставить малинку распознавать изображения с помощью натренированной googlenet. Тут меня ждал второй подвох: в Alexnet такое огромное количество параметров, что памяти малинки уже не хватает. Но тут на выручку приходит squeezenet и Network-in-Network, автор последней даже сделал натренерованную [модель в формате для torch](https://gist.github.com/szagoruyko/0f5b4c5e2d2b18472854).
Для начала надо преобразовать модель так чтобы её можно было использовать на архитектуре ARM (тренировать на Raspberry PI не стоит — результаты будут готовы лет через сто).
На десктопе надо загрузить модель в бинарном формате torch, и записать в формате ‘ascii’, потом на малинке — преобразовать обратно:
Desktop:
```
model=torch.load(‘blah.t7’)
torch.save(‘blah_ascii.t7’,model,’ascii’)
```
Raspberry PI:
```
model=torch.load(‘blah_ascii.t7’,’ascii’)
torch.save(‘blah_arm.t7’,model)
```
Версию для arm можно загрузить [тут](https://github.com/vfonov/deep-pi/releases/download/v1/nin_bn_final_arm.t7).
Я сделал маленький скриптик для проверки работоспособности на малинке:
Полный текст [тут](https://github.com/vfonov/deep-pi/blob/master/test_single.lua).
```
...
local m=torch.load(prefix..'nin_bn_final_arm.t7')
...
local input=image.load(prefix.."n07579787_ILSVRC2012_val_00049211.JPEG")
...
local output=model:forward(cropped)
...
```
И вуаля, запускаем с изображением из тестового набора [ImageNET](http://image-net.org/download-images):
```
>th test_single.lua n07579787_ILSVRC2012_val_00049211.JPEG
loading model:0.57sec
Running neural net:13.46sec
25.3%: n07579787: plate
13.8%: n07873807: pizza, pizza pie
8.8%: n04263257: soup bowl
8.0%: n07590611: hot pot, hotpot
7.2%: n07831146: carbonara
```
T.e за 14 сек малинка удачно справилась с процедурой распознавания образов!
Настало время сделать пример поинтересней: приделываем интерфейс к камере из пакета camera и веб интерфейс из пакета display, и у нас получается интерактивная машина, раз в 14 секунд объявляющая миру что она видит. Надо только установить пакет для работы с камерой (luarocks install camera) и для визуализации через веб-интерфейс (luarocks install display).
Полный текст [тут](https://github.com/vfonov/deep-pi/blob/master/camera_interface.lua).
```
…
-- подцепляем камеру
local cam = image.Camera {idx=0,width=iW,height=iH}
...
local frame = cam:forward()
local cropped = image.crop(frame, w1, h1, w1+oW, h1+oH) -- center patch
…
-- отправляем кадр зрителю
display_sample_in.win=display.image(cropped,display_sample_in)
…
-- прогоняем его через нейросеть
local output=model:forward(cropped)
…
-- отправляем описание - чего увидели
display_output.win=display.text(out_text,display_output)
```
Перед запуском надо запустить демона из пакета display: `nohup th -ldisplay.start 8000 0.0.0.0 &`
### Испытания
Тестовая установка:
Результат:
Заключение
----------
Итак у нас получилась недорогая машинка для распознавания образов, которой вы можете порадовать ваших друзей во время новогодних праздников. Естественно, задача классификации изображения может быть заменена на что-то более продуктивное, например можно легко сделать систему для идентификации человека по физиономии, несколько примеров есть [тут](http://torch.ch/blog/2016/06/01/deep-fun-with-opencv.html) или можно [идентифицировать фигуры людей](https://github.com/torch/demos/tree/master/person-detector) на камере наблюдения за вашим огородом.
Для оптимизации производительности можно попробовать использовать [nnpack](https://github.com/szagoruyko/nnpack.torch), или даже сделать интерфейс к векторному ускорителю встроенному в процессор малинки как [тут](https://github.com/jetpacapp/DeepBeliefSDK).
Примечания:
-----------
Цитаты из "Понедельник начинается в субботу" и "Сказка о тройке" А. и Б. Стругацких.
Описание процедуры на английском и репозиторий со всеми исходниками находится на [гитхабе](https://github.com/vfonov/deep-pi). | https://habr.com/ru/post/400141/ | null | ru | null |
# Понимаем декораторы в Python'e, шаг за шагом. Шаг 1
*###### На Хабре множество раз обсуждалась тема декораторов, однако, на мой взгляд, данная статья (выросшая из одного [вопроса на stackoverflow](http://stackoverflow.com/questions/739654/understanding-python-decorators)) описывает данную тему наиболее понятно и, что немаловажно, является «пошаговым руководством» по использованию декораторов, позволяющим новичку овладеть этой техникой сразу на достойном уровне.*
#### Итак, что же такое «декоратор»?
Впереди достаточно длинная статья, так что, если кто-то спешит — вот пример того, как работают декораторы:
```
def makebold(fn):
def wrapped():
return "**" + fn() + "**"
return wrapped
def makeitalic(fn):
def wrapped():
return "*" + fn() + "*"
return wrapped
@makebold
@makeitalic
def hello():
return "hello habr"
print hello() ## выведет ***hello habr***
```
Те же из вас, кто готов потратить немного времени, приглашаются прочесть длиииинный пост.
##### Функции в Python'e являются объектами
Для того, чтобы понять, как работают декораторы, в первую очередь следует осознать, что в Python'е функции — это тоже объекты.
Давайте посмотрим, что из этого следует:
```
def shout(word="да"):
return word.capitalize()+"!"
print shout()
# выведет: 'Да!'
# Так как функция - это объект, вы связать её с переменнной,
# как и любой другой объект
scream = shout
# Заметьте, что мы не используем скобок: мы НЕ вызываем функцию "shout",
# мы связываем её с переменной "scream". Это означает, что теперь мы
# можем вызывать "shout" через "scream":
print scream()
# выведет: 'Да!'
# Более того, это значит, что мы можем удалить "shout", и функция всё ещё
# будет доступна через переменную "scream"
del shout
try:
print shout()
except NameError, e:
print e
#выведет: "name 'shout' is not defined"
print scream()
# выведет: 'Да!'
```
Запомним этот факт, скоро мы к нему вернёмся, но кроме того, стоит понимать, что функция в Python'e может быть определена… внутри другой функции!
```
def talk():
# Внутри определения функции "talk" мы можем определить другую...
def whisper(word="да"):
return word.lower()+"...";
# ... и сразу же её использовать!
print whisper()
# Теперь, КАЖДЫЙ РАЗ при вызове "talk", внутри неё определяется а затем
# и вызывается функция "whisper".
talk()
# выведет: "да..."
# Но вне функции "talk" НЕ существует никакой функции "whisper":
try:
print whisper()
except NameError, e:
print e
#выведет : "name 'whisper' is not defined"
```
##### Ссылки на функции
Ну что, вы всё ещё здесь?:)
Теперь мы знаем, что функции являются полноправными объектами, а значит:
* могут быть связаны с переменной;
* могут быть определены одна внутри другой.
Что ж, а это значит, что одна функция может вернуть другую функцию!
Давайте посмотрим:
```
def getTalk(type="shout"):
# Мы определяем функции прямо здесь
def shout(word="да"):
return word.capitalize()+"!"
def whisper(word="да") :
return word.lower()+"...";
# Затем возвращаем необходимую
if type == "shout":
# Заметьте, что мы НЕ используем "()", нам нужно не вызвать функцию,
# а вернуть объект функции
return shout
else:
return whisper
# Как использовать это непонятное нечто?
# Возьмём функцию и свяжем её с переменной
talk = getTalk()
# Как мы можем видеть, "talk" теперь - объект "function":
print talk
# выведет:
# Который можно вызывать, как и функцию, определённую "обычным образом":
print talk()
# Если нам захочется - можно вызвать её напрямую из возвращаемого значения:
print getTalk("whisper")()
# выведет: да...
```
Подождите, раз мы можем возвращать функцию, значит, мы можем и передавать её другой функции, как параметр:
```
def doSomethingBefore(func):
print "Я делаю что-то ещё, перед тем как вызвать функцию, которую ты мне передал"
print func()
doSomethingBefore(scream)
#выведет:
# Я делаю что-то ещё, перед тем как вызвать функцию, которую ты мне передал
# Да!
```
Ну что, теперь у нас есть все необходимые знания для того, чтобы понять, как работают декораторы.
Как вы могли догадаться, декораторы — это, по сути, просто своеобразные «обёртки», которые **дают нам возможность делать что-либо до и после того, что сделает декорируемая функция, не изменяя её.**
##### Создадим свой декоратор «вручную»
```
# Декоратор - это функция, ожидающая ДРУГУЮ функцию в качестве параметра
def my_shiny_new_decorator(a_function_to_decorate):
# Внутри себя декоратор определяет функцию-"обёртку".
# Она будет (что бы вы думали?..) обёрнута вокруг декорируемой,
# получая возможность исполнять произвольный код до и после неё.
def the_wrapper_around_the_original_function():
# Поместим здесь код, который мы хотим запускать ДО вызова
# оригинальной функции
print "Я - код, который отработает до вызова функции"
# ВЫЗОВЕМ саму декорируемую функцию
a_function_to_decorate()
# А здесь поместим код, который мы хотим запускать ПОСЛЕ вызова
# оригинальной функции
print "А я - код, срабатывающий после"
# На данный момент функция "a_function_to_decorate" НЕ ВЫЗЫВАЛАСЬ НИ РАЗУ
# Теперь, вернём функцию-обёртку, которая содержит в себе
# декорируемую функцию, и код, который необходимо выполнить до и после.
# Всё просто!
return the_wrapper_around_the_original_function
# Представим теперь, что у нас есть функция, которую мы не планируем больше трогать.
def a_stand_alone_function():
print "Я простая одинокая функция, ты ведь не посмеешь меня изменять?.."
a_stand_alone_function()
# выведет: Я простая одинокая функция, ты ведь не посмеешь меня изменять?..
# Однако, чтобы изменить её поведение, мы можем декорировать её, то есть
# Просто передать декоратору, который обернет исходную функцию в любой код,
# который нам потребуется, и вернёт новую, готовую к использованию функцию:
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#выведет:
# Я - код, который отработает до вызова функции
# Я простая одинокая функция, ты ведь не посмеешь меня изменять?..
# А я - код, срабатывающий после
```
Наверное, теперь мы бы хотели, чтобы каждый раз, во время вызова *a\_stand\_alone\_function*, вместо неё вызывалась *a\_stand\_alone\_function**\_decorated***. Нет ничего проще, просто перезапишем *a\_stand\_alone\_function* функцией, которую нам вернул *my\_shiny\_new\_decorator*:
```
a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#выведет:
# Я - код, который отработает до вызова функции
# Я простая одинокая функция, ты ведь не посмеешь меня изменять?..
# А я - код, срабатывающий после
```
Вы ведь уже догадались, что это ровно тоже самое, что делают @декораторы.:)
##### Разрушаем ореол таинственности вокруг декораторов
Вот так можно было записать предыдущий пример, используя синтаксис декораторов:
```
@my_shiny_new_decorator
def another_stand_alone_function():
print "Оставь меня в покое"
another_stand_alone_function()
#выведет:
# Я - код, который отработает до вызова функции
# Оставь меня в покое
# А я - код, срабатывающий после
```
Да, всё действительно так просто! [decorator](http://habrahabr.ru/users/decorator/) — просто [синтаксический сахар](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%81%D0%B0%D1%85%D0%B0%D1%80) для конструкций вида:
```
another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)
```
Декораторы — это просто pythonic-реализация [паттерна проектирования «Декоратор»](http://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)). В Python включены некоторые [классические паттерны проектирования](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#.D0.9E.D1.81.D0.BD.D0.BE.D0.B2.D0.BD.D1.8B.D0.B5), такие как рассматриваемые в этой статье декораторы, или привычные любому пайтонисту [итераторы](http://ru.wikipedia.org/wiki/%D0%98%D1%82%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
Конечно, можно вкладывать декораторы друг в друга, например так:
```
def bread(func):
def wrapper():
print ""
func()
print "<\______/>"
return wrapper
def ingredients(func):
def wrapper():
print "#помидоры#"
func()
print "~салат~"
return wrapper
def sandwich(food="--ветчина--"):
print food
sandwich()
#выведет: --ветчина--
sandwich = bread(ingredients(sandwich))
sandwich()
#выведет:
#
# #помидоры#
# --ветчина--
# ~салат~
# <\______/>
```
И используя синтаксис декораторов:
```
@bread
@ingredients
def sandwich(food="--ветчина--"):
print food
sandwich()
#выведет:
#
# #помидоры#
# --ветчина--
# ~салат~
# <\______/>
```
Следует помнить о том, что порядок декорирования ВАЖЕН:
```
@ingredients
@bread
def sandwich(food="--ветчина--"):
print food
sandwich()
#выведет:
# #помидоры#
#
# --ветчина--
# <\______/>
# ~салат~
```
На этом моменте Вы можете счастливо уйти, с осознанием того, что вы поняли, что такое декораторы и с чем их едят.
Для тех же, кто хочет помучать ещё немного свой мозг, завтра будет допереведена вторая часть статьи, посвящённая продвинутому использованию декораторов.
Содержание:
* [Шаг 1. Базовое понимание декораторов](http://habrahabr.ru/post/141411/) *(вы сейчас прочитали эту статью)*
* [Шаг 2. Продвинутое использование декораторов](http://habrahabr.ru/post/141501/)
*Прим. переводчика:
Спасибо за внимание. Буду благодарен любым замечаниям по переводу и оформлению, постараюсь учесть их все во второй части перевода.
UPD: Во второй части будут разобраны такие вопросы, как: передача аргументов декорируемым функциям, декорация методов, декораторы с параметрами и пр.
**UPD2: Выложена [вторая часть статьи.](http://habrahabr.ru/post/141501/)*** | https://habr.com/ru/post/141411/ | null | ru | null |
# ONLYOFFICE Community Server: как баги способствуют возникновению проблем с безопасностью
В наши обзоры ошибок программ с отрытым исходным кодом редко попадают серверные сетевые приложения. Наверное, это связано с их популярностью. Ведь мы стараемся обращать внимание на проекты, которые нам предлагают сами читатели. А серверы часто выполняют очень важные функции, но их деятельность и польза остаётся невидимой для большинства пользователей. Так, чисто случайно, был проверен код ONLYOFFICE Community Server. Получился очень весёлый обзор.
Введение
--------
[ONLYOFFICE Community Server](https://github.com/ONLYOFFICE/CommunityServer) — бесплатная система для совместной работы с открытым исходным кодом, разработанная для управления документами, проектами, взаимодействия с клиентами и электронной переписки в одном месте. На своём [сайте](https://www.onlyoffice.com/) компания подчёркивает безопасность своих решений такими фразами, как "Run your private office with the ONLYOFFICE" и "Secure office and productivity apps". Но какие-либо инструменты для контроля качества кода, видимо, в процессе разработки не используются.
Всё началось с того, что я просматривал исходники нескольких сетевых приложений в поисках вдохновения для воплощения в жизнь одной своей идеи приложения. В фоне работал анализатор [PVS-Studio](https://www.viva64.com/ru/pvs-studio/), и я кидал в общий корпоративный чат смешные ошибки.
Так, несколько примеров ушли в [Twitter](https://twitter.com/Code_Analysis):
Позже представители прокомментировали твит, а ещё позже запостили опровержение проблемы:
Скорее всего, это действительно так. Но и очков качеству проекта это не добавляет. Давайте посмотрим, что там ещё нашлось.
"Мастер" проверки входных данных
--------------------------------
Некоторые подходы разработчиков к проверке входных данных поражают своей оригинальностью.
**Предупреждение 1**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'string.IsNullOrEmpty("password")' is always false. SmtpSettings.cs 104
```
public void SetCredentials(string userName, string password, string domain)
{
if (string.IsNullOrEmpty(userName))
{
throw new ArgumentException("Empty user name.", "userName");
}
if (string.IsNullOrEmpty("password"))
{
throw new ArgumentException("Empty password.", "password");
}
CredentialsUserName = userName;
CredentialsUserPassword = password;
CredentialsDomain = domain;
}
```
Как вы заметили, этот фрагмент кода задаёт тон всей статье. Его можно описать фразой "Код смешной, а ситуация страшная". Наверное, надо сильно устать, чтобы перепутать переменную *password* со строкой *"password"*. Эта ошибка позволяет продолжить выполнение кода с пустым паролем. По словам автора кода, пароль дополнительно проверяется в интерфейсе программы. Но процесс программирования устроен так, что написанные ранее функции часто переиспользуются. Поэтому эта ошибка может проявить себя где угодно в будущем. Всегда помните про важность своевременного выявления ошибок в коде.
**Предупреждение 2**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'String.IsNullOrEmpty("name")' is always false. SendInterceptorSkeleton.cs 36
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'String.IsNullOrEmpty("sendInterceptor")' is always false. SendInterceptorSkeleton.cs 37
```
public SendInterceptorSkeleton(
string name,
....,
Func sendInterceptor)
{
if (String.IsNullOrEmpty("name")) // <=
throw new ArgumentNullException("name");
if (String.IsNullOrEmpty("sendInterceptor")) // <=
throw new ArgumentNullException("sendInterceptor");
method = sendInterceptor;
Name = name;
PreventPlace = preventPlace;
Lifetime = lifetime;
}
```
Внезапно в коде обнаружился целый ряд подобных ошибок. Если сначала было смешно, то сейчас стоит задуматься о причинах написания такого кода. Может это привычка осталась после перехода с другого языка программирования. В C++ часто приносят ошибки бывшие Python программисты по нашему опыту проверок C++ проектов.
**Предупреждение 3**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'id < 0' is always false. Unsigned type value is always >= 0. UserFolderEngine.cs 173
```
public MailUserFolderData Update(uint id, string name, uint? parentId = null)
{
if (id < 0)
throw new ArgumentException("id");
....
}
```
Переменная *id* имеет беззнаковый тип *uint*. Следовательно, здесь проверка бессмысленна. Стоит уделить внимание вызову этой функции. Интересно, что передают в эту функцию. Скорее всего, раньше везде использовался знаковый тип *int*, а после рефакторинга проверка осталась.
Copy-Paste код
--------------
**Предупреждение 1**
[V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions 'searchFilterData.WithCalendar == WithCalendar' to the left and to the right of the '&&' operator. MailSearchFilterData.cs 131
Этот фрагмент кода пришлось привести в виде картинки, чтобы передать масштаб написанного условного выражения. В нём есть проблемное место. Указание места в предупреждении анализатора с трудом помогает найти 2 одинаковых проверки. Поэтому воспользуемся красным маркером:
И вот те самые условные выражения, о которых предупредил анализатор. Кроме исправления этого места, я бы рекомендовал оформить код получше, чтобы он не способствовал появлению таких ошибок в будущем.
**Предупреждение 2**
[V3030](https://www.viva64.com/ru/w/v3030/) Recurring check. The '!String.IsNullOrEmpty(user)' condition was already verified in line 173. CommonLinkUtility.cs 176
```
public static string GetUserProfile(string user, bool absolute)
{
var queryParams = "";
if (!String.IsNullOrEmpty(user))
{
var guid = Guid.Empty;
if (!String.IsNullOrEmpty(user) && 32 <= user.Length && user[8] == '-')
{
....
}
```
Строка *user* проверяется 2 раза подряд одинаковым образом. Пожалуй, этот код можно немного отрефакторить. Хотя кто знает, может, в одном из случаев хотели проверить логическую переменную *absolute*.
**Предупреждение 3**
[V3021](https://www.viva64.com/ru/w/v3021/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless WikiEngine.cs 688
```
private static LinkType CheckTheLink(string str, out string sLink)
{
sLink = string.Empty;
if (string.IsNullOrEmpty(str))
return LinkType.None;
if (str[0] == '[')
{
sLink = str.Trim("[]".ToCharArray()).Split('|')[0].Trim();
}
else if (....)
{
sLink = str.Split('|')[0].Trim();
}
sLink = sLink.Split('#')[0].Trim(); // <=
if (string.IsNullOrEmpty(str)) // <=
return LinkType.None;
if (sLink.Contains(":"))
{
....
}
....
}
```
Уверен, что ошибку здесь глазами не найти. Анализатор обнаружил бесполезную проверку, которая на деле оказалась скопированным кодом сверху. Вместо переменной *str* должна проверяться переменная *sLink*.
**Предупреждение 4**
[V3004](https://www.viva64.com/ru/w/v3004/) The 'then' statement is equivalent to the 'else' statement. SelectelStorage.cs 461
```
public override string[] ListFilesRelative(....)
{
var paths = new List();
var client = GetClient().Result;
if (recursive)
{
paths = client.GetContainerFilesAsync(\_private\_container, int.MaxValue,
null, MakePath(domain, path)).Result.Select(x => x.Name).ToList();
}
else
{
paths = client.GetContainerFilesAsync(\_private\_container, int.MaxValue,
null, MakePath(domain, path)).Result.Select(x => x.Name).ToList();
}
....
}
```
Анализатор обнаружил очень наглядный Copy-Paste код. Возможно, в одном из случаев переменную *paths* необходимо вычислять рекурсивно, но этого не было сделано.
**Предупреждение 5**
[V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of 'true'. MessageEngine.cs 318
```
//TODO: Simplify
public bool SetUnread(List ids, bool unread, bool allChain = false)
{
....
if (!chainedMessages.Any())
return true;
var listIds = allChain
? chainedMessages.Where(x => x.IsNew == !unread).Select(....).ToList()
: ids;
if (!listIds.Any())
return true;
....
return true;
}
```
Размер этой функции 135 строк. Даже сами разработчики оставили комментарий, что её надо упростить. С кодом функции определённо надо поработать, т.к. он ещё и возвращает одно значение во всех случаях.
Бесполезные вызовы функций
--------------------------
**Предупреждение 1**
[V3010](https://www.viva64.com/ru/w/v3010/) The return value of function 'Distinct' is required to be utilized. DbTenantService.cs 132
```
public IEnumerable GetTenants(string login, string passwordHash)
{
//new password
result = result.Concat(ExecList(q).ConvertAll(ToTenant)).ToList();
result.Distinct();
....
}
```
Метод *Distinct* удаляет дубликаты из коллекции. Но в C# большинство подобных методов-расширений не меняют объект, а создают копию. Таким образом, в этом примере список *result* остаётся всё тем же, что и до вызова метода. Ещё тут можно заметить имена *login* и *passwordHash*. Возможно, это очередная проблема с безопасностью.
**Предупреждение 2**
[V3010](https://www.viva64.com/ru/w/v3010/) The return value of function 'ToString' is required to be utilized. UserPhotoManager.cs 678
```
private static void ResizeImage(ResizeWorkerItem item)
{
....
using (var stream2 = new MemoryStream(data))
{
item.DataStore.Save(fileName, stream2).ToString();
AddToCache(item.UserId, item.Size, fileName);
}
....
}
```
Метод *ToString* здесь стандартный. Он возвращает текстовое представление объекта, но возвращаемое значение не используется.
**Предупреждение 3**
[V3010](https://www.viva64.com/ru/w/v3010/) The return value of function 'Replace' is required to be utilized. TextFileUserImporter.cs 252
```
private int GetFieldsMapping(....)
{
....
if (NameMapping != null && NameMapping.ContainsKey(propertyField))
{
propertyField = NameMapping[propertyField];
}
propertyField.Replace(" ", "");
....
}
```
Кто-то допустил серьёзную ошибку. Из свойства *propertyField* необходимо было удалить все пробелы, а этого не происходит, т.к. функция *Replace* не изменяет исходный объект.
**Предупреждение 4**
[V3038](https://www.viva64.com/ru/w/v3038/) The '"yy"' argument was passed to 'Replace' method several times. It is possible that other argument should be passed instead. MasterLocalizationResources.cs 38
```
private static string GetDatepikerDateFormat(string s)
{
return s
.Replace("yyyy", "yy")
.Replace("yy", "yy") // <=
.Replace("MMMM", "MM")
.Replace("MMM", "M")
.Replace("MM", "mm")
.Replace("M", "mm")
.Replace("dddd", "DD")
.Replace("ddd", "D")
.Replace("dd", "11")
.Replace("d", "dd")
.Replace("11", "dd")
.Replace("'", "")
;
}
```
Здесь вызовы функций *Replace* написаны корректно, но в одном место это сделано со странными одинаковыми аргументами.
Потенциальный NullReferenceException
------------------------------------
**Предупреждение 1**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'portalUser.BirthDate.ToString()' is always not null. The operator '??' is excessive. LdapUserManager.cs 436
```
public DateTime? BirthDate { get; set; }
private bool NeedUpdateUser(UserInfo portalUser, UserInfo ldapUser)
{
....
_log.DebugFormat("NeedUpdateUser by BirthDate -> portal: '{0}', ldap: '{1}'",
portalUser.BirthDate.ToString() ?? "NULL", // <=
ldapUser.BirthDate.ToString() ?? "NULL"); // <=
needUpdate = true;
....
}
```
*ToString* не будет иметь значение *null*. Проверка здесь делалась для того, чтобы в отладочный лог вывести значение "NULL", если дата не задана. Но т.к. в случае отсутствия значения метод *ToString* вернёт пустую строку, то ошибка в алгоритме может быть менее заметна в логах.
Весь список сомнительных мест логгирования выглядит так:
* V3022 Expression 'ldapUser.BirthDate.ToString()' is always not null. The operator '??' is excessive. LdapUserManager.cs 437
* V3022 Expression 'portalUser.Sex.ToString()' is always not null. The operator '??' is excessive. LdapUserManager.cs 444
* V3022 Expression 'ldapUser.Sex.ToString()' is always not null. The operator '??' is excessive. LdapUserManager.cs 445
**Предупреждение 2**
[V3095](https://www.viva64.com/ru/w/v3095/) The 'r.Attributes["href"]' object was used before it was verified against null. Check lines: 86, 87. HelpCenterStorage.cs 86
```
public override void Init(string html, string helpLinkBlock, string baseUrl)
{
....
foreach (var href in hrefs.Where(r =>
{
var value = r.Attributes["href"].Value;
return r.Attributes["href"] != null
&& !string.IsNullOrEmpty(value)
&& !value.StartsWith("mailto:")
&& !value.StartsWith("http");
}))
{
....
}
....
}
```
При парсинге Html или Xml очень опасно обращаться к атрибутам по имени без проверки. Эта ошибка особенно привлекательна тем, что значение атрибута *href* сначала извлекается, а потом проверяется, присутствует ли он вообще.
**Предупреждение 3**
[V3146](https://www.viva64.com/ru/w/v3146/) Possible null dereference. The 'listTags.FirstOrDefault' can return default null value. FileMarker.cs 299
```
public static void RemoveMarkAsNew(....)
{
....
var listTags = tagDao.GetNewTags(userID, (Folder)fileEntry, true).ToList();
valueNew = listTags.FirstOrDefault(tag => tag.EntryId.Equals(....)).Count;
....
}
```
Анализатор обнаружил небезопасное использование результата вызова метода *FirstOrDefault*. Этот метод возвращают значение по умолчанию, если в списке нет ни одного объекта, удовлетворяющего предикату поиска. Значением по умолчанию для ссылочных типов является пустая ссылка (null). Соответственно, прежде чем использовать полученную ссылку, её следует проверить, а не звать сразу свойство, как здесь.
**Предупреждение 4**
[V3115](https://www.viva64.com/ru/w/v3115/) Passing 'null' to 'Equals' method should not result in 'NullReferenceException'. ResCulture.cs 28
```
public class ResCulture
{
public string Title { get; set; }
public string Value { get; set; }
public bool Available { get; set; }
public override bool Equals(object obj)
{
return Title.Equals(((ResCulture) obj).Title);
}
....
}
```
Ссылки на объекты в C# часто сравнивают со значением *null*. Следовательно, при перегрузке методов сравнения очень важно предусмотреть такие ситуации и добавить соответствующую проверку в начало функции. А здесь этого не сделали.
Другие баги
-----------
**Предупреждение 1**
[V3022](https://www.viva64.com/ru/w/v3022/) Expression is always true. Probably the '&&' operator should be used here. ListItemHistoryDao.cs 140
```
public virtual int CreateItem(ListItemHistory item)
{
if (item.EntityType != EntityType.Opportunity || // <=
item.EntityType != EntityType.Contact)
throw new ArgumentException();
if (item.EntityType == EntityType.Opportunity &&
(DaoFactory.DealDao.GetByID(item.EntityID) == null ||
DaoFactory.DealMilestoneDao.GetByID(item.StatusID) == null))
throw new ArgumentException();
if (item.EntityType == EntityType.Contact &&
(DaoFactory.ContactDao.GetByID(item.EntityID) == null ||
DaoFactory.ListItemDao.GetByID(item.StatusID) == null))
throw new ArgumentException();
....
}
```
Вызов метода *CreateItem* приведёт к возникновению исключения типа *ArgumentException*. Дело в том, что самое первое условное выражение содержит ошибку. Условие всегда имеет результат *true*. Ошибка заключается в выборе логического оператора. Надо было использовать оператор &&.
Скорее всего, этот метод ещё ни разу не вызывался, т.к. он виртуальный и до сего момента всегда переопределялся в производных классах.
Чтобы впредь не допускать таких ошибок, рекомендую почитать мою статью и сохранить на неё ссылку: "[Логические выражения. Как ошибаются профессионалы](https://www.viva64.com/ru/b/0390/)". Там приведены и разобраны все ошибочные комбинации из логических операторов.
**Предупреждение 2**
[V3052](https://www.viva64.com/ru/w/v3052/) The original exception object 'ex' was swallowed. Stack of original exception could be lost. GoogleDriveStorage.cs 267
```
public DriveFile CopyEntry(string toFolderId, string originEntryId)
{
var body = FileConstructor(folderId: toFolderId);
try
{
var request = _driveService.Files.Copy(body, originEntryId);
request.Fields = GoogleLoginProvider.FilesFields;
return request.Execute();
}
catch (GoogleApiException ex)
{
if (ex.HttpStatusCode == HttpStatusCode.Forbidden)
{
throw new SecurityException(ex.Error.Message);
}
throw;
}
}
```
Здесь преобразовали исключение *GoogleApiException* в *SecurityException*, потеряв при этом информацию из исходного исключения, которая может быть полезной.
Вот такое небольшое изменение сделает сгенерированное предупреждение более информативным:
```
throw new SecurityException(ex.Error.Message, ex);
```
Хотя вполне возможно, что исключение *GoogleApiException* скрыли намерено.
**Предупреждение 3**
[V3118](https://www.viva64.com/ru/w/v3118/) Minutes component of TimeSpan is used, which does not represent full time interval. Possibly 'TotalMinutes' value was intended instead. NotifyClient.cs 281
```
public static void SendAutoReminderAboutTask(DateTime scheduleDate)
{
....
var deadlineReminderDate = deadline.AddMinutes(-alertValue);
if (deadlineReminderDate.Subtract(scheduleDate).Minutes > 1) continue;
....
}
```
Раньше я считал, что диагностика имеет предупредительный характер. В коде моих проектов она всегда выдавала ложные предупреждения. Здесь же я почти уверен, обнаружилась ошибка. Скорее всего, надо использовать именно свойство *TotalMinutes*, вместо *Minutes*.
**Предупреждение 4**
[V3008](https://www.viva64.com/ru/w/v3008/) The 'key' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 244, 240. Metadata.cs 244
```
private byte[] GenerateKey()
{
var key = new byte[keyLength];
using (var deriveBytes = new Rfc2898DeriveBytes(Password, Salt, ....))
{
key = deriveBytes.GetBytes(keyLength);
}
return key;
}
```
Проблема этого фрагмента в том, что при входе в функции всегда создаётся массив байт, а потом сразу перезатирается. Т.е. тут постоянно происходит выделение памяти, которое не имеет смысла.
Лучше всего тут было бы перейти на C#8 вместо используемого C#5 и написать более короткий код:
```
private byte[] GenerateKey()
{
using var deriveBytes = new Rfc2898DeriveBytes(Password, Salt, ....);
return deriveBytes.GetBytes(keyLength);
}
```
Не могу сказать, возможен ли апгрейд проекта или нет, но таких мест не мало. Их желательно переписать как-нибудь:
* V3008 The 'hmacKey' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 256, 252. Metadata.cs 256
* V3008 The 'hmacHash' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 270, 264. Metadata.cs 270
* V3008 The 'paths' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 512, 508. RackspaceCloudStorage.cs 512
* V3008 The 'b' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 265, 264. BookmarkingUserControl.ascx.cs 265
* V3008 The 'taskIds' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 412, 391. TaskDao.cs 412
На крайний случай, можно не выделять память при объявлении переменной.
Баг в PVS-Studio
----------------
Думаете, мы только пишем про ошибки других. Нет, наша команда самокритична, признаёт свои ошибки и не стесняется написать про них тоже. Все ошибаются.
По ходу работы над статьёй у нас нашёлся достаточно глупый баг. Признаём и спешим поделиться.
Код из того же Community Server:
```
private bool IsPhrase(string searchText)
{
return searchText.Contains(" ") || searchText.Contains("\r\n") ||
searchText.Contains("\n");
}
```
Я должен был привести полное предупреждение анализатора перед кодом, как это делается во всей статье, но в этом то и проблема. Предупреждение выглядит так:
Управляющие символы \r и \n не экранируются перед выводом в таблицу.
Заключение
----------
Давно мне не попадался столь интересный проект для проверки. Спасибо авторам ONLYOFFCE. Мы хотели с Вами связаться, но обратной связи не последовало.
Мы регулярно пишем подобные [статьи](https://www.viva64.com/ru/inspections/). Этому жанру уже более десяти лет. Поэтому разработчикам не стоит принимать критику близко к сердцу. Мы будем рады выдать полную версию отчёта для улучшения проекта или предоставить временную лицензию для проверки проекта. Причём не только проекту CommunityServer, а всем желающим и на ОДИН МЕСЯЦ по промокоду [#onlyoffice](https://www.viva64.com/onlyoffice).
Также специалистам по безопасности будет интересно узнать, что мы ведём активную поддержку стандарта OWASP. Некоторые диагностики уже доступны. А скоро будет доработан интерфейс анализатора, чтобы включение того или иного стандарта для анализа кода стало ещё удобнее.
[](https://habr.com/en/company/pvs-studio/blog/533494/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [ONLYOFFICE Community Server: how bugs contribute to the emergence of security problems](https://habr.com/en/company/pvs-studio/blog/533494/). | https://habr.com/ru/post/533496/ | null | ru | null |
# AWS: RDS Micro инстансы теперь доступны и в VPC
Привет! 
Совсем [недавно](http://habrahabr.ru/company/epam_systems/blog/154179/) RDS стали доступными на инстансах типа t1.micro бесплатно в рамках пакета Free Tier. А с сегодняшнего дня, эти RDS инстансы доступны и в VPC.
Напомню, что VPC (Virtual Private Cloud) — это отдельное виртуальное облако, которое позиционируется, как приватное. Ресурсам можно назначать сети и подсети, сетевые интерфейсы и ещё много чего. Можно ограничить свои серверы от всего Интернета, тем самым серьёзно повысив безопасность ресурсов.
Для того, чтоб добавить RDS инстанс в уже существующую сеть, нужно сначала создать DB подсеть в консоли:
Заметим, что дожны быть покрыты минимум 2 зоны. Это сделано для создания MultiAZ деалойментов в VPC.
После, нужно создать Security Group для подсети VPC:
Ну и при создании инстанса нужно указать подсеть VPC и созданную Security Group:
Все те же манипуляции доступны в утилитах CLI командами:
```
$ rds-create-db-subnet-group
$ rds-create-db-security-group
$ rds-create-db-instance
```
Пользуетесь ли вы VPC? A RDS в VPC? | https://habr.com/ru/post/161447/ | null | ru | null |
# Linux: Листинг директории без ls (list files without ls)
Выяснилось что в моем zte 531 b стоит урезанный linux. Однако полноценному его изучению мешает отсутствие в стандартной поставке командочки ls. Оказывается листинг директории можно получить и без нее:
`> echo *
CVS bin dev etc lib linuxrc mnt proc sbin usr var webs
>`
А натолкнула меня на это подсказка встроенная в cat
`> cat *
You should use echo * to list the files
>` | https://habr.com/ru/post/51245/ | null | ru | null |
# Главное — скорость. Новый графический формат QOI в 20−50 раз быстрее PNG
Современные форматы кодирования изображений — это настоящая магия, в которой не разобраться без нескольких лет погружения в специфические алгоритмы. Даже опенсорсные форматы содержат настоящее спагетти навороченных и хитроумных методов типа [алгоритма Хаффмана](https://en.wikipedia.org/wiki/Huffman_coding) и [дискретно-косинусного преобразования](https://en.wikipedia.org/wiki/Discrete_cosine_transform) — результат нескольких десятилетий развития компьютерной науки.
Поскольку польский разработчик Доминик Шаблевски вообще не разбирается в кодировании изображений, то он написал примитивный метод сжатия изображений без потери качества всего в [300 строчек кода](https://github.com/phoboslab/qoi), на базовой математике. Результат его очень удивил.
Оказалось, что этот простой метод по скорости на порядок превосходит популярные кодеки libpng и stbi.
Доминик Шаблевски назвал формат Quite OK (Quite OK Image), то есть «вполне достаточное» качество и размер. Другими словами, он конкретно заточен именно на скорость. Во многих случаях — при пакетной обработке большого количества файлов, в автоматических конвейерах — скорость является ключевым фактором.
Автор считает свой алгоритм до глупости простым. Он берёт изображения RGB и RGBA — и кодирует их в формат QOI размером с обычный PNG, но гораздо быстрее. Всё в один поток, без SIMD.
В своём блоге Доминик [описывает](https://phoboslab.org/log/2021/11/qoi-fast-lossless-image-compression) нехитрую технику сжатия. Изображение кодируется в один проход, каждый пиксель считывается только один раз и кодируется одним из четырёх методов, по порядку:
1. Если пиксель равен предыдущему, увеличивается счётчик по типу [кодирования повторов](https://en.wikipedia.org/wiki/Run-length_encoding) (RLE). Если нет, то применяется метод 2, и так далее
2. Пиксель из массива 64 последних по «хешу» `r^g^b^a`
3. Разница с предыдущим пикселем, если она небольшая
4. Полное значение RGBA
Результирующие значения записываются в группы с указанием сначала тега (метод кодирования), после которого идут биты. Все группы выровнены по байтам для ускорения доступа в памяти.
Вот и всё.
Для сравнения, ниже результаты сжатия скриншотов нескольких сайтов. Использовались библиотеки libpng, stbi и qoi. Указан размер каждого скриншота, время кодирования, время декодирования, скорость кодирования/декодирования в мегапикселях в секунду и размеры итоговых файлов. Тесты проводились на процессоре Intel i7-6700K.
**Бенчмарки**
```
/screenshots/news.ycombinator.com.png: 1325x1450
decode ms encode ms decode mpps encode mpps size kb
libpng: 8.6 79.9 223.22 24.03 289
stbi: 6.0 157.4 319.14 12.21 333
qoi: 3.0 3.8 649.95 502.49 288
/screenshots/reddit.com.png: 1313x8008
decode ms encode ms decode mpps encode mpps size kb
libpng: 72.4 754.0 145.23 13.95 2821
stbi: 43.3 990.1 243.06 10.62 3927
qoi: 25.2 31.8 417.56 330.15 3083
/screenshots/nytimes.com.png: 1313x5780
decode ms encode ms decode mpps encode mpps size kb
libpng: 53.2 575.6 142.75 13.18 2672
stbi: 36.5 700.7 207.79 10.83 3377
qoi: 17.4 23.1 436.58 327.94 2820
/screenshots/phoboslab.org.png: 1313x20667
decode ms encode ms decode mpps encode mpps size kb
libpng: 116.4 1452.2 233.03 18.69 6199
stbi: 80.8 1861.0 335.93 14.58 7421
qoi: 57.7 79.2 470.43 342.82 8337
/screenshots/microsoft.com.png: 1313x3328
decode ms encode ms decode mpps encode mpps size kb
libpng: 28.7 356.7 152.36 12.25 1518
stbi: 20.8 413.0 210.03 10.58 2030
qoi: 10.2 14.3 429.00 306.57 1701
/screenshots/cnn.com.png: 1313x5241
decode ms encode ms decode mpps encode mpps size kb
libpng: 36.2 457.2 189.96 15.05 2246
stbi: 30.7 613.9 224.44 11.21 2729
qoi: 14.4 20.2 478.56 340.84 2449
/screenshots/sublime.png: 1008x9513
decode ms encode ms decode mpps encode mpps size kb
libpng: 38.4 405.6 249.44 23.64 1579
stbi: 29.5 761.8 325.20 12.59 1858
qoi: 16.9 20.5 568.14 468.58 1538
/screenshots/amazon.com.png: 1313x6097
decode ms encode ms decode mpps encode mpps size kb
libpng: 67.3 843.0 118.97 9.50 4589
stbi: 58.1 841.4 137.84 9.51 6014
qoi: 24.7 36.3 323.62 220.51 5382
/screenshots/imdb.com.png: 1313x6441
decode ms encode ms decode mpps encode mpps size kb
libpng: 43.3 535.0 195.43 15.81 2264
stbi: 37.3 761.0 226.62 11.11 3053
qoi: 17.9 23.0 472.10 367.12 2541
/screenshots/duckduckgo.com.png: 1313x2874
decode ms encode ms decode mpps encode mpps size kb
libpng: 12.7 146.3 297.73 25.80 333
stbi: 8.8 300.3 427.03 12.57 436
qoi: 5.0 6.8 755.00 558.83 330
/screenshots/en.wikipedia.org.png: 1313x2936
decode ms encode ms decode mpps encode mpps size kb
libpng: 21.7 227.7 177.59 16.93 1342
stbi: 15.2 317.3 253.86 12.15 1497
qoi: 8.4 11.9 460.19 325.07 1547
/screenshots/apple.com.png: 1313x4755
decode ms encode ms decode mpps encode mpps size kb
libpng: 33.1 427.8 188.47 14.59 1941
stbi: 27.5 556.7 227.34 11.21 2575
qoi: 13.2 18.6 474.51 335.93 2157
/screenshots/stripe.com.png: 1313x6603
decode ms encode ms decode mpps encode mpps size kb
libpng: 40.8 411.5 212.45 21.07 1054
stbi: 24.4 691.6 354.68 12.54 1428
qoi: 16.2 19.4 535.20 447.23 1386
```
Как видим, размер итоговых файлов QOI обычно между libpng и stbi, а скорость намного выше. Разница в сжатии составляет 20−50 раз, в декомпрессии — 3−4 раза.
В среднем по всем скриншотам:
```
decode ms encode ms decode mpps encode mpps size kb
libpng: 44.1 513.3 186.80 16.04 2219
stbi: 32.2 689.7 255.47 11.93 2821
qoi: 17.7 23.8 465.18 346.52 2582
```
Результаты остальных бенчмарков см. [здесь](https://phoboslab.org/files/qoibench/). Набор тестовых изображений для проверки: [images.tar](https://phoboslab.org/files/qoibench/images.tar), ~308 МБ.
Разумеется, QOI можно рекомендовать только для внутреннего использования во внутренних конвейерах обработки изображений, потому что никакие браузеры, да и вообще никто его ещё не поддерживает. Но он отлично подходит для внутреннего хранения картинок без потери качества, если главным фактором является скорость.
Доминик Шаблевски считает, что разработчики форматов сжатия в основном думают об уровне сжатия, размере файлов. Мало кто ставит на первое место именно скорость и простоту кодека. Поэтому в сообществе есть некоторая потребность в суперпростом и быстром кодеке. Может, он кому-то пригодится.
Теоретически, кодек можно приспособить для супербыстрого сжатия видео (без потерь) на примитивных микросхемах.
**Код qoi.h**
```
// Header - Public functions
#ifndef QOI_H
#define QOI_H
#ifdef __cplusplus
extern "C" {
#endif
// A pointer to qoi_desc struct has to be supplied to all of qoi's functions. It
// describes either the input format (for qoi_write, qoi_encode), or is filled
// with the description read from the file header (for qoi_read, qoi_decode).
// The colorspace in this qoi_desc is a bitmap with 0000rgba where a 0-bit
// indicates sRGB and a 1-bit indicates linear colorspace for each channel. You
// may use one of the predefined constants: QOI_SRGB, QOI_SRGB_LINEAR_ALPHA or
// QOI_LINEAR. The colorspace is purely informative. It will be saved to the
// file header, but does not affect en-/decoding in any way.
#define QOI_SRGB 0x00
#define QOI_SRGB_LINEAR_ALPHA 0x01
#define QOI_LINEAR 0x0f
typedef struct {
unsigned int width;
unsigned int height;
unsigned char channels;
unsigned char colorspace;
} qoi_desc;
#ifndef QOI_NO_STDIO
// Encode raw RGB or RGBA pixels into a QOI image and write it to the file
// system. The qoi_desc struct must be filled with the image width, height,
// number of channels (3 = RGB, 4 = RGBA) and the colorspace.
// The function returns 0 on failure (invalid parameters, or fopen or malloc
// failed) or the number of bytes written on success.
int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
// Read and decode a QOI image from the file system. If channels is 0, the
// number of channels from the file header is used. If channels is 3 or 4 the
// output format will be forced into this number of channels.
// The function either returns NULL on failure (invalid data, or malloc or fopen
// failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
// will be filled with the description from the file header.
// The returned pixel data should be free()d after use.
void *qoi_read(const char *filename, qoi_desc *desc, int channels);
#endif // QOI_NO_STDIO
// Encode raw RGB or RGBA pixels into a QOI image in memory.
// The function either returns NULL on failure (invalid parameters or malloc
// failed) or a pointer to the encoded data on success. On success the out_len
// is set to the size in bytes of the encoded data.
// The returned qoi data should be free()d after use.
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
// Decode a QOI image from memory.
// The function either returns NULL on failure (invalid parameters or malloc
// failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
// is filled with the description from the file header.
// The returned pixel data should be free()d after use.
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
#ifdef __cplusplus
}
#endif
#endif // QOI_H
// -----------------------------------------------------------------------------
// Implementation
#ifdef QOI_IMPLEMENTATION
#include
#ifndef QOI\_MALLOC
#define QOI\_MALLOC(sz) malloc(sz)
#define QOI\_FREE(p) free(p)
#endif
#define QOI\_INDEX 0x00 // 00xxxxxx
#define QOI\_RUN\_8 0x40 // 010xxxxx
#define QOI\_RUN\_16 0x60 // 011xxxxx
#define QOI\_DIFF\_8 0x80 // 10xxxxxx
#define QOI\_DIFF\_16 0xc0 // 110xxxxx
#define QOI\_DIFF\_24 0xe0 // 1110xxxx
#define QOI\_COLOR 0xf0 // 1111xxxx
#define QOI\_MASK\_2 0xc0 // 11000000
#define QOI\_MASK\_3 0xe0 // 11100000
#define QOI\_MASK\_4 0xf0 // 11110000
#define QOI\_COLOR\_HASH(C) (C.rgba.r ^ C.rgba.g ^ C.rgba.b ^ C.rgba.a)
#define QOI\_MAGIC \
(((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
((unsigned int)'i') << 8 | ((unsigned int)'f'))
#define QOI\_HEADER\_SIZE 14
#define QOI\_PADDING 4
typedef union {
struct { unsigned char r, g, b, a; } rgba;
unsigned int v;
} qoi\_rgba\_t;
void qoi\_write\_32(unsigned char \*bytes, int \*p, unsigned int v) {
bytes[(\*p)++] = (0xff000000 & v) >> 24;
bytes[(\*p)++] = (0x00ff0000 & v) >> 16;
bytes[(\*p)++] = (0x0000ff00 & v) >> 8;
bytes[(\*p)++] = (0x000000ff & v);
}
unsigned int qoi\_read\_32(const unsigned char \*bytes, int \*p) {
unsigned int a = bytes[(\*p)++];
unsigned int b = bytes[(\*p)++];
unsigned int c = bytes[(\*p)++];
unsigned int d = bytes[(\*p)++];
return (a << 24) | (b << 16) | (c << 8) | d;
}
void \*qoi\_encode(const void \*data, const qoi\_desc \*desc, int \*out\_len) {
if (
data == NULL || out\_len == NULL || desc == NULL ||
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
(desc->colorspace & 0xf0) != 0
) {
return NULL;
}
int max\_size =
desc->width \* desc->height \* (desc->channels + 1) +
QOI\_HEADER\_SIZE + QOI\_PADDING;
int p = 0;
unsigned char \*bytes = QOI\_MALLOC(max\_size);
if (!bytes) {
return NULL;
}
qoi\_write\_32(bytes, &p, QOI\_MAGIC);
qoi\_write\_32(bytes, &p, desc->width);
qoi\_write\_32(bytes, &p, desc->height);
bytes[p++] = desc->channels;
bytes[p++] = desc->colorspace;
const unsigned char \*pixels = (const unsigned char \*)data;
qoi\_rgba\_t index[64] = {0};
int run = 0;
qoi\_rgba\_t px\_prev = {.rgba = {.r = 0, .g = 0, .b = 0, .a = 255}};
qoi\_rgba\_t px = px\_prev;
int px\_len = desc->width \* desc->height \* desc->channels;
int px\_end = px\_len - desc->channels;
int channels = desc->channels;
for (int px\_pos = 0; px\_pos < px\_len; px\_pos += channels) {
if (channels == 4) {
px = \*(qoi\_rgba\_t \*)(pixels + px\_pos);
}
else {
px.rgba.r = pixels[px\_pos];
px.rgba.g = pixels[px\_pos+1];
px.rgba.b = pixels[px\_pos+2];
}
if (px.v == px\_prev.v) {
run++;
}
if (
run > 0 &&
(run == 0x2020 || px.v != px\_prev.v || px\_pos == px\_end)
) {
if (run < 33) {
run -= 1;
bytes[p++] = QOI\_RUN\_8 | run;
}
else {
run -= 33;
bytes[p++] = QOI\_RUN\_16 | run >> 8;
bytes[p++] = run;
}
run = 0;
}
if (px.v != px\_prev.v) {
int index\_pos = QOI\_COLOR\_HASH(px) % 64;
if (index[index\_pos].v == px.v) {
bytes[p++] = QOI\_INDEX | index\_pos;
}
else {
index[index\_pos] = px;
int vr = px.rgba.r - px\_prev.rgba.r;
int vg = px.rgba.g - px\_prev.rgba.g;
int vb = px.rgba.b - px\_prev.rgba.b;
int va = px.rgba.a - px\_prev.rgba.a;
if (
vr > -17 && vr < 16 &&
vg > -17 && vg < 16 &&
vb > -17 && vb < 16 &&
va > -17 && va < 16
) {
if (
va == 0 &&
vr > -3 && vr < 2 &&
vg > -3 && vg < 2 &&
vb > -3 && vb < 2
) {
bytes[p++] = QOI\_DIFF\_8 | ((vr + 2) << 4) | (vg + 2) << 2 | (vb + 2);
}
else if (
va == 0 &&
vr > -17 && vr < 16 &&
vg > -9 && vg < 8 &&
vb > -9 && vb < 8
) {
bytes[p++] = QOI\_DIFF\_16 | (vr + 16);
bytes[p++] = (vg + 8) << 4 | (vb + 8);
}
else {
bytes[p++] = QOI\_DIFF\_24 | (vr + 16) >> 1;
bytes[p++] = (vr + 16) << 7 | (vg + 16) << 2 | (vb + 16) >> 3;
bytes[p++] = (vb + 16) << 5 | (va + 16);
}
}
else {
bytes[p++] = QOI\_COLOR | (vr ? 8 : 0) | (vg ? 4 : 0) | (vb ? 2 : 0) | (va ? 1 : 0);
if (vr) { bytes[p++] = px.rgba.r; }
if (vg) { bytes[p++] = px.rgba.g; }
if (vb) { bytes[p++] = px.rgba.b; }
if (va) { bytes[p++] = px.rgba.a; }
}
}
}
px\_prev = px;
}
for (int i = 0; i < QOI\_PADDING; i++) {
bytes[p++] = 0;
}
\*out\_len = p;
return bytes;
}
void \*qoi\_decode(const void \*data, int size, qoi\_desc \*desc, int channels) {
if (
data == NULL || desc == NULL ||
(channels != 0 && channels != 3 && channels != 4) ||
size < QOI\_HEADER\_SIZE + QOI\_PADDING
) {
return NULL;
}
const unsigned char \*bytes = (const unsigned char \*)data;
int p = 0;
unsigned int header\_magic = qoi\_read\_32(bytes, &p);
desc->width = qoi\_read\_32(bytes, &p);
desc->height = qoi\_read\_32(bytes, &p);
desc->channels = bytes[p++];
desc->colorspace = bytes[p++];
if (
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
header\_magic != QOI\_MAGIC
) {
return NULL;
}
if (channels == 0) {
channels = desc->channels;
}
int px\_len = desc->width \* desc->height \* channels;
unsigned char \*pixels = QOI\_MALLOC(px\_len);
if (!pixels) {
return NULL;
}
qoi\_rgba\_t px = {.rgba = {.r = 0, .g = 0, .b = 0, .a = 255}};
qoi\_rgba\_t index[64] = {0};
int run = 0;
int chunks\_len = size - QOI\_PADDING;
for (int px\_pos = 0; px\_pos < px\_len; px\_pos += channels) {
if (run > 0) {
run--;
}
else if (p < chunks\_len) {
int b1 = bytes[p++];
if ((b1 & QOI\_MASK\_2) == QOI\_INDEX) {
px = index[b1 ^ QOI\_INDEX];
}
else if ((b1 & QOI\_MASK\_3) == QOI\_RUN\_8) {
run = (b1 & 0x1f);
}
else if ((b1 & QOI\_MASK\_3) == QOI\_RUN\_16) {
int b2 = bytes[p++];
run = (((b1 & 0x1f) << 8) | (b2)) + 32;
}
else if ((b1 & QOI\_MASK\_2) == QOI\_DIFF\_8) {
px.rgba.r += ((b1 >> 4) & 0x03) - 2;
px.rgba.g += ((b1 >> 2) & 0x03) - 2;
px.rgba.b += ( b1 & 0x03) - 2;
}
else if ((b1 & QOI\_MASK\_3) == QOI\_DIFF\_16) {
int b2 = bytes[p++];
px.rgba.r += (b1 & 0x1f) - 16;
px.rgba.g += (b2 >> 4) - 8;
px.rgba.b += (b2 & 0x0f) - 8;
}
else if ((b1 & QOI\_MASK\_4) == QOI\_DIFF\_24) {
int b2 = bytes[p++];
int b3 = bytes[p++];
px.rgba.r += (((b1 & 0x0f) << 1) | (b2 >> 7)) - 16;
px.rgba.g += ((b2 & 0x7c) >> 2) - 16;
px.rgba.b += (((b2 & 0x03) << 3) | ((b3 & 0xe0) >> 5)) - 16;
px.rgba.a += (b3 & 0x1f) - 16;
}
else if ((b1 & QOI\_MASK\_4) == QOI\_COLOR) {
if (b1 & 8) { px.rgba.r = bytes[p++]; }
if (b1 & 4) { px.rgba.g = bytes[p++]; }
if (b1 & 2) { px.rgba.b = bytes[p++]; }
if (b1 & 1) { px.rgba.a = bytes[p++]; }
}
index[QOI\_COLOR\_HASH(px) % 64] = px;
}
if (channels == 4) {
\*(qoi\_rgba\_t\*)(pixels + px\_pos) = px;
}
else {
pixels[px\_pos] = px.rgba.r;
pixels[px\_pos+1] = px.rgba.g;
pixels[px\_pos+2] = px.rgba.b;
}
}
return pixels;
}
#ifndef QOI\_NO\_STDIO
#include
int qoi\_write(const char \*filename, const void \*data, const qoi\_desc \*desc) {
FILE \*f = fopen(filename, "wb");
if (!f) {
return 0;
}
int size;
void \*encoded = qoi\_encode(data, desc, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fclose(f);
QOI\_FREE(encoded);
return size;
}
void \*qoi\_read(const char \*filename, qoi\_desc \*desc, int channels) {
FILE \*f = fopen(filename, "rb");
if (!f) {
return NULL;
}
fseek(f, 0, SEEK\_END);
int size = ftell(f);
fseek(f, 0, SEEK\_SET);
void \*data = QOI\_MALLOC(size);
if (!data) {
fclose(f);
return NULL;
}
int bytes\_read = fread(data, 1, size, f);
fclose(f);
void \*pixels = qoi\_decode(data, bytes\_read, desc, channels);
QOI\_FREE(data);
return pixels;
}
#endif // QOI\_NO\_STDIO
#endif // QOI\_IMPLEMENTATION
```
**P. S.** В первый день после анонса в формате файлов обнаружились [незначительные баги](https://github.com/phoboslab/qoi/issues/48). Автор обещает представить финальную версию 20 декабря 2021 года. | https://habr.com/ru/post/592699/ | null | ru | null |
# Jupyter for .NET. «Like Python»
A few months ago Microsoft [announced](https://habr.com/ru/company/microsoft/blog/487532/) about the creation of Jupyter for .NET. However, people are barely interested in it despite how attractive the topic is. I decided to make a LaTeX wrapper for the `Entity` class from a symbolic algebra library:
Looks awesome. Is simple. Very enjoyable. Let's see more!
### About [Jupyter](https://jupyter.org)
It's some kind of IDE for interactive notebooks. Instead of execucting the whole code, you can interact with it by executing some parts of it, preserving the variables' values. It's very convenient for research and simple everyday scripts for whatever needs.
### About [dotnet/interactive](https://github.com/dotnet/interactive)
This is what allows us to use .NET inside Jupyter. You can literally write like this
and see the results immediately, without rerunning the whole code.
There are some features without any additional overhead:
### About [AngouriMath](https://github.com/asc-community/AngouriMath)
It's a symbolic algebra library for .NET for working with mathematical expressions. One surely could work with them in-line, like we normally work with them in the code, but it's still inconvenient.
All mathematical expressions in this library inherit from `Entity`, which has method `Latexise` of the `string`. We only need render this LaTeX.
### Injecting LaTeX rendering
We can register our own, custom output for any type. That is how I did it:
```
let magic() =
let register (value : ILatexiseable) = $@"
\[{value.Latexise()}\]
"
Formatter.Register(register, "text/html")
```
That is, we register type `ILatexiseable` to be printed in html which is generated by our function. I use [MathJax](https://www.mathjax.org), a well-known LaTeX rendering library.
Now all classes inhereting from `ILatexiseable` will be rendered like this:
**Explanation for every block**
1. In the first block we call an extension method `ToEntity()`, which parses the expression
2. In the second block we create a system of equations and immediately print out it
3. In the third block we create a matrix and immediately print out it
As long as Jupyter is more about small pieces of code without following any OOP or other industrial principles, F# is best suited for it. That is why it also supported, let me show an example of a school-level equation, solved via this triplet of technologies:
### Further ideas
I'm a big fan of .NET, but I also love Jupyter. That is why the creation of Interactive was an amazing event for me, so I made a wrapper supporting Interactive for AngouriMath for LaTeX output.
Now I think of creating something lke `Entity.Plot()`, which would plot a function's graph. Imagine you write something like
```
plot "x" 10 12 "x2 + sqrt(x) + e^x"
```
and get the graph immediately. In my opinion, it can be a useful feature for simple use-cases.
If you want to try it without installation, try this: [](https://mybinder.org/v2/gh/asc-community/Try/main) (for some reason, it's quite slow, so you will have to wait)
Thank you for your attention! Hope you liked this mini-article.
#### References
1. [Jupyter](https://en.wikipedia.org/wiki/Project_Jupyter) — Interactive IDE for research & creating notebooks
2. [.NET Interactive](https://github.com/dotnet/interactive) — Wrapper for .NET allowing to use .NET in Jupyter
3. [AngouriMath](https://github.com/asc-community/AngouriMath) — Computer algebra library, for which I wrote a [wrapper](https://github.com/asc-community/AngouriMath#jupyter-integration) for LaTeX
4. [MyBinder](https://mybinder.org/v2/gh/asc-community/Try/main) — Demo to play | https://habr.com/ru/post/528816/ | null | en | null |
# Начало работы с TI CC13xx-CC26xx и Contiki под Code Composer Studio
Последнее время тематика интернета вещей становится все более и более горячей — однако в большинстве случаев, если речь заходит о работе с какими-то базовыми аппаратными решениями, то беседа сводится либо к готовым модулям, либо, реже, к чипам выпуска прошлых лет. Тем временем, в 2015 году компания Texas Instruments выпустила очередную линейку систему на кристале CC13xx-CC26xx — крайне интересных с точки зрения соотношения производительности, энергопотребления и возможностей. Эти випы имеют на борту основное ядро ARM Cortex-M3, второе ядро Cortex-M0, эксклюзивно обслуживающее радиочасть, и… да, ещё и третье ядро — собственное 16-битное ядро TI для работы с периферией, так называемый Sensor Controller. При этом и по энергопотреблению комбайн получился крайне скромным — даже радиочасть значительно убавила по сравнению с чипами предыдущего поколения, CC2538.
Мы уже писали обзор существующих стандартов связи, в котором остановились на наиболее современном стандарте 6loWPAN. Данный стандарт описывает сетевой и транспортный уровни модели OSI, а физический и канальный уровни стандартизованы IEEE 802.15.4. Texas Instruments позаботились о нас, и отдали обработку MAC-уровня отдельному ядру Cortex-M0. Остальные уровни нужно обрабатывать на Cortex-M3. И тут нам на помощь приходит операционная система реального времени Contiki, в которой реализована поддержка стека 6loWPAN.
Однако традиционная проблема с новыми чипами — нехватка «коллективного опыта», то есть подробных описаний работы с ними, обхода багов и тому подобных вещей.
Что ж, будем его восполнять. Начнём с базового — сборка и отладка операционной системы Contiki для чипов CC2650. Допустим, мы еще любим красивые графические среды и отладку в них. Поэтому мы будем собирать Contiki под TI Code Composer Studio 6. Я пользуюсь Ubuntu 14.04 X86\_64 для разработки, шаги под Windows будут очень похожи, за исключением установки тулчейна. В конце есть немного вкусностей...
Toolchain
---------
Для начала нужно собрать голый репозиторий [Contiki](https://github.com/contiki-os/contiki.git). Выкачиваем:
```
git clone --recursive https://github.com/contiki-os/contiki.git
```
Собирать будем с помощью родной для проекта системой сборки GNU Make + GCC. Предполагается, что Make у вас уже стоит, виндоюзеры могут поставить его в составе CygWin. Скачиваем [gcc-arm-none-eabi](https://launchpad.net/gcc-arm-embedded/+download) для соответствующей операционной системы и распаковываем куда удобно. Не забываем прописать в PATH!
```
wget https://launchpad.net/gcc-arm-embedded/4.9/4.9-2015-q3-update/+download/gcc-arm-none-eabi-4_9-2015q3-20150921-linux.tar.bz2
tar xz gcc-arm-none-eabi-4_9-2015q3-20150921-linux.tar.bz2
cd gcc-arm-none-eabi-4_9-2015q3
export PATH=$PATH:`pwd`/bin
arm-none-eabi-gcc –v
```
Устанавливаем утилиту для склеивания прошивок [SRecord](http://srecord.sourceforge.net/download.html), необходимую для сборки.
```
sudo add-apt-repository ppa:pmiller-opensource/ppa
sudo apt-get update
sudo apt-get install srecord
```
Теперь попробуем собрать код. Заходим в сорцы и пробуем собрать. `$CONTIKI_DIR` заменяем на свой путь. Собираю я обычно в 4 потока, количество регулируется параметром `-jN`
```
cd $CONTIKI_DIR/examples/cc26xx
make -j4 TARGET=srf06-cc26xx BOARD=srf06/cc26xx cc26xx-demo
ls cc26xx-demo.srf06-cc26xx
```
Собралось, отлично, идем дальше.
Прошивка
--------
Один из путей залить прошивку на сам чип это пользоваться отдельными флешерами. Техас предлагает под линух софтину [Uniflash](http://www.ti.com/tool/uniflash), скачиваем и устанавливаем. Процесс установки хорошо описан в [этом документе](http://www.ti.com.cn/cn/lit/an/swra446/swra446.pdf), *раздел 4.9*.
Для отладки я пользовался комплектом TI SRF06EB + CC2650, так что на его примере и буду показывать.Создаем новую таргет конфигурацию. Програматор с чипом должен быть уже подключен.
Заходим в *Programs*, открываем файл прошивки *Add* и жмакаем *Program*.
Все, можно было бы на этом закончить, но иногда в разработке нужно воспользоваться отладкой, поэтому идем дальше.
Code Composer Studio
--------------------
Скачиваем [TI Code composer Studio for Wireless Connectivity](http://www.ti.com/tool/ccstudio-wcs) для своей платформы. Для установки **настоятельно** рекомендую воспользоваться [installation guide](http://processors.wiki.ti.com/index.php/Linux_Host_Support_CCSv6) с сайта TI.
* Запускаем
* Заходим *Files -> New -> Other...*
* Выбираем *Makefile Project With Existing Code*
* Заполняем названия, путь к директории с Contiki и выбираем *Crocc GCC*
* Заходим в *настройки проекта -> C/C++ Build*, прописываем команду сборки `make -j4 TARGET=srf06-cc26xx BOARD=srf06/cc26xx` и путь до директории, нажав кнопку **Workspace...**
* Build — собралось, промежуточная победа!
+ Не собралось
Возможно CCSv6 не подцепила переменную PATH и не может найти тулчеин. Исправляем: `vim /etc/profile.d/env_vars.sh`
```
export ARM_TOOLCHAIN_HOME=/home/$USER/soft/gcc-arm-none-eabi/gcc-arm-none-eabi-4_9-2015q3
export PATH=$PATH:$ARM_TOOLCHAIN_HOME/bin
```
Настраиваем отладку
===================
#### Для отладки необходимо, чтобы папка с сорцами Contiki лежала в рабочей директории CCSv6
* Нажимаем на проекте правой кнопкой -> добавить файл -> Target Configuration File
* Выбираем отладчик XDS100v3 и чип CC2650 как на скрине
* Нажимаем в форме **Save** и **Test Connection**
* Нажимаем правой кнопкой по свежесозданной конфигурации -> *Debug As* -> *Debug Configurations*
+ Слева создаем новую конфигурацию
+ Заполняем путь к недавно созданной Target Configuration
+ Apply
+ Во вкладке *Program* заполняем поля *Project* и *Program* — путем к собраной прошивке
+ Apply
+ Debug
+ Собралось, прошилось, но говорит **No source available**
+ Открываем *contiki/cpu/cc26xx-cc13xx/Makefile.cc26xx-cc13xx*
+ Добавляем ключ сборки с отладочными символами `CFLAGS += -g`
+ Убираем оптимизации: меняем `-O2` и `-Os` на `-O0`
+ Сохраняем
+ Заходим снова в **Debug Configurations**
+ Нажимаем **Debug**
+ Вуаля
Теперь у нас есть возможность полноценной отладки Contiki в Code Composer Studio под CC2650!
--------------------------------------------------------------------------------------------
Заключение
==========
Описанная последовательность действий является чуть ли не единственно рабочей. На пути к этому было потрачено много времени и нервов, вплоть до обращения в тех-поддержку TI. Есть еще возможность использовать голый Eclipse в качестве среды, но мои изыскания показали, что это условно рабочее решение. Мне так и не удалось запустить отладку в Eclipse, проблема заключалась в GDB-сервере, который никак не хочет подгружать возможность использования hardware-breakpoints. Если кто хочет попробовать, путь описан в документе [TI SWRA446](http://www.ti.com.cn/cn/lit/an/swra446/swra446.pdf).
Увидеть глазами
===============
27 февраля будет проходить офлайн [встреча](https://vk.com/catethysis_ru_meeting) блога Catethysis.ru, на которой буду в этот раз рассказывать и показывать как програмировать MESH-сети. Всех, кто дочитал до конца, милости просим! | https://habr.com/ru/post/390815/ | null | ru | null |
# Верстаем flex-календарик
Идет 2018 год, модные пацаны давно уже верстают на grid, а я все на третьем бутстрапе сижу с **col-md** кочерячусь, мельком поглядывая на четвертый.
Решил я, что это не дело, и стоит немного знания освежить, но у **grid** вроде как поддержка пока хромает, а вот **flex** технологию уже даже утюги поддерживают.
Вот и решил его освоить. И процессом усвоения с вами поделится. В общем, будем верстать календарик на весь год.
Нам потребуется
* vue
* ~~клей~~ moment
* и чуток flex
Результат будет выглядеть примерно вот так:
Так получилось, что я адепт **vue**, и поэтому для рендера буду использовать его. Для работы с датами буду использовать библиотечку **moment**, можно и без нее обойтись, но мне с ней привычнее.
Подготовка
----------
Устанавливаем **vue-cli**, если у вас её еще нет:
```
npm install -g vue-cli
```
создаем проект на базе шаблона **webpack-simple**, я буду использовать **scss** (в основном для комментов), поэтому когда визард спросит вас
```
? Use sass? (y/N)
```
ответьте y(es), в общем запускаем:
```
vue-init webpack-simple calendar_flex
cd calendar_flex
npm install
```
добавим библиотечку **moment.js**
```
npm install -S moment
```
очищаем файлик **App.vue**
```
export default {
name: 'app',
data () {
return {
}
}
}
```
Чтоб не показаться варваром, не будем просто верстать голый календарь, а разработаем отдельную компоненту.
Создадим файлик **Calendar.vue**:
```
Календарь
export default {
props: {
year: { // год на который строится календарь
type: Number,
default: (new Date()).getFullYear()
},
},
data () {
return {}
}
}
```
подключим компоненту глобально в **main.js**
```
import Vue from 'vue'
import App from './App.vue'
import Calendar from './Calendar.vue'
Vue.component("calendar", Calendar);
new Vue({
el: '#app',
render: h => h(App)
})
```
добавим компоненту в App.vue
```
...
```
Если все верно сделали, то увидим слово "Календарь" на белом фоне.
Готовим данные
--------------
Прежде чем что-то рисовать надо подготовить данные для календаря. Я предлагаю упихать данные по году в массив из месяцев. В свою очередь, каждый месяц будет представлять собой объект вида:
```
{
title: 'Январь',
weeks: {1: {}, 2: {}, ...}
}
```
то бишь название месяца и массив из недель. Каждая неделя будет представлять собой объект где к каждому дню (от 1 до 7) будет привязана дата и может еще какая-нибудь мета информация:
```
week = {
1: {date: new Date(), ...}, // понедельник
2: {date: new Date(), ...}, // вторник
...
}
```
переключимся на файлик **Calendar.vue**, и обновим часть ответственную за скрипт:
```
import moment from 'moment';
export default {
...
computed: {
yearData() {
let data = [];
for (let m = 0; m < 12; ++m) {
// формируем дату на первый день каждого месяца
let day = moment({year: this.year, month: m, day: 1});
let daysInMonth = day.daysInMonth(); // количество дней в месяце
let month = { // готовим объект месяца
title: day.format("MMMM"),
weeks: {},
};
// итерируем по количеству дней в месяце
for (let d = 0; d < daysInMonth; ++d) {
let week = day.week();
// небольшой хак, момент считает
// последние дни декабря за первую неделю,
// но мне надо чтобы считалось за 53
if (m === 11 && week === 1) {
week = 53
}
// если неделя еще не присутствует в месяце, то добавляем ее
if (!month.weeks.hasOwnProperty(week)) {
month.weeks[week] = {}
}
// добавляем день, у weekday() нумерация с нуля,
// поэтому добавляю единицу, можно и не добавлять,
// но так будет удобнее
month.weeks[week][day.weekday() + 1] = {
date: day.toDate(),
};
// итерируем день на единицу, moment мутирует исходное значение
day.add(1, 'd');
}
// добавлям данные по месяцу в год
data.push(month);
}
return data
}
}
...
}
```
Можно заглянуть в **vue-devtools** и увидеть там:
Верстаем
--------
Ну давайте чего-нибудь уже выведем. Сначала научимся верстать один месяц, а потом, как освоимся, выведем все остальные. В общем, правим шаблон **Calendar.vue**:
```
{{yearData[0].title}}
{{week[day].date.getDate()}}
```
Сначала заставим отображать даты в нашей неделе в ряд, для этого поправим стиль:
```
.week {
display: flex;
}
```
теперь укажем, что каждый день должен занимать одинаковое количество места в нашем ряду:
```
.week {
display: flex;
}
.day {
flex-grow: 1;
}
```
Ну вроде поприличнее стало, только цифры таки скачут. Происходит это потому, что **flex-grow** по сути распределяет пустое пространство, а текст цифр в это пустое пространство не входит, поэтому, чтобы ячейки с цифрами стали действительно равными надо указать в стиле, чтобы ширина текста не учитывалась. Для этого установим свойству **flex-basis** на ноль.
Если не совсем понятно что я говорю, попробуйте поизучать данную картинку:
Ну как? Правим стиль:
```
.week {
display: flex;
}
.day {
flex-grow: 1;
flex-basis: 0;
}
```
от теперь красота
Я думаю мы теперь готовы к тому, чтобы попробовать вывести все месяцы, правим шаблон:
```
{{month.title}}
{{week[day].date.getDate()}}
```
Отлично, у нас уже своего рода респонсивный календарь:
Но нам этого мало, у нас календарь отображается в столбик, как завещал дедушка **div**, а нам бы в строчку… Сделаем по аналоги. Только что мы каждую неделю назначили **flex** контейнером для ее дней. А теперь наш блок year назначим **flex** контейнером для его месяцев. Добавим стили:
```
.week {...}
.day {...}
.year {
display: flex;
}
.month {
flex-grow: 1;
flex-basis: 0;
}
```
чет, каша какая-та:
причина сей каши в том, что по умолчанию **flex** не делает переносов, а пытается все отобразить в одну строчку, ну и соответственно сжимает покуда сил хватает, а их не хватает. Чтобы включить режим переносов, надо в нашем контейнер year добавить свойство **flex-wrap**, сделаем это:
```
.week {...}
.day {...}
.year {
display: flex;
flex-wrap: wrap; // добавили
}
.month {...}
```
Ну, эээ… типа получше стало, хотя б переносит:
Тут воздух маловато, но нам кстати так даже интереснее. Очевидно, что лучше всего чувствуют себя ноябрь и декабрь, но так как мы за равенство, то давайте ужмем их, чтобы сильно не выделялись.
Чтобы ужать, надо убрать **flex-grow: 1** у month, (ток добавили, теперь удалять...), который отвечает за растяжение в рамках строки:
```
...
.month {
flex-basis: 0;
}
```
За то как будут располагаться последние два (на самом деле не только за них) висящих элемента отвечает **justify-content** в стиле контейнере, по умолчанию он равен **flex-start**. Можно выровнять в конец.
```
.week {...}
.day {...}
.year {
display: flex;
flex-wrap: wrap;
justify-content: flex-end; // выровнять в конец
}
.month {...}
```
Вот гифка с разными значениями:
Так как я планирую, что у меня будет всегда одинаковое количество месяцев в строке, и хочу чтобы они занимали все свободное место, то я пожалуй верну **flex-grow: 1**; обратно, и добавлю немного воздуха:
```
.week {...}
.day {
margin: 0.25em; // воздух
flex-grow: 1;
flex-basis: 0;
}
.year {
display: flex;
flex-wrap: wrap;
}
.month {
margin: 0.25em; // воздух
flex-basis: 0;
flex-grow: 1; // вернул обратно
}
```
красота:
Еще раз вернусь к **justify-content** и **flex-grow: 1**. Сравните две гифки, на первой у month **flex-grow = 1**, на второй — свойство отсутствует:
Какой вариант вам больше по душе, решайте сами.
Добавим строчку с днями недели. Сначала добавим вычислимое свойство в скрипт
```
export default {
...
computed: {
weekDays () { // дни недели
let days = [];
for(let i = 1; i<=7;++i) {
days.push(moment().isoWeekday(i).format("dd"))
}
return days;
},
...
}
}
```
а теперь отобразим их в шаблоне:
```
{{month.title}}
{{d}}
{{week[day].date.getDate()}}
```
Я хочу чтобы воскресенье у меня было красненькое, давайте добавим динамический стиль к узлу **.day**:
```
...
{{week[day].date.getDate()}}
```
А теперь подкорректируем стили, чуток красоты наведем:
```
.title { // новый стиль под название месяца
margin: 0.25em;
font-weight: bold;
}
.week-day-7 { // воскресенье
color: red;
}
...
```
Ну и последние штрихи: добавим возможность менять год и сделаем фиксированный заголовок средствами **flex**.
Переключимся на **App.vue** файл, и откорректируем шаблон:
```
{{year}}
```
добавилась строчка с годом, пока, как видно, не фиксированная:
Подправим стили в **App.vue**, уберем отступы в **body**, установим высоту **html** и **body** на всю высоту окна, и сделаем заголовок покрасивше, я намеренно использую два узла **style**, один для глобальных стилей второй для локальных:
```
html {
height: 100%;
}
body {
height: 100%;
margin: 0;
}
.title {
font-weight: bold;
font-size: 1.5em;
margin: 0.25em;
text-align: center;
}
```
Идея создания фиксированного заголовка на **flex** заключается в использовании двух вложенных контейнеров flex, один из которых ограничивает высоту всего содержимого, а второй, вложенный, использует **flex-direction: column**.
Правим стиль:
```
.title {...}
.wrapper { // ограничивает высоту
display: flex;
height: 100%; // тут я указываю высоту по высоте родительского узла, в нашем случае 'это тег body
}
.content { // непосредственный контейнер с заголовком и содержимым
display: flex;
flex-direction: column;
}
.body { // основное тело контейнера
flex-grow: 1; // растягивается, чтобы заполнить все пространство
overflow-y: auto; // скролл, если не влезает
}
```
Классно, да? Вы можете даже сделать футер:
```
{{year}}
{{year}}
```
Ну и давайте кнопки для переключения года добавим:
```
<
{{year}}
>
{{year}}
```
Воспользуемся уже полученными знаниями, и сделаем заголовок более flex-образным, правим стили:
```
.title {...}
.header {
padding: 0.25em;
display: flex;
justify-content: space-between;
}
.wrapper {...}
.content {...}
.body {...}
```
Хм… что-то тут не так. Чет наши заголовки прям сдавило и верстка поплыла. К сожалению это тот момент, который я не до конца понял почему так произошло. Но как я полагаю, это из-за того что **display: flex** задает динамическую высоту, и находясь внутри другого **flex** контейнера, ориентируется на размеры заданные своим родителем.
В общем, чтобы это вылечить, надо запретить **flex** контейнеру внутри которого находится наш header сжимать его размеры, для этого добавим свойство **flex-shrink**:
```
.title {...}
.header {
padding: 0.25em;
display: flex;
flex-shrink: 0; // не сжимай меня
justify-content: space-between;
}
.wrapper {...}
.content {...}
.body {...}
```
Ну вот и все, теперь у вас есть flex-календарь на любой год!
В это статье не удалось показать все возможности **flex**, но общий подход работы с ним, думаю, отразить получилось.
Я надеюсь, что статья поможет тем, кто как и я застрял в css-временах где-то между 3-м и 4-м бутстрапом, сделать свои первые шаги навстречу современному css.
[Код примера доступен по адресу](https://github.com/SevenLines/CalendarFlex). | https://habr.com/ru/post/353664/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.